diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,7 @@
+# 0.5.2 [2019.04.26]
+* Support `th-abstraction-0.3.0.0` or later.
+* Only incur a `semigroups` dependency on old GHCs.
+
 # 0.5.1 [2018.07.15]
 * Depend on `QuickCheck-2.11` or later in the test suite.
 * Some Haddock fixes in `Data.Functor.Invariant.TH`.
diff --git a/invariant.cabal b/invariant.cabal
--- a/invariant.cabal
+++ b/invariant.cabal
@@ -1,5 +1,5 @@
 name:                invariant
-version:             0.5.1
+version:             0.5.2
 synopsis:            Haskell98 invariant functors
 description:         Haskell98 invariant functors (also known as exponential functors).
                      .
@@ -24,8 +24,8 @@
                    , GHC == 7.10.3
                    , GHC == 8.0.2
                    , GHC == 8.2.2
-                   , GHC == 8.4.3
-                   , GHC == 8.6.1
+                   , GHC == 8.4.4
+                   , GHC == 8.6.4
 extra-source-files:  CHANGELOG.md, README.md
 
 source-repository head
@@ -46,16 +46,18 @@
                      , contravariant        >= 0.5    && < 2
                      , ghc-prim
                      , profunctors          >= 5.2.1  && < 6
-                     , semigroups           >= 0.16.2 && < 1
                      , StateVar             >= 1.1    && < 2
                      , stm                  >= 2.2    && < 3
                      , tagged               >= 0.7.3  && < 1
                      , template-haskell     >= 2.4    && < 2.15
-                     , th-abstraction       >= 0.2.2  && < 1
+                     , th-abstraction       >= 0.2.2  && < 0.4
                      , transformers         >= 0.2    && < 0.6
                      , transformers-compat  >= 0.3    && < 1
                      , unordered-containers >= 0.2.4  && < 0.3
   ghc-options:         -Wall
+
+  if !impl(ghc >= 8.0)
+    build-depends:     semigroups           >= 0.16.2 && < 1
 
 test-suite spec
   type:                exitcode-stdio-1.0
diff --git a/src/Data/Functor/Invariant/TH.hs b/src/Data/Functor/Invariant/TH.hs
--- a/src/Data/Functor/Invariant/TH.hs
+++ b/src/Data/Functor/Invariant/TH.hs
@@ -269,26 +269,30 @@
 deriveInvariantClass iClass opts name = do
   info <- reifyDatatype name
   case info of
-    DatatypeInfo { datatypeContext = ctxt
-                 , datatypeName    = parentName
-                 , datatypeVars    = vars
-                 , datatypeVariant = variant
-                 , datatypeCons    = cons
+    DatatypeInfo { datatypeContext   = ctxt
+                 , datatypeName      = parentName
+#if MIN_VERSION_th_abstraction(0,3,0)
+                 , datatypeInstTypes = instTys
+#else
+                 , datatypeVars      = instTys
+#endif
+                 , datatypeVariant   = variant
+                 , datatypeCons      = cons
                  } -> do
       (instanceCxt, instanceType)
-        <- buildTypeInstance iClass parentName ctxt vars variant
+        <- buildTypeInstance iClass parentName ctxt instTys variant
       (:[]) `fmap` instanceD (return instanceCxt)
                              (return instanceType)
-                             (invmapDecs iClass opts parentName vars cons)
+                             (invmapDecs iClass opts parentName instTys cons)
 
 -- | Generates a declaration defining the primary function corresponding to a
 -- particular class (invmap for Invariant and invmap2 for Invariant2).
 invmapDecs :: InvariantClass -> Options -> Name -> [Type] -> [ConstructorInfo]
            -> [Q Dec]
-invmapDecs iClass opts parentName vars cons =
+invmapDecs iClass opts parentName instTys cons =
     [ funD (invmapName iClass)
            [ clause []
-                    (normalB $ makeInvmapForCons iClass opts parentName vars cons)
+                    (normalB $ makeInvmapForCons iClass opts parentName instTys cons)
                     []
            ]
     ]
@@ -299,29 +303,33 @@
 makeInvmapClass iClass opts name = do
   info <- reifyDatatype name
   case info of
-    DatatypeInfo { datatypeContext = ctxt
-                 , datatypeName    = parentName
-                 , datatypeVars    = vars
-                 , datatypeVariant = variant
-                 , datatypeCons    = cons
+    DatatypeInfo { datatypeContext   = ctxt
+                 , datatypeName      = parentName
+#if MIN_VERSION_th_abstraction(0,3,0)
+                 , datatypeInstTypes = instTys
+#else
+                 , datatypeVars      = instTys
+#endif
+                 , datatypeVariant   = variant
+                 , datatypeCons      = cons
                  } ->
       -- We force buildTypeInstance here since it performs some checks for whether
       -- or not the provided datatype can actually have invmap/invmap2
       -- implemented for it, and produces errors if it can't.
-      buildTypeInstance iClass parentName ctxt vars variant
-        >> makeInvmapForCons iClass opts parentName vars cons
+      buildTypeInstance iClass parentName ctxt instTys variant
+        >> makeInvmapForCons iClass opts parentName instTys cons
 
 -- | Generates a lambda expression for invmap(2) for the given constructors.
 -- All constructors must be from the same type.
 makeInvmapForCons :: InvariantClass -> Options -> Name -> [Type] -> [ConstructorInfo]
                   -> Q Exp
-makeInvmapForCons iClass opts _parentName vars cons = do
+makeInvmapForCons iClass opts _parentName instTys cons = do
     value      <- newName "value"
     covMaps    <- newNameList "covMap" numNbs
     contraMaps <- newNameList "contraMap" numNbs
 
     let mapFuns    = zip covMaps contraMaps
-        lastTyVars = map varTToName $ drop (length vars - fromEnum iClass) vars
+        lastTyVars = map varTToName $ drop (length instTys - fromEnum iClass) instTys
         tvMap      = Map.fromList $ zip lastTyVars mapFuns
         argNames   = concat (transpose [covMaps, contraMaps]) ++ [value]
     lamE (map varP argNames)