diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,10 @@
+### 0.7.0
+
+* Support for GHC 8.2
+* Support use in a dynamically-linked executable
+* Add `normalizeType`, like ghci's :kind!
+* Drop support for GHC 7.6
+
 ### 0.6.0
 
 * Support for GHC 8.0
diff --git a/hint.cabal b/hint.cabal
--- a/hint.cabal
+++ b/hint.cabal
@@ -1,5 +1,5 @@
 name:         hint
-version:      0.6.0
+version:      0.7.0
 description:
         This library defines an Interpreter monad. It allows to load Haskell
         modules, browse them, type-check and evaluate strings with Haskell
@@ -30,7 +30,7 @@
   type:     git
   location: https://github.com/mvdan/hint
 
-Test-Suite unit-tests
+test-suite unit-tests
   type:           exitcode-stdio-1.0
   hs-source-dirs: unit-tests
   main-is:        run-unit-tests.hs
@@ -43,9 +43,9 @@
                   extensible-exceptions,
                   exceptions
 
-Library
+library
   build-depends: base == 4.*,
-                 ghc >= 7.6 && < 8.2,
+                 ghc >= 7.6 && < 8.4,
                  ghc-paths,
                  mtl,
                  filepath,
@@ -63,7 +63,6 @@
   other-modules:   Hint.GHC
                    Hint.Base
                    Hint.InterpreterT
-                   Hint.Compat
                    Hint.CompatPlatform
                    Hint.Configuration
                    Hint.Extension
diff --git a/src/Control/Monad/Ghc.hs b/src/Control/Monad/Ghc.hs
--- a/src/Control/Monad/Ghc.hs
+++ b/src/Control/Monad/Ghc.hs
@@ -38,12 +38,6 @@
 instance MTL.MonadIO m => MTL.MonadIO (GhcT m) where
     liftIO = GhcT . GHC.liftIO
 
-#if __GLASGOW_HASKELL__ < 708
-  -- ghc started using transformers at some point
-instance MTL.MonadIO m => GHC.MonadIO (GhcT m) where
-    liftIO = MTL.liftIO
-#endif
-
 instance MonadCatch m => MonadThrow (GhcT m) where
     throwM = lift . throwM
 
diff --git a/src/Hint/Base.hs b/src/Hint/Base.hs
--- a/src/Hint/Base.hs
+++ b/src/Hint/Base.hs
@@ -34,9 +34,9 @@
 
 -- | Version of the underlying ghc api. Values are:
 --
--- * @708@ for GHC 7.8.x
---
 -- * @710@ for GHC 7.10.x
+--
+-- * @800@ for GHC 8.0.x
 --
 -- * etc...
 ghcVersion :: Int
diff --git a/src/Hint/Compat.hs b/src/Hint/Compat.hs
deleted file mode 100644
--- a/src/Hint/Compat.hs
+++ /dev/null
@@ -1,34 +0,0 @@
-module Hint.Compat where
-
-import qualified Hint.GHC as GHC
-
--- Kinds became a synonym for Type in GHC 6.8. We define this wrapper
--- to be able to define a FromGhcRep instance for both versions
-newtype Kind = Kind GHC.Kind
-
-supportedExtensions :: [String]
-supportedExtensions = map f GHC.xFlags
-    where
-#if (__GLASGOW_HASKELL__ >= 710)
-      f = GHC.flagSpecName
-#else
-      f (e,_,_) = e
-#endif
-
-configureDynFlags :: GHC.DynFlags -> GHC.DynFlags
-configureDynFlags dflags = dflags{GHC.ghcMode    = GHC.CompManager,
-                                  GHC.hscTarget  = GHC.HscInterpreted,
-                                  GHC.ghcLink    = GHC.LinkInMemory,
-                                  GHC.verbosity  = 0}
-
-parseDynamicFlags :: GHC.GhcMonad m
-                  => GHC.DynFlags -> [String] -> m (GHC.DynFlags, [String])
-parseDynamicFlags d = fmap firstTwo . GHC.parseDynamicFlags d . map GHC.noLoc
-    where firstTwo (a,b,_) = (a, map GHC.unLoc b)
-
-pprType :: GHC.Type -> GHC.SDoc
-#if __GLASGOW_HASKELL__ < 708
-pprType = GHC.pprTypeForUser False -- False means drop explicit foralls
-#else
-pprType = GHC.pprTypeForUser
-#endif
diff --git a/src/Hint/Configuration.hs b/src/Hint/Configuration.hs
--- a/src/Hint/Configuration.hs
+++ b/src/Hint/Configuration.hs
@@ -8,7 +8,10 @@
       languageExtensions, availableExtensions, Extension(..),
       installedModulesInScope,
 
-      searchPath
+      searchPath,
+
+      configureDynFlags, parseDynamicFlags,
+
 ) where
 
 import Control.Monad
@@ -17,7 +20,6 @@
 import Data.List (intercalate)
 
 import qualified Hint.GHC as GHC
-import qualified Hint.Compat as Compat
 import Hint.Base
 import Hint.Util (quote)
 
@@ -26,7 +28,7 @@
 setGhcOptions :: MonadInterpreter m => [String] -> m ()
 setGhcOptions opts =
     do old_flags <- runGhc GHC.getSessionDynFlags
-       (new_flags,not_parsed) <- runGhc2 Compat.parseDynamicFlags old_flags opts
+       (new_flags,not_parsed) <- runGhc2 parseDynamicFlags old_flags opts
        unless (null not_parsed) $
             throwM $ UnknownError
                             $ concat ["flags: ", unwords $ map quote not_parsed,
@@ -127,3 +129,16 @@
        => (InterpreterConfiguration -> InterpreterConfiguration)
        -> m ()
 onConf f = onState $ \st -> st{configuration = f (configuration st)}
+
+configureDynFlags :: GHC.DynFlags -> GHC.DynFlags
+configureDynFlags dflags =
+    (if GHC.dynamicGhc then GHC.addWay' GHC.WayDyn else id)
+                           dflags{GHC.ghcMode    = GHC.CompManager,
+                                  GHC.hscTarget  = GHC.HscInterpreted,
+                                  GHC.ghcLink    = GHC.LinkInMemory,
+                                  GHC.verbosity  = 0}
+
+parseDynamicFlags :: GHC.GhcMonad m
+                  => GHC.DynFlags -> [String] -> m (GHC.DynFlags, [String])
+parseDynamicFlags d = fmap firstTwo . GHC.parseDynamicFlags d . map GHC.noLoc
+    where firstTwo (a,b,_) = (a, map GHC.unLoc b)
diff --git a/src/Hint/Conversions.hs b/src/Hint/Conversions.hs
--- a/src/Hint/Conversions.hs
+++ b/src/Hint/Conversions.hs
@@ -5,7 +5,6 @@
 import qualified Hint.GHC as GHC
 
 import Hint.Base
-import qualified Hint.Compat as Compat
 
 -- --------- Types / Kinds -----------------------
 
@@ -15,12 +14,12 @@
       -- (i.e., do not expose internals)
       unqual <- runGhc GHC.getPrintUnqual
       withDynFlags $ \df ->
-        return $ GHC.showSDocForUser df unqual (Compat.pprType t)
+        return $ GHC.showSDocForUser df unqual (GHC.pprTypeForUser t)
 
-kindToString :: MonadInterpreter m => Compat.Kind -> m String
-kindToString (Compat.Kind k)
+kindToString :: MonadInterpreter m => GHC.Kind -> m String
+kindToString k
  = withDynFlags $ \df ->
-     return $ GHC.showSDoc df (Compat.pprType k)
+     return $ GHC.showSDoc df (GHC.pprTypeForUser k)
 
 -- ---------------- Modules --------------------------
 
diff --git a/src/Hint/Extension.hs b/src/Hint/Extension.hs
--- a/src/Hint/Extension.hs
+++ b/src/Hint/Extension.hs
@@ -1,14 +1,23 @@
 -- this module was automatically generated. do not edit!
 -- edit util/mk_extensions_mod.hs instead
 module Hint.Extension (
-    Extension(..), availableExtensions, asExtension
+    Extension(..), supportedExtensions, availableExtensions, asExtension
 ) where
 
-import Hint.Compat as Compat
+import qualified Hint.GHC as GHC
 
+supportedExtensions :: [String]
+supportedExtensions = map f GHC.xFlags
+    where
+#if (__GLASGOW_HASKELL__ >= 710)
+      f = GHC.flagSpecName
+#else
+      f (e,_,_) = e
+#endif
+
 -- | List of the extensions known by the interpreter.
 availableExtensions :: [Extension]
-availableExtensions = map asExtension Compat.supportedExtensions
+availableExtensions = map asExtension supportedExtensions
 
 asExtension :: String -> Extension
 asExtension s = if isKnown s
@@ -139,6 +148,7 @@
                | MonadFailDesugaring
                | TemplateHaskellQuotes
                | OverloadedLabels
+               | TypeFamilyDependencies
                | NoOverlappingInstances
                | NoUndecidableInstances
                | NoIncoherentInstances
@@ -257,6 +267,7 @@
                | NoMonadFailDesugaring
                | NoTemplateHaskellQuotes
                | NoOverloadedLabels
+               | NoTypeFamilyDependencies
                | UnknownExtension String
         deriving (Eq, Show, Read)
 
@@ -379,6 +390,7 @@
                    MonadFailDesugaring,
                    TemplateHaskellQuotes,
                    OverloadedLabels,
+                   TypeFamilyDependencies,
                    NoOverlappingInstances,
                    NoUndecidableInstances,
                    NoIncoherentInstances,
@@ -496,5 +508,6 @@
                    NoUndecidableSuperClasses,
                    NoMonadFailDesugaring,
                    NoTemplateHaskellQuotes,
-                   NoOverloadedLabels
+                   NoOverloadedLabels,
+                   NoTypeFamilyDependencies
                    ]
diff --git a/src/Hint/GHC.hs b/src/Hint/GHC.hs
--- a/src/Hint/GHC.hs
+++ b/src/Hint/GHC.hs
@@ -25,11 +25,15 @@
 import DynFlags as X (xFlags, xopt, LogAction)
 #endif
 
+#if __GLASGOW_HASKELL__ >= 800
+import DynFlags as X (WarnReason(NoReason))
+#endif
+
 import PprTyThing as X (pprTypeForUser)
 import SrcLoc as X (mkRealSrcLoc)
 
-#if __GLASGOW_HASKELL__ >= 708
 import ConLike as X (ConLike(RealDataCon))
-#endif
+
+import DynFlags as X (addWay', Way(..), dynamicGhc)
 
 type Message = MsgDoc
diff --git a/src/Hint/InterpreterT.hs b/src/Hint/InterpreterT.hs
--- a/src/Hint/InterpreterT.hs
+++ b/src/Hint/InterpreterT.hs
@@ -25,7 +25,6 @@
 import qualified GHC.Paths
 
 import qualified Hint.GHC as GHC
-import qualified Hint.Compat as Compat
 
 type Interpreter = InterpreterT IO
 
@@ -84,8 +83,8 @@
        -- Set a custom log handler, to intercept error messages :S
        df0 <- runGhc GHC.getSessionDynFlags
 
-       let df1 = Compat.configureDynFlags df0
-       (df2, extra) <- runGhc2 Compat.parseDynamicFlags df1 args
+       let df1 = configureDynFlags df0
+       (df2, extra) <- runGhc2 parseDynamicFlags df1 args
        unless (null extra) $
             throwM $ UnknownError (concat [ "flags: '"
                                           , unwords extra
@@ -103,7 +102,7 @@
        let toOpt e     = let err = error ("init error: unknown ext:" ++ show e)
                          in fromMaybe err (lookup e extMap)
        let getOptVal e = (asExtension e, GHC.xopt (toOpt e) df2)
-       let defExts = map  getOptVal Compat.supportedExtensions
+       let defExts = map  getOptVal supportedExtensions
 
        onState (\s -> s{defaultExts = defExts})
 
diff --git a/src/Hint/Parsers.hs b/src/Hint/Parsers.hs
--- a/src/Hint/Parsers.hs
+++ b/src/Hint/Parsers.hs
@@ -8,10 +8,6 @@
 
 import qualified Hint.GHC as GHC
 
-#if __GLASGOW_HASKELL__ >= 800
-import qualified DynFlags as GHC
-#endif
-
 data ParseResult = ParseOk | ParseError GHC.SrcSpan GHC.Message
 
 parseExpr :: MonadInterpreter m => String -> m ParseResult
diff --git a/src/Hint/Reflection.hs b/src/Hint/Reflection.hs
--- a/src/Hint/Reflection.hs
+++ b/src/Hint/Reflection.hs
@@ -47,11 +47,7 @@
            (
              [asModElem df c | c@(GHC.ATyCon c') <- xs, GHC.isClassTyCon c'],
              [asModElem df t | t@(GHC.ATyCon c') <- xs, (not . GHC.isClassTyCon) c'],
-#if __GLASGOW_HASKELL__ < 708
-             [asModElem df d | d@GHC.ADataCon{} <- xs],
-#else
              [asModElem df d | d@(GHC.AConLike (GHC.RealDataCon{})) <- xs],
-#endif
              [asModElem df f | f@GHC.AnId{} <- xs]
            )
           cs' = [Class n $ filter (alsoIn fs) ms  | Class n ms  <- cs]
@@ -60,11 +56,7 @@
 
 asModElem :: GHC.DynFlags -> GHC.TyThing -> ModuleElem
 asModElem df (GHC.AnId f)      = Fun $ getUnqualName df f
-#if __GLASGOW_HASKELL__ < 708
-asModElem df (GHC.ADataCon dc) = Fun $ getUnqualName df dc
-#else
 asModElem df (GHC.AConLike (GHC.RealDataCon dc)) = Fun $ getUnqualName df dc
-#endif
 asModElem df (GHC.ATyCon tc)   =
   if GHC.isClassTyCon tc
   then Class (getUnqualName df tc) (map (getUnqualName df) $ (GHC.classMethods . fromJust . GHC.tyConClass_maybe) tc)
diff --git a/src/Hint/Typecheck.hs b/src/Hint/Typecheck.hs
--- a/src/Hint/Typecheck.hs
+++ b/src/Hint/Typecheck.hs
@@ -1,5 +1,5 @@
 module Hint.Typecheck (
-      typeOf, typeChecks, kindOf,
+      typeOf, typeChecks, kindOf, normalizeType
 ) where
 
 import Control.Monad.Catch
@@ -8,7 +8,6 @@
 import Hint.Parsers
 import Hint.Conversions
 
-import qualified Hint.Compat as Compat
 import qualified Hint.GHC as GHC
 
 -- | Returns a string representation of the type of the expression.
@@ -37,17 +36,34 @@
        -- kind of errors
        failOnParseError parseType type_expr
        --
-       kind <- mayFail $ runGhc1 typeKind type_expr
+       (_, kind) <- mayFail $ runGhc1 typeKind type_expr
        --
-       kindToString (Compat.Kind kind)
+       kindToString kind
 
+-- | Returns a string representation of the normalized type expression.
+-- This is what the @:kind!@ GHCi command prints after @=@.
+normalizeType :: MonadInterpreter m => String -> m String
+normalizeType type_expr =
+    do -- First, make sure the expression has no syntax errors,
+       -- for this is the only way we have to "intercept" this
+       -- kind of errors
+       failOnParseError parseType type_expr
+       --
+       (ty, _) <- mayFail $ runGhc1 typeKind type_expr
+       --
+       typeToString ty
+
 -- add a bogus Maybe, in order to use it with mayFail
 exprType :: GHC.GhcMonad m => String -> m (Maybe GHC.Type)
+#if __GLASGOW_HASKELL__ < 802
 exprType = fmap Just . GHC.exprType
+#else
+exprType = fmap Just . GHC.exprType GHC.TM_Inst
+#endif
 
 -- add a bogus Maybe, in order to use it with mayFail
-typeKind :: GHC.GhcMonad m => String -> m (Maybe GHC.Kind)
-typeKind = fmap (Just . snd) . GHC.typeKind True
+typeKind :: GHC.GhcMonad m => String -> m (Maybe (GHC.Type, GHC.Kind))
+typeKind = fmap Just . GHC.typeKind True
 
 onCompilationError :: MonadInterpreter m
                    => ([GhcError] -> m a)
diff --git a/src/Language/Haskell/Interpreter.hs b/src/Language/Haskell/Interpreter.hs
--- a/src/Language/Haskell/Interpreter.hs
+++ b/src/Language/Haskell/Interpreter.hs
@@ -34,7 +34,7 @@
     -- pragmas inline in the code since GHC scarfs them up.
     getModuleAnnotations, getValAnnotations,
     -- ** Type inference
-     typeOf, typeChecks, kindOf,
+     typeOf, typeChecks, kindOf, normalizeType,
     -- ** Evaluation
      interpret, as, infer, eval,
     -- * Error handling
diff --git a/src/Language/Haskell/Interpreter/Unsafe.hs b/src/Language/Haskell/Interpreter/Unsafe.hs
--- a/src/Language/Haskell/Interpreter/Unsafe.hs
+++ b/src/Language/Haskell/Interpreter/Unsafe.hs
@@ -38,7 +38,7 @@
 --   containers, etc.) can be found. This allows you to run hint on
 --   a machine in which GHC is not installed.
 --
---   A typical libdir value would be "/opt/ghc/7.10.3/lib/ghc-7.10.3".
+--   A typical libdir value could be "/usr/lib/ghc-8.0.1/ghc-8.0.1".
 unsafeRunInterpreterWithArgsLibdir :: (MonadIO m, MonadMask m
 #if __GLASGOW_HASKELL__ < 800
                                  , Functor m
diff --git a/unit-tests/run-unit-tests.hs b/unit-tests/run-unit-tests.hs
--- a/unit-tests/run-unit-tests.hs
+++ b/unit-tests/run-unit-tests.hs
@@ -200,6 +200,19 @@
         _ <- forkIO $ Control.Monad.void concurrent
         readMVar r @?  "concurrent instance did not fail"
 
+test_normalize_type :: TestCase
+test_normalize_type = TestCase "normalize_type" [mod_file] $ do
+        liftIO $ writeFile mod_file mod_text
+        loadModules [mod_file]
+        setTopLevelModules ["T"]
+        normalizeType "Foo Int" @@?= "()"
+
+    where mod_text = unlines ["{-# LANGUAGE TypeFamilies #-}"
+                             ,"module T where"
+                             ,"type family Foo x"
+                             ,"type instance Foo x = ()"]
+          mod_file = "TEST_NormalizeType.hs"
+
 tests :: [TestCase]
 tests = [test_reload_modified
         ,test_lang_exts
@@ -215,6 +228,7 @@
         ,test_search_path_dot
         ,test_catch
         ,test_only_one_instance
+        ,test_normalize_type
         ]
 
 main :: IO ()