diff --git a/Generics/RepLib/Derive.hs b/Generics/RepLib/Derive.hs
--- a/Generics/RepLib/Derive.hs
+++ b/Generics/RepLib/Derive.hs
@@ -48,6 +48,10 @@
 
 import Unsafe.Coerce
 
+#if MIN_VERSION_template_haskell(2,11,0)
+import Control.Monad.Fail ( MonadFail )
+#endif
+
 -- | Given a type, produce its representation.
 repty :: Type -> Exp
 repty ty = SigE (VarE (mkName "rep")) ((ConT ''R) `AppT` ty)
@@ -81,12 +85,14 @@
 -- while generating constructor representations.
 
 newtype QN a = QN { unQN :: WriterT (S.Set Int) Q a }
+  deriving ( Monad, Functor, MonadWriter (S.Set Int)
+#if MIN_VERSION_template_haskell(2,11,0)
+           , MonadFail
+#endif
 #if MIN_VERSION_template_haskell(2,7,0)
-  deriving (Applicative, Functor, Monad, MonadWriter (S.Set Int))
-#else
-  deriving (Functor, Monad, MonadWriter (S.Set Int))
+           , Applicative
 #endif
-
+           )
 
 liftQN :: Q a -> QN a
 liftQN = QN . lift
@@ -119,6 +125,12 @@
   qGetQ                 = liftQN $ qGetQ
   qPutQ a               = liftQN $ qPutQ a
 #endif
+#if MIN_VERSION_template_haskell(2,11,0)
+  qReifyFixity n        = liftQN $ qReifyFixity n
+  qReifyConStrictness n = liftQN $ qReifyConStrictness n
+  qIsExtEnabled e       = liftQN $ qIsExtEnabled e
+  qExtsEnabled          = liftQN $ qExtsEnabled
+#endif
 
 -- Generate the representation for a data constructor.
 -- As our representation of data constructors evolves, so must this definition.
@@ -296,14 +308,16 @@
                                                           `AppT` ty))
                       rType :: Dec
                       rType = ValD (VarP rTypeName) (NormalB body) []
-                  let inst  = InstanceD ctx ((ConT (mkName "Rep")) `AppT` ty)
+                  let inst  = InstanceD
+#if MIN_VERSION_template_haskell(2,11,0)
+                                 Nothing
+#endif
+                                 ctx
+                                 ((ConT (mkName "Rep")) `AppT` ty)
                                  [ValD (VarP (mkName "rep")) (NormalB (VarE rTypeName)) []]
 
                   return $ ress ++ [rSig, rType, inst]
 
-reprs :: Flag -> [Name] -> Q [Dec]
-reprs f ns = concat <$> mapM (repr f) ns
-
 --------------------------------------------------------------------------------------------
 --- Generating the R1 representation
 
@@ -338,7 +352,7 @@
                          , cpTyVars  :: [Name]          -- /All/ type variable arguments to the type
                                                         -- (not just ones requiring equality proofs);
                                                         -- needed when generating special Sat classes
-                         , cpPayload :: Type            -- What you get after supplying
+                         , _cpPayload :: Type            -- What you get after supplying
                                                         -- the proofs
                          , cpPayloadElts :: [Type]      -- individual elements in
                                                         -- the payload
@@ -425,6 +439,9 @@
                        Nothing -> VarT a
 
       satInst  = InstanceD
+#if MIN_VERSION_template_haskell(2,11,0)
+                   Nothing
+#endif
 #if MIN_VERSION_template_haskell(2,10,0)
                    (map (\x -> AppT (ConT ''Sat) x) (cpPayloadElts ctxParam))
 #else
@@ -445,7 +462,11 @@
   nms <- replicateM (length tvs) (newName "a")
   err <- [| error "Impossible Sat instance!" |]
 
-  let defSatInst = InstanceD [] (foldl' AppT (ConT satNm) (map VarT (ctx : nms)))
+  let defSatInst = InstanceD
+#if MIN_VERSION_template_haskell(2,11,0)
+                     Nothing
+#endif
+                     [] (foldl' AppT (ConT satNm) (map VarT (ctx : nms)))
                      [ValD (VarP dictNm)
                            (NormalB (LamE (replicate (length eqs) (ConP 'Refl [])) err))
                            []
@@ -573,22 +594,34 @@
 
 typeInfo :: Dec -> TypeInfo
 typeInfo d = case d of
-    (DataD _ _ _ _ _) ->
+    (DataD {}) ->
       TypeInfo (getName d) (paramsA d) (consA d)
-    (NewtypeD _ _ _ _ _) ->
+    (NewtypeD {}) ->
       TypeInfo (getName d) (paramsA d) (consA d)
     _ -> error ("derive: not a data type declaration: " ++ show d)
 
   where
-    getName (DataD _ n _ _ _)     = n
-    getName (NewtypeD _ n _ _ _)  = n
-    getName x                     = error $ "Impossible! " ++ show x ++ " is neither data nor newtype"
+#if MIN_VERSION_template_haskell(2,11,0)
+    getName (DataD _ n _ _ _ _)    = n
+    getName (NewtypeD _ n _ _ _ _) = n
+    getName x                      = error $ "Impossible! " ++ show x ++ " is neither data nor newtype"
 
+    paramsA (DataD _ _ ps _ _ _)    = ps
+    paramsA (NewtypeD _ _ ps _ _ _) = ps
+
+    consA (DataD _ _ _ _ cs _)      = rememberOnly $ map conA cs
+    consA (NewtypeD _ _ _ _ c _)    = rememberOnly $ [ conA c ]
+#else
+    getName (DataD _ n _ _ _)      = n
+    getName (NewtypeD _ n _ _ _)   = n
+    getName x                      = error $ "Impossible! " ++ show x ++ " is neither data nor newtype"
+
     paramsA (DataD _ _ ps _ _)    = ps
     paramsA (NewtypeD _ _ ps _ _) = ps
 
     consA (DataD _ _ _ cs _)      = rememberOnly $ map conA cs
     consA (NewtypeD _ _ _ c _)    = rememberOnly $ [ conA c ]
+#endif
 
     conA (NormalC c xs)           = (mkConstr c)
                                       { constrFields  = map normalField xs }
@@ -603,7 +636,14 @@
                                     in  c' { constrBinders = bdrs ++ constrBinders c'
                                            , constrCxt = cx ++ constrCxt c'
                                            }
+#if MIN_VERSION_template_haskell(2,11,0)                                        
+    conA (GadtC [c] xs ty)        = (mkConstr c)
+                                      { constrFields = map normalField xs }
 
+    conA (RecGadtC [c] xs ty)     = (mkConstr c)
+                                      { constrFields = map recField xs }
+#endif
+
     normalField x                 = FieldInfo
                                     { fieldName = Nothing
                                     , fieldType = snd x
@@ -669,6 +709,9 @@
 deriveResData :: Int -> Name -> Name -> [Name] -> Dec
 deriveResData n c a bs =
   DataD [] (mkName $ "Res" ++ show n) (map PlainTV [c,a])
+#if MIN_VERSION_template_haskell(2,11,0)
+        Nothing
+#endif
         [deriveResultCon n c a bs, deriveNoResultCon n] []
 
 deriveResultCon :: Int -> Name -> Name -> [Name] -> TH.Con
@@ -681,8 +724,14 @@
       (map (ClassP ''Rep . (:[]) . VarT) bs)
 #endif
       (NormalC (mkName $ "Result" ++ show n)
-        [(NotStrict, deriveResultEq c a bs)]
+        [(notStrict, deriveResultEq c a bs)]
       )
+  where
+#if MIN_VERSION_template_haskell(2,11,0)
+    notStrict = Bang NoSourceUnpackedness NoSourceStrictness
+#else
+    notStrict = NotStrict
+#endif
 
 deriveResultEq :: Name     -- Tyvar representing the type to be deconstructed
                -> Name     -- Constructor tyvar
@@ -767,4 +816,3 @@
 appsT :: Type -> [Name] -> Type
 appsT t []     = t
 appsT t (n:ns) = appsT (AppT t (VarT n)) ns
-
diff --git a/Generics/RepLib/R.hs b/Generics/RepLib/R.hs
--- a/Generics/RepLib/R.hs
+++ b/Generics/RepLib/R.hs
@@ -1,5 +1,5 @@
 {-# LANGUAGE TemplateHaskell, UndecidableInstances, ExistentialQuantification,
-    TypeOperators, GADTs, TypeSynonymInstances, FlexibleInstances,
+    RankNTypes, TypeOperators, GADTs, TypeSynonymInstances, FlexibleInstances,
     ScopedTypeVariables, CPP
  #-}
 -----------------------------------------------------------------------------
@@ -17,6 +17,8 @@
 
 module Generics.RepLib.R where
 
+import Unsafe.Coerce
+
 import Data.Type.Equality
 
 -- | A value of type @R a@ is a representation of a type @a@.
@@ -82,6 +84,11 @@
 
 -- | A class of representable types
 class Rep a where rep :: R a
+
+-- | Use a concrete @'R' a@ for a @'Rep' a@ dictionary
+withRep :: R a -> (Rep a => r) -> r
+withRep = unsafeCoerce (flip ($) :: R a -> (R a -> r) -> r)
+-- I think there's some contraint machinery that could hide the unsafeness here
 
 ------ Showing representations  (rewrite this with showsPrec?)
 
diff --git a/RepLib.cabal b/RepLib.cabal
--- a/RepLib.cabal
+++ b/RepLib.cabal
@@ -1,5 +1,5 @@
 name:           RepLib
-version:        0.5.3.5
+version:        0.5.4
 license:        BSD3
 license-file:   LICENSE
 build-type:     Simple
@@ -10,7 +10,8 @@
                 GHC == 7.6.1,
                 GHC == 7.8.1,
                 GHC == 7.8.3,
-                GHC == 7.10.2
+                GHC == 7.10.2,
+                GHC == 8.0.1
 author:         Stephanie Weirich
 maintainer:     Stephanie Weirich <sweirich@cis.upenn.edu>
 homepage:       https://github.com/sweirich/replib
@@ -26,7 +27,7 @@
 
 Library
   build-depends: base >= 4.3 && < 5,
-                 template-haskell >= 2.4 && < 2.11,
+                 template-haskell >= 2.4 && < 2.12,
                  mtl >= 2.0 && < 2.3,
                  containers >= 0.4 && < 0.6,
                  transformers