diff --git a/cabal-debian.cabal b/cabal-debian.cabal
--- a/cabal-debian.cabal
+++ b/cabal-debian.cabal
@@ -1,5 +1,5 @@
 Name:           cabal-debian
-Version:        4.35.9
+Version:        4.36
 Copyright:      Copyright (c) 2007-2014, David Fox, Jeremy Shaw
 License:        BSD3
 License-File:   LICENSE
diff --git a/src/Debian/Debianize/BasicInfo.hs b/src/Debian/Debianize/BasicInfo.hs
--- a/src/Debian/Debianize/BasicInfo.hs
+++ b/src/Debian/Debianize/BasicInfo.hs
@@ -27,7 +27,11 @@
 import Debian.Debianize.Prelude (read')
 import Debian.Orphans ()
 import Distribution.Compiler (CompilerFlavor(..))
+#if MIN_VERSION_Cabal(2,0,0)
+import Distribution.PackageDescription as Cabal (FlagName, mkFlagName)
+#else
 import Distribution.PackageDescription as Cabal (FlagName(FlagName))
+#endif
 import Prelude hiding (break, lines, log, null, readFile, sum)
 import System.Console.GetOpt (ArgDescr(ReqArg, NoArg), OptDescr(Option))
 import System.FilePath ((</>))
@@ -118,5 +122,10 @@
 -- Lifted from Distribution.Simple.Setup, since it's not exported.
 flagList :: String -> [(FlagName, Bool)]
 flagList = map tagWithValue . words
+#if MIN_VERSION_Cabal(2,0,0)
+  where tagWithValue ('-':name) = (mkFlagName (map toLower name), False)
+        tagWithValue name       = (mkFlagName (map toLower name), True)
+#else
   where tagWithValue ('-':name) = (FlagName (map toLower name), False)
         tagWithValue name       = (FlagName (map toLower name), True)
+#endif
diff --git a/src/Debian/Debianize/BuildDependencies.hs b/src/Debian/Debianize/BuildDependencies.hs
--- a/src/Debian/Debianize/BuildDependencies.hs
+++ b/src/Debian/Debianize/BuildDependencies.hs
@@ -14,11 +14,11 @@
 import Control.Monad.Trans (liftIO, MonadIO)
 import Data.Char (isSpace, toLower)
 import Data.Function (on)
-import Data.List as List (filter, groupBy, map, minimumBy, nub, sortBy)
+import Data.List as List (filter, groupBy, intercalate, map, minimumBy, nub, sortBy)
 import Data.Map as Map (lookup, Map)
-import Data.Maybe (catMaybes, fromMaybe, isJust, isNothing, listToMaybe)
+import Data.Maybe (catMaybes, fromMaybe, isJust, isNothing, listToMaybe, mapMaybe)
 import Data.Set as Set (empty, fold, fromList, map, member, Set, singleton, toList, union)
-import Data.Version (showVersion, Version)
+import Debian.Debianize.Prelude
 import Debian.Debianize.BasicInfo (buildEnv, compilerFlavor, EnvSet(dependOS))
 import Debian.Debianize.Bundled (builtIn)
 import qualified Debian.Debianize.DebInfo as D
@@ -34,11 +34,14 @@
 import qualified Debian.Relation as D (BinPkgName(BinPkgName), Relation(..), Relations, VersionReq(EEQ, GRE, LTE, SGR, SLT))
 import Debian.Version (DebianVersion, parseDebianVersion')
 import Distribution.Compiler (CompilerFlavor(..))
-import Distribution.Package (Dependency(..), PackageIdentifier(pkgName, pkgVersion), PackageName(PackageName))
-import Distribution.PackageDescription (PackageDescription)
+import Distribution.Package (Dependency(..), PackageIdentifier(pkgName, pkgVersion), PackageName)
 import Distribution.PackageDescription as Cabal (BuildInfo(..), BuildInfo(buildTools, extraLibs, pkgconfigDepends), Library(..), Executable(..), TestSuite(..))
+import Distribution.PackageDescription (PackageDescription)
 import qualified Distribution.PackageDescription as Cabal (PackageDescription(library, executables, testSuites))
---import Distribution.Text (display)
+#if MIN_VERSION_Cabal(2,0,0)
+import Distribution.Types.LegacyExeDependency (LegacyExeDependency(..))
+import Distribution.Types.PkgconfigDependency (PkgconfigDependency(..))
+#endif
 import Distribution.Version (anyVersion, asVersionIntervals, earlierVersion, foldVersionRange', fromVersionIntervals, intersectVersionRanges, isNoVersion, laterVersion, orEarlierVersion, orLaterVersion, toVersionIntervals, unionVersionRanges, VersionRange, withinVersion)
 import Distribution.Version.Invert (invertVersionRange)
 import Prelude hiding (init, log, map, unlines, unlines, writeFile)
@@ -80,11 +83,20 @@
 allBuildDepends buildInfos =
     allBuildDepends'
       (mergeCabalDependencies $ concatMap Cabal.targetBuildDepends buildInfos)
-      (mergeCabalDependencies $ concatMap buildTools buildInfos)
-      (mergeCabalDependencies $ concatMap pkgconfigDepends buildInfos)
+      (mergeCabalDependencies $ mapMaybe convertLegacy $ concatMap buildTools buildInfos)
+      (mergeCabalDependencies $ mapMaybe convertPkgconfig $  concatMap pkgconfigDepends buildInfos)
       (concatMap extraLibs buildInfos) >>=
     return {- . List.filter (not . selfDependency (Cabal.package pkgDesc)) -}
     where
+#if MIN_VERSION_Cabal(2,0,0)
+      convertLegacy :: LegacyExeDependency -> Maybe Dependency
+      convertLegacy = const Nothing
+      convertPkgconfig :: PkgconfigDependency -> Maybe Dependency
+      convertPkgconfig = const Nothing
+#else
+      convertLegacy = Just
+      convertPkgconfig = Just
+#endif
       allBuildDepends' :: Monad m => [Dependency] -> [Dependency] -> [Dependency] -> [String] -> CabalT m [Dependency_]
       allBuildDepends' buildDepends' buildTools' pkgconfigDepends' extraLibs' =
           do atoms <- get
@@ -125,6 +137,11 @@
        binDeps <- allBuildDepends (List.map buildInfo (Cabal.executables pkgDesc))
        testDeps <- allBuildDepends (List.map testBuildInfo (Cabal.testSuites pkgDesc))
 
+       liftIO (putStrLn ("library dependencies: " ++ show libDeps))
+       liftIO (putStrLn ("executable dependencies: " ++ show binDeps))
+       liftIO (putStrLn (intercalate "\n  " ("executables:" :  fmap show (Cabal.executables pkgDesc))))
+       liftIO (putStrLn ("test suite dependencies: " ++ show testDeps))
+
        testsStatus <- use (A.debInfo . D.testsStatus)
 
        cDeps <- nub . concat . concat <$> sequence
@@ -217,12 +234,12 @@
           return []
 
 adapt :: Map.Map String Relations -> Dependency_ -> [Relations]
-adapt mp (PkgConfigDepends (Dependency (PackageName pkg) _)) =
-    maybe (aptFile pkg) (: []) (Map.lookup pkg mp)
-adapt mp (BuildTools (Dependency (PackageName pkg) _)) =
-    maybe (aptFile pkg) (: []) (Map.lookup pkg mp)
+adapt mp (PkgConfigDepends (Dependency pkg _)) =
+    maybe (aptFile (unPackageName pkg)) (: []) (Map.lookup (unPackageName pkg) mp)
+adapt mp (BuildTools (Dependency pkg _)) =
+    maybe (aptFile (unPackageName pkg)) (: []) (Map.lookup (unPackageName pkg) mp)
 adapt _flags (ExtraLibs x) = [x]
-adapt _flags (BuildDepends (Dependency (PackageName pkg) _)) = [[[D.Rel (D.BinPkgName pkg) Nothing Nothing]]]
+adapt _flags (BuildDepends (Dependency pkg _)) = [[[D.Rel (D.BinPkgName (unPackageName pkg)) Nothing Nothing]]]
 
 -- There are three reasons this may not work, or may work
 -- incorrectly: (1) the build environment may be a different
@@ -283,10 +300,16 @@
                           (\ v -> debianVersion' name v >>= \ dv -> return $ Rel' (D.Rel dname (Just (D.SLT dv)) Nothing))
                           (\ v -> debianVersion' name v >>= \ dv -> return $ Rel' (D.Rel dname (Just (D.GRE dv)) Nothing))
                           (\ v -> debianVersion' name v >>= \ dv -> return $ Rel' (D.Rel dname (Just (D.LTE dv)) Nothing))
+#if MIN_VERSION_Cabal(2,0,0)
                           (\ x y -> debianVersion' name x >>= \ dvx ->
                                     debianVersion' name y >>= \ dvy ->
                                     return $ And [Rel' (D.Rel dname (Just (D.GRE dvx)) Nothing),
                                                   Rel' (D.Rel dname (Just (D.SLT dvy)) Nothing)])
+#endif
+                          (\ x y -> debianVersion' name x >>= \ dvx ->
+                                    debianVersion' name y >>= \ dvy ->
+                                    return $ And [Rel' (D.Rel dname (Just (D.GRE dvx)) Nothing),
+                                                  Rel' (D.Rel dname (Just (D.SLT dvy)) Nothing)])
                           (\ x y -> x >>= \ x' -> y >>= \ y' -> return $ Or [x', y'])
                           (\ x y -> x >>= \ x' -> y >>= \ y' -> return $ And [x', y'])
                           id
@@ -310,6 +333,9 @@
             orLaterVersion
             orEarlierVersion
             (\ lb ub -> intersectVersionRanges (orLaterVersion lb) (earlierVersion ub))
+#if MIN_VERSION_Cabal(2,0,0)
+            (\ lb ub -> intersectVersionRanges (orLaterVersion lb) (earlierVersion ub))
+#endif
             unionVersionRanges
             intersectVersionRanges
             id
diff --git a/src/Debian/Debianize/Bundled.hs b/src/Debian/Debianize/Bundled.hs
--- a/src/Debian/Debianize/Bundled.hs
+++ b/src/Debian/Debianize/Bundled.hs
@@ -32,12 +32,18 @@
 import Data.List (groupBy, intercalate, isPrefixOf, stripPrefix)
 import Data.Maybe (listToMaybe, mapMaybe)
 import Data.Set as Set (difference, fromList)
-import Data.Version (parseVersion, Version(..))
 import Debian.GHC ({-instance Memoizable CompilerFlavor-})
 import Debian.Relation (BinPkgName(..))
 import Debian.Relation.ByteString ()
 import Debian.Version (DebianVersion, parseDebianVersion', prettyDebianVersion)
+#if MIN_VERSION_Cabal(2,0,0)
+import Distribution.Package (mkPackageName, PackageIdentifier(..), unPackageName)
+import Data.Version (parseVersion)
+import Distribution.Version(mkVersion, mkVersion', Version)
+#else
+import Data.Version (parseVersion, Version(..))
 import Distribution.Package (PackageIdentifier(..), PackageName(..))
+#endif
 #if MIN_VERSION_Cabal(1,22,0)
 import Distribution.Simple.Compiler (CompilerFlavor(GHCJS))
 #else
@@ -51,8 +57,11 @@
 import Text.Regex.TDFA ((=~))
 
 #if MIN_VERSION_base(4,8,0)
+#if !MIN_VERSION_Cabal(2,0,0)
 import Data.Version (makeVersion)
 #else
+#endif
+#else
 import Data.Monoid (mempty)
 
 #if !MIN_VERSION_Cabal(1,22,0)
@@ -169,23 +178,41 @@
 -- So be it.
 parsePackageIdentifier :: ReadP PackageIdentifier
 parsePackageIdentifier = do
+#if MIN_VERSION_Cabal(2,0,0)
+  makeId <$> ((,) <$> endBy1 (munch1 isAlphaNum) (char '-') <*> parseCabalVersion)
+    where
+      makeId :: ([String], Version) -> PackageIdentifier
+      makeId (xs, v) = PackageIdentifier {pkgName = mkPackageName (intercalate "-" xs), pkgVersion = v}
+#else
   makeId <$> ((,) <$> endBy1 (munch1 isAlphaNum) (char '-') <*> parseVersion)
     where
       makeId :: ([String], Version) -> PackageIdentifier
       makeId (xs, v) = PackageIdentifier {pkgName = PackageName (intercalate "-" xs), pkgVersion = v}
+#endif
 
 parseMaybe :: ReadP a -> String -> Maybe a
 parseMaybe p = listToMaybe . map fst . filter ((== "") . snd) . readP_to_S p
 
 parseVersion' :: String -> Maybe Version
+#if MIN_VERSION_Cabal(2,0,0)
+parseVersion' = parseMaybe parseCabalVersion
+
+parseCabalVersion :: ReadP Version
+parseCabalVersion = fmap mkVersion' parseVersion
+#else
 parseVersion' = parseMaybe parseVersion
+#endif
 
 parsePackageIdentifier' :: String -> Maybe PackageIdentifier
 parsePackageIdentifier' = parseMaybe parsePackageIdentifier
 
 tests :: Test
 tests = TestList [ TestCase (assertEqual "Bundled1"
+#if MIN_VERSION_Cabal(2,0,0)
+                               (Just (PackageIdentifier (mkPackageName "HUnit") (mkVersion [1,2,3])))
+#else
                                (Just (PackageIdentifier (PackageName "HUnit") (makeVersion [1,2,3])))
+#endif
                                (parseMaybe parsePackageIdentifier "HUnit-1.2.3"))
                  , TestCase (assertEqual "Bundled2"
                                Nothing
diff --git a/src/Debian/Debianize/CopyrightDescription.hs b/src/Debian/Debianize/CopyrightDescription.hs
--- a/src/Debian/Debianize/CopyrightDescription.hs
+++ b/src/Debian/Debianize/CopyrightDescription.hs
@@ -54,7 +54,11 @@
 import Text.PrettyPrint.HughesPJClass (Pretty(pPrint), text)
 
 unPackageName :: Cabal.PackageName -> String
+#if MIN_VERSION_Cabal(2,0,0)
+unPackageName p = Cabal.unPackageName p
+#else
 unPackageName (Cabal.PackageName x) = x
+#endif
 
 -- | Description of the machine readable debian/copyright file.  A
 -- special case is used to represeent the old style free format file -
diff --git a/src/Debian/Debianize/DebianName.hs b/src/Debian/Debianize/DebianName.hs
--- a/src/Debian/Debianize/DebianName.hs
+++ b/src/Debian/Debianize/DebianName.hs
@@ -18,7 +18,6 @@
 import Control.Lens
 import Data.Char (toLower)
 import Data.Map as Map (alter, lookup)
-import Data.Version (showVersion, Version)
 import Debian.Debianize.Monad (CabalT)
 import Debian.Debianize.CabalInfo as A (debianNameMap, packageDescription, debInfo)
 import Debian.Debianize.BinaryDebDescription as Debian (PackageType(..))
@@ -29,7 +28,13 @@
 import qualified Debian.Relation as D (VersionReq(EEQ))
 import Debian.Version (parseDebianVersion')
 import Distribution.Compiler (CompilerFlavor(..))
+#if MIN_VERSION_Cabal(2,0,0)
+import Distribution.Package (Dependency(..), PackageIdentifier(..), PackageName, unPackageName)
+import Distribution.Version (showVersion, Version)
+#else
+import Data.Version (showVersion, Version)
 import Distribution.Package (Dependency(..), PackageIdentifier(..), PackageName(PackageName))
+#endif
 import qualified Distribution.PackageDescription as Cabal (PackageDescription(package))
 import Prelude hiding (unlines)
 
@@ -60,7 +65,11 @@
        pkgDesc <- use packageDescription
        let pkgId = Cabal.package pkgDesc
        nameMap <- use A.debianNameMap
+#if MIN_VERSION_Cabal(2,0,0)
+       let pname = pkgName pkgId
+#else
        let pname@(PackageName _) = pkgName pkgId
+#endif
            version = (Just (D.EEQ (parseDebianVersion' (showVersion (pkgVersion pkgId)))))
        case (nameBase, Map.lookup (pkgName pkgId) nameMap) of
          (Just base, _) -> return base
@@ -91,8 +100,13 @@
     where prefix = "lib" ++ map toLower (show hc) ++ "-"
 
 debianBaseName :: PackageName -> DebBase
+#if MIN_VERSION_Cabal(2,0,0)
+debianBaseName p =
+    DebBase (map (fixChar . toLower) (unPackageName p))
+#else
 debianBaseName (PackageName name) =
     DebBase (map (fixChar . toLower) name)
+#endif
     where
       -- Underscore is prohibited in debian package names.
       fixChar :: Char -> Char
diff --git a/src/Debian/Debianize/Details.hs b/src/Debian/Debianize/Details.hs
--- a/src/Debian/Debianize/Details.hs
+++ b/src/Debian/Debianize/Details.hs
@@ -1,6 +1,7 @@
 -- | Detailed information about the specific repositories such as
 -- debian or seereason - in particular how cabal names are mapped to
 -- debian.
+{-# LANGUAGE CPP #-}
 {-# OPTIONS -Wall #-}
 module Debian.Debianize.Details
     ( debianDefaults
@@ -8,14 +9,19 @@
 
 import Control.Lens
 import Data.Map as Map (insert)
-import Data.Version (Version(Version))
 import Debian.Debianize.DebianName (mapCabal, splitCabal)
 import Debian.Debianize.Monad (CabalT)
 import Debian.Debianize.CabalInfo as A (epochMap, debInfo)
 import Debian.Debianize.DebInfo as D (execMap)
 import Debian.Debianize.VersionSplits (DebBase(DebBase))
 import Debian.Relation (BinPkgName(BinPkgName), Relation(Rel))
+#if MIN_VERSION_Cabal(2,0,0)
+import Distribution.Package (mkPackageName)
+import Distribution.Version (mkVersion)
+#else
+import Data.Version (Version(Version))
 import Distribution.Package (PackageName(PackageName))
+#endif
 
 -- | Update the CabalInfo value in the CabalT state with some details about
 -- the debian repository - special cases for how some cabal packages
@@ -23,25 +29,51 @@
 debianDefaults :: Monad m => CabalT m ()
 debianDefaults =
     do -- These are the two epoch names I know about in the debian repo
+#if MIN_VERSION_Cabal(2,0,0)
+       A.epochMap %= Map.insert (mkPackageName "HaXml") 1
+       A.epochMap %= Map.insert (mkPackageName "HTTP") 1
+#else
        A.epochMap %= Map.insert (PackageName "HaXml") 1
        A.epochMap %= Map.insert (PackageName "HTTP") 1
+#endif
        -- Associate some build tools and their corresponding
        -- (eponymous) debian package names
        mapM_ (\name -> (A.debInfo . D.execMap) %= Map.insert name [[Rel (BinPkgName name) Nothing Nothing]])
             ["ghc", "happy", "alex", "hsx2hs"]
        -- The parsec debs are suffixed with either "2" or "3"
+#if MIN_VERSION_Cabal(2,0,0)
+       mapCabal (mkPackageName "parsec") (DebBase "parsec3")
+#else
        mapCabal (PackageName "parsec") (DebBase "parsec3")
+#endif
        -- Similar split for quickcheck
+#if MIN_VERSION_Cabal(2,0,0)
+       mapCabal (mkPackageName "QuickCheck") (DebBase "quickcheck2")
+#else
        mapCabal (PackageName "QuickCheck") (DebBase "quickcheck2")
+#endif
        -- Something was required for this package at one time - it
        -- looks like a no-op now
+#if MIN_VERSION_Cabal(2,0,0)
+       mapCabal (mkPackageName "gtk2hs-buildtools") (DebBase "gtk2hs-buildtools")
+#else
        mapCabal (PackageName "gtk2hs-buildtools") (DebBase "gtk2hs-buildtools")
+#endif
        -- Upgrade transformers to 0.4 - no don't!
        -- remapCabal (PackageName "transformers") (DebBase "transformers4")
        -- remapCabal (PackageName "haskeline") (DebBase "haskeline0713")
+#if MIN_VERSION_Cabal(2,0,0)
+       mapCabal (mkPackageName "haskell-src-exts") (DebBase "src-exts")
+       mapCabal (mkPackageName "haskell-src-meta") (DebBase "src-meta")
+       mapCabal (mkPackageName "Cabal") (DebBase "cabal")
+
+       mapCabal (mkPackageName "happstack-authenticate") (DebBase "happstack-authenticate")
+       splitCabal (mkPackageName "happstack-authenticate") (DebBase "happstack-authenticate-0") (mkVersion [2])
+#else
        mapCabal (PackageName "haskell-src-exts") (DebBase "src-exts")
        mapCabal (PackageName "haskell-src-meta") (DebBase "src-meta")
        mapCabal (PackageName "Cabal") (DebBase "cabal")
 
        mapCabal (PackageName "happstack-authenticate") (DebBase "happstack-authenticate")
        splitCabal (PackageName "happstack-authenticate") (DebBase "happstack-authenticate-0") (Version [2] [])
+#endif
diff --git a/src/Debian/Debianize/Finalize.hs b/src/Debian/Debianize/Finalize.hs
--- a/src/Debian/Debianize/Finalize.hs
+++ b/src/Debian/Debianize/Finalize.hs
@@ -53,8 +53,15 @@
 #if MIN_VERSION_Cabal(1,22,0)
 import Distribution.Compiler (CompilerFlavor(GHCJS))
 #endif
+#if MIN_VERSION_Cabal(2,0,0)
+import Distribution.Package (Dependency(..), PackageIdentifier(..), PackageName, mkPackageName, unPackageName)
+import Distribution.PackageDescription as Cabal (allBuildInfo, author, BuildInfo(buildable, extraLibs), Executable(buildInfo, exeName), FlagName, mkFlagName, unFlagName, maintainer, PackageDescription(testSuites))
+import Distribution.Types.UnqualComponentName
+import Distribution.Utils.ShortText
+#else
 import Distribution.Package (Dependency(..), PackageIdentifier(..), PackageName(PackageName))
 import Distribution.PackageDescription as Cabal (allBuildInfo, author, BuildInfo(buildable, extraLibs), Executable(buildInfo, exeName), FlagName(FlagName), maintainer, PackageDescription(testSuites))
+#endif
 import qualified Distribution.PackageDescription as Cabal (PackageDescription(dataFiles, executables, library, package))
 import Prelude hiding (init, log, map, unlines, unlines, writeFile)
 import System.Directory (doesFileExist)
@@ -368,7 +375,11 @@
 officialSettings :: (Monad m, Functor m) => CabalT m ()
 officialSettings = do
     pkgDesc <- use A.packageDescription
+#if MIN_VERSION_Cabal(2,0,0)
+    let cabal = pkgName (Cabal.package pkgDesc)
+#else
     let PackageName cabal = pkgName (Cabal.package pkgDesc)
+#endif
     zoom A.debInfo $ do
         let officialError = error "officialSettings: no sourcePackageName"
 
@@ -378,7 +389,11 @@
         let packagesURI = "https://anonscm.debian.org/cgit/pkg-haskell/DHG_packages.git/tree/p/" <> pack src
         zoom D.control $ do
            S.standardsVersion .?= Just (parseStandardsVersion "3.9.8")
+#if MIN_VERSION_Cabal(2,0,0)
+           S.homepage .?= Just ("http://hackage.haskell.org/package/" <> pack (unPackageName cabal))
+#else
            S.homepage .?= Just ("http://hackage.haskell.org/package/" <> pack cabal)
+#endif
            S.vcsFields %= Set.union (Set.fromList
               [ S.VCSBrowser packagesURI
               , S.VCSGit  "https://anonscm.debian.org/cgit/pkg-haskell/DHG_packages.git"
@@ -491,12 +506,23 @@
        -- The names of cabal executables that go into eponymous debs
        insExecPkg <- use (A.debInfo . D.executable) >>= return . Set.map ename . Set.fromList . elems
 
+#if MIN_VERSION_Cabal(2,0,0)
+       let installedData :: Set (FilePath, FilePath)
+           installedData = Set.map (\ a -> (a, a)) $ Set.unions (Map.elems installedDataMap)
+           installedExec :: Set String
+#else
        let installedData = Set.map (\ a -> (a, a)) $ Set.unions (Map.elems installedDataMap)
+#endif
            installedExec = Set.unions (Map.elems installedExecMap)
 
        prefixPath <- dataTop
        let dataFilePaths = Set.fromList (zip (List.map (prefixPath </>) (Cabal.dataFiles pkgDesc)) (Cabal.dataFiles pkgDesc)) :: Set (FilePath, FilePath)
+#if MIN_VERSION_Cabal(2,0,0)
+           execFilePaths :: Set FilePath
+           execFilePaths = Set.map (unUnqualComponentName . Cabal.exeName) (Set.filter (Cabal.buildable . Cabal.buildInfo) (Set.fromList (Cabal.executables pkgDesc))) :: Set FilePath
+#else
            execFilePaths = Set.map Cabal.exeName (Set.filter (Cabal.buildable . Cabal.buildInfo) (Set.fromList (Cabal.executables pkgDesc))) :: Set FilePath
+#endif
        let availableData = Set.union installedData dataFilePaths
            availableExec = Set.union installedExec execFilePaths
 
@@ -696,8 +722,17 @@
 -- Lifted from Distribution.Simple.Setup, since it's not exported.
 flagList :: String -> [(FlagName, Bool)]
 flagList = List.map tagWithValue . words
+#if MIN_VERSION_Cabal(2,0,0)
+  where tagWithValue ('-':name) = (mkFlagName (List.map toLower name), False)
+        tagWithValue name       = (mkFlagName (List.map toLower name), True)
+#else
   where tagWithValue ('-':name) = (FlagName (List.map toLower name), False)
         tagWithValue name       = (FlagName (List.map toLower name), True)
+#endif
 
 flagString :: [(FlagName, Bool)] -> String
+#if MIN_VERSION_Cabal(2,0,0)
+flagString = List.intercalate " " . List.map (\ (s, sense) -> "-f" ++ (if sense then "" else "-") ++ unFlagName s)
+#else
 flagString = List.intercalate " " . List.map (\ (FlagName s, sense) -> "-f" ++ (if sense then "" else "-") ++ s)
+#endif
diff --git a/src/Debian/Debianize/Goodies.hs b/src/Debian/Debianize/Goodies.hs
--- a/src/Debian/Debianize/Goodies.hs
+++ b/src/Debian/Debianize/Goodies.hs
@@ -40,7 +40,11 @@
 import Debian.Policy (apacheAccessLog, apacheErrorLog, apacheLogDirectory, databaseDirectory, dataDirectory, serverAccessLog, serverAppLog)
 import Debian.Pretty (ppShow, ppText)
 import Debian.Relation (BinPkgName(BinPkgName), Relation(Rel))
+#if MIN_VERSION_Cabal(2,0,0)
+import Distribution.Package (PackageName, unPackageName)
+#else
 import Distribution.Package (PackageName(PackageName))
+#endif
 import Distribution.PackageDescription as Cabal (PackageDescription(package, synopsis, description))
 import Distribution.Simple.Build.PathsModule (pkgPathEnvVar)
 import Prelude hiding (init, log, map, unlines, writeFile)
@@ -170,8 +174,13 @@
     , "--http-port", show (D.port x)]
 
 watchAtom :: PackageName -> Text
+#if MIN_VERSION_Cabal(2,0,0)
+watchAtom pkgname =
+    pack $ "version=3\nhttp://hackage.haskell.org/package/" ++ unPackageName pkgname ++ "/distro-monitor .*-([0-9\\.]+)\\.(?:zip|tgz|tbz|txz|(?:tar\\.(?:gz|bz2|xz)))\n"
+#else
 watchAtom (PackageName pkgname) =
     pack $ "version=3\nhttp://hackage.haskell.org/package/" ++ pkgname ++ "/distro-monitor .*-([0-9\\.]+)\\.(?:zip|tgz|tbz|txz|(?:tar\\.(?:gz|bz2|xz)))\n"
+#endif
 
 siteAtoms :: PackageDescription -> BinPkgName -> D.Site -> CabalInfo -> CabalInfo
 siteAtoms pkgDesc b site =
diff --git a/src/Debian/Debianize/InputDebian.hs b/src/Debian/Debianize/InputDebian.hs
--- a/src/Debian/Debianize/InputDebian.hs
+++ b/src/Debian/Debianize/InputDebian.hs
@@ -40,7 +40,11 @@
 import Debian.Policy (parseMaintainer, parsePackageArchitectures, parseStandardsVersion, parseUploaders, readPriority, readSection, readMultiArch, readSourceFormat, Section(..))
 import Debian.Relation (BinPkgName(..), parseRelations, Relations, SrcPkgName(..))
 --import Debug.Trace (trace)
+#if MIN_VERSION_Cabal(2,0,0)
+import Distribution.Package (PackageIdentifier(..), PackageName(..), unPackageName)
+#else
 import Distribution.Package (PackageIdentifier(..), PackageName(..))
+#endif
 import qualified Distribution.PackageDescription as Cabal (dataDir, PackageDescription(package))
 import Prelude hiding (break, lines, log, null, readFile, sum, words)
 import System.Directory (doesFileExist)
@@ -296,8 +300,12 @@
 dataDest :: Monad m => CabalT m FilePath
 dataDest = do
   d <- use packageDescription
+#if MIN_VERSION_Cabal(2,0,0)
+  return $ "usr/share" </> (unPackageName $ pkgName $ Cabal.package d)
+#else
   return $ "usr/share" </> ((\ (PackageName x) -> x) $ pkgName $ Cabal.package d)
 
+#endif
 -- | Where to look for the data-files
 dataTop :: Monad m => CabalT m FilePath
 dataTop = do
diff --git a/src/Debian/Debianize/Optparse.hs b/src/Debian/Debianize/Optparse.hs
--- a/src/Debian/Debianize/Optparse.hs
+++ b/src/Debian/Debianize/Optparse.hs
@@ -40,8 +40,13 @@
 import Debian.Relation
 import Debian.Version (DebianVersion, parseDebianVersion')
 import Distribution.Compiler (CompilerFlavor(..))
+#if MIN_VERSION_Cabal(2,0,0)
+import Distribution.Package (PackageName, mkPackageName, unPackageName)
+import Distribution.PackageDescription (FlagName, mkFlagName)
+#else
 import Distribution.Package (PackageName(..))
 import Distribution.PackageDescription (FlagName(FlagName))
+#endif
 import GHC.Generics
 import System.Environment (getArgs)
 import System.FilePath(splitFileName, (</>))
@@ -200,15 +205,28 @@
 extraRelationsR = first BinPkgName <$> mappingR
 
 cabalDebMappingR :: O.ReadM CabalDebMapping
+#if MIN_VERSION_Cabal(2,0,0)
+cabalDebMappingR = CabalDebMapping . first mkPackageName <$> mappingR
+#else
 cabalDebMappingR = CabalDebMapping . first PackageName <$> mappingR
+#endif
 
 cabalEpochMappingR :: O.ReadM CabalEpochMapping
+#if MIN_VERSION_Cabal(2,0,0)
+cabalEpochMappingR = CabalEpochMapping . first mkPackageName <$> epochMappingR
+#else
 cabalEpochMappingR = CabalEpochMapping . first PackageName <$> epochMappingR
+#endif
 
 cabalFlagMappingR :: O.ReadM CabalFlagMapping
 cabalFlagMappingR = O.str >>= \case
+#if MIN_VERSION_Cabal(2,0,0)
+  ('-' : str) -> return $ CabalFlagMapping (mkFlagName str, False)
+  str -> return $ CabalFlagMapping (mkFlagName str, True)
+#else
   ('-' : str) -> return $ CabalFlagMapping (FlagName str, False)
   str -> return $ CabalFlagMapping (FlagName str, True)
+#endif
 
 -- Here are parser for BehaviorAdjustment and next are parsers for
 -- every field of this data.  Please, keep parsers declarations in
@@ -638,8 +656,13 @@
   D.debVersion .= _debianVersion
   D.uploadersOption %= (++ _uploaders)
   D.extraDevDeps %= (++ concatMap unpack _devDep)
+#if MIN_VERSION_Cabal(2,0,0)
+  forM_ _cabalDebMapping $ \(CabalDebMapping (pkg, rels)) -> do
+    D.extraLibMap %= Map.insert (unPackageName pkg) rels
+#else
   forM_ _cabalDebMapping $ \(CabalDebMapping (PackageName pkg, rels)) -> do
     D.extraLibMap %= Map.insert pkg rels
+#endif
   addExtra _extraDepends B.depends
   addExtra _extraConflicts B.conflicts
   addExtra _extraProvides B.provides
diff --git a/src/Debian/Debianize/Prelude.hs b/src/Debian/Debianize/Prelude.hs
--- a/src/Debian/Debianize/Prelude.hs
+++ b/src/Debian/Debianize/Prelude.hs
@@ -1,6 +1,6 @@
 -- | Functions and instances used by but not related to cabal-debian.
 -- These could conceivably be moved into more general libraries.
-{-# LANGUAGE FlexibleContexts, FlexibleInstances, Rank2Types, ScopedTypeVariables #-}
+{-# LANGUAGE CPP, FlexibleContexts, FlexibleInstances, Rank2Types, ScopedTypeVariables #-}
 {-# OPTIONS_GHC -Wall -fno-warn-orphans #-}
 module Debian.Debianize.Prelude
     ( curry3
@@ -38,6 +38,18 @@
     , fromSingleton
     , (.?=)
     , escapeDebianWildcards
+#if MIN_VERSION_Cabal(2,0,0)
+    -- Cabal has its own Version type starting in 2.0.0.0
+    , module Distribution.Version
+    , module Distribution.Package
+#else
+    , module Data.Version
+    , mkPackageName
+    , mkVersion
+    , mkVersion'
+    , versionNumbers
+    , unPackageName
+#endif
     ) where
 
 
@@ -62,7 +74,13 @@
 import qualified Debian.Relation as D (BinPkgName(BinPkgName), Relations)
 import Debian.Relation.Common ()
 import Debian.Version (DebianVersion, parseDebianVersion', prettyDebianVersion)
+#if MIN_VERSION_Cabal(2,0,0)
+import Distribution.Package (PackageIdentifier(..), PackageName, unPackageName)
+import Distribution.Version
+#else
 import Distribution.Package (PackageIdentifier(..), PackageName(..))
+import Data.Version
+#endif
 import Distribution.Verbosity (intToVerbosity, Verbosity)
 import GHC.IO.Exception (ExitCode(ExitFailure, ExitSuccess), IOErrorType(InappropriateType, NoSuchThing), IOException(IOError, ioe_description, ioe_type))
 import Prelude hiding (lookup, map)
@@ -328,7 +346,11 @@
     pPrint (PP p) = pPrint (PP (pkgName p)) <> text "-" <> pPrint (PP (pkgVersion p))
 
 instance Pretty (PP PackageName) where
+#if MIN_VERSION_Cabal(2,0,0)
+    pPrint (PP p) = text (unPackageName p)
+#else
     pPrint (PP (PackageName s)) = text s
+#endif
 
 -- | Set @b@ if it currently isNothing and the argument isJust, that is
 --  1. Nothing happens if the argument isNothing
@@ -341,3 +363,18 @@
 escapeDebianWildcards (c : more) | elem c "[]" = '\\' : c : escapeDebianWildcards more
 escapeDebianWildcards (c : more) = c : escapeDebianWildcards more
 escapeDebianWildcards "" = ""
+
+#if !MIN_VERSION_Cabal(2,0,0)
+mkPackageName :: String -> PackageName
+mkPackageName = PackageName
+mkVersion :: [Int] -> Version
+mkVersion ns = Version ns []
+mkVersion' :: Version -> Version
+mkVersion' = id
+versionNumbers :: Version -> [Int]
+versionNumbers (Version ns _) = ns
+#if !MIN_VERSION_Cabal(1,22,0)
+unPackageName :: PackageName -> String
+unPackageName (PackageName x) = x
+#endif
+#endif
diff --git a/src/Debian/Debianize/VersionSplits.hs b/src/Debian/Debianize/VersionSplits.hs
--- a/src/Debian/Debianize/VersionSplits.hs
+++ b/src/Debian/Debianize/VersionSplits.hs
@@ -1,6 +1,6 @@
 -- | Convert between cabal and debian package names based on version
 -- number ranges.
-{-# LANGUAGE DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses, TypeSynonymInstances #-}
+{-# LANGUAGE CPP, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses, TypeSynonymInstances #-}
 module Debian.Debianize.VersionSplits
     ( DebBase(DebBase, unDebBase)
     -- * Combinators for VersionSplits
@@ -18,12 +18,18 @@
 import Data.Generics (Data, Typeable)
 import Data.Map as Map (elems, Map, mapMaybeWithKey)
 import Data.Set as Set (fromList, Set, toList)
-import Data.Version (showVersion, Version(Version))
 import Debian.Debianize.Interspersed (foldTriples, Interspersed(leftmost, pairs, foldInverted))
 import Debian.Orphans ()
 import qualified Debian.Relation as D (VersionReq(..))
 import Debian.Version (DebianVersion, parseDebianVersion')
+#if MIN_VERSION_Cabal(2,0,0)
+import Distribution.Package (PackageIdentifier(..), PackageName)
+import Distribution.Package (mkPackageName)
+import Distribution.Version (showVersion, Version)
+#else
+import Data.Version (showVersion, Version(Version))
 import Distribution.Package (PackageIdentifier(..), PackageName(..))
+#endif
 import Distribution.Version (anyVersion, earlierVersion, intersectVersionRanges, orLaterVersion, VersionRange)
 import Prelude hiding (init, log, unlines)
 
@@ -63,7 +69,11 @@
             -> DebBase -- ^ The name to use for versions older than the split
             -> VersionSplits
             -> VersionSplits
+#if MIN_VERSION_Cabal(2,0,0)
+insertSplit ver ltname sp@(VersionSplits {}) =
+#else
 insertSplit ver@(Version _ _) ltname sp@(VersionSplits {}) =
+#endif
     -- (\ x -> trace ("insertSplit " ++ show (ltname, ver, sp) ++ " -> " ++ show x) x) $
     case splits sp of
       -- This is the oldest split, change oldestPackage and insert a new head pair
@@ -104,7 +114,11 @@
 cabalFromDebian mp base@(DebBase name) ver =
     case Set.toList pset of
       [x] -> x
+#if MIN_VERSION_Cabal(2,0,0)
+      [] -> mkPackageName name
+#else
       [] -> PackageName name
+#endif
       l -> error $ "Error, multiple cabal package names associated with " ++ show base ++ ": " ++ show l
     where
       -- Look for splits that involve the right DebBase and return the
diff --git a/src/Debian/GHC.hs b/src/Debian/GHC.hs
--- a/src/Debian/GHC.hs
+++ b/src/Debian/GHC.hs
@@ -30,9 +30,7 @@
 import Control.Lens (_2, over)
 import Control.Monad.Trans (MonadIO, liftIO)
 import Data.Char (isSpace, toLower, toUpper)
-import Data.Function.Memoize (deriveMemoizable, memoize, memoize2)
 import Data.List (intercalate, isPrefixOf)
-import Data.Version (showVersion, Version(..), parseVersion)
 import Debian.Debianize.BinaryDebDescription (PackageType(..))
 import Debian.Relation (BinPkgName(BinPkgName))
 import Debian.Version (DebianVersion, parseDebianVersion')
@@ -40,6 +38,15 @@
 #if MIN_VERSION_Cabal(1,22,0)
 import Distribution.Compiler (CompilerInfo(..), unknownCompilerInfo, AbiTag(NoAbiTag))
 #endif
+#if MIN_VERSION_Cabal(2,0,0)
+import Data.Function.Memoize (deriveMemoizable, Memoizable, memoize, memoize2, memoizeFinite)
+import Distribution.Version (mkVersion', mkVersion, showVersion, Version, versionNumbers)
+import Data.Version (parseVersion)
+import Data.Word (Word64)
+#else
+import Data.Function.Memoize (deriveMemoizable, memoize, memoize2)
+import Data.Version (showVersion, Version(..), parseVersion)
+#endif
 import System.Console.GetOpt (ArgDescr(ReqArg), OptDescr(..))
 import System.Directory (doesDirectoryExist)
 import System.Environment (getEnv)
@@ -55,6 +62,9 @@
 import Text.Read (readMaybe)
 import Text.Regex.TDFA ((=~))
 
+#if MIN_VERSION_Cabal(2,0,0)
+instance Memoizable Word64 where memoize = memoizeFinite
+#endif
 $(deriveMemoizable ''CompilerFlavor)
 $(deriveMemoizable ''Version)
 $(deriveMemoizable ''BinPkgName)
@@ -82,7 +92,11 @@
 
 toVersion :: String -> Maybe Version
 toVersion s = case filter (all isSpace . snd) (readP_to_S parseVersion s) of
+#if MIN_VERSION_Cabal(2,0,0)
+                [(v, _)] -> Just (mkVersion' v)
+#else
                 [(v, _)] -> Just v
+#endif
                 _ -> Nothing
 
 withCompilerVersion :: FilePath -> CompilerFlavor -> (DebianVersion -> a) -> Either String a
@@ -100,20 +114,41 @@
 
 -- | What version of Cabal goes with this version of GHC?
 hvrCabalVersion :: Version -> Version
+#if MIN_VERSION_Cabal(2,0,0)
+hvrCabalVersion v =
+  case versionNumbers v of
+    (m : n : _) | (m == 7 && n <= 7) || m < 7 -> mkVersion [1,16]
+    (7 : n : _) | n <= 9 -> mkVersion [1,18]
+    (7 : _) -> mkVersion [1,22]
+    _ -> mkVersion [1,24]
+#else
 hvrCabalVersion (Version (m : n : _) _) | (m == 7 && n <= 7) || m < 7 = Version [1,16] []
 hvrCabalVersion (Version (7 : n : _) _) | n <= 9 = Version [1,18] []
 hvrCabalVersion (Version (7 : _) _) = Version [1,22] []
 hvrCabalVersion _ = Version [1,24] []
+#endif
 
 -- | What version of Happy goes with this version of GHC?
 hvrHappyVersion :: Version -> Version
+#if MIN_VERSION_Cabal(2,0,0)
+hvrHappyVersion v =
+    case versionNumbers v of
+      (m : n : _) | (m == 7 && n <= 3) || m < 7 -> mkVersion [1,19,3]
+      (7 : n : _) | n <= 2 -> mkVersion [1,19,3]
+      _ -> mkVersion [1,19,5]
+#else
 hvrHappyVersion (Version (m : n : _) _) | (m == 7 && n <= 3) || m < 7 = Version [1,19,3] []
 hvrHappyVersion (Version (7 : n : _) _) | n <= 2 = Version [1,19,3] []
 hvrHappyVersion _ = Version [1,19,5] []
+#endif
 
 -- | What version of Alex goes with this version of GHC?
 hvrAlexVersion :: Version -> Version
+#if MIN_VERSION_Cabal(2,0,0)
+hvrAlexVersion _ = mkVersion [3,1,7]
+#else
 hvrAlexVersion _ = Version [3,1,7] []
+#endif
 
 withModifiedPATH :: MonadIO m => (String -> String) -> m a -> m a
 withModifiedPATH f action = do
@@ -196,8 +231,13 @@
 
 compilerIdFromDebianVersion :: CompilerFlavor -> DebianVersion -> CompilerId
 compilerIdFromDebianVersion hc debVersion =
+#if MIN_VERSION_Cabal(2,0,0)
+    let ds = versionNumbers (greatestLowerBound debVersion (map (\ d -> mkVersion [d]) [0..])) in
+    CompilerId hc (greatestLowerBound debVersion (map (\ d -> mkVersion (ds ++ [d])) [0..]))
+#else
     let (Version ds ts) = greatestLowerBound debVersion (map (\ d -> Version [d] []) [0..]) in
     CompilerId hc (greatestLowerBound debVersion (map (\ d -> Version (ds ++ [d]) ts) [0..]))
+#endif
     where
       greatestLowerBound :: DebianVersion -> [Version] -> Version
       greatestLowerBound b xs = last $ takeWhile (\ v -> parseDebianVersion' (showVersion v) < b) xs
diff --git a/src/Debian/Orphans.hs b/src/Debian/Orphans.hs
--- a/src/Debian/Orphans.hs
+++ b/src/Debian/Orphans.hs
@@ -7,7 +7,6 @@
 import Data.List (intersperse, isPrefixOf)
 import Data.Maybe (fromMaybe)
 import Data.Monoid ((<>))
-import Data.Version (showVersion, Version(..))
 import Debian.Changes (ChangeLog(..), ChangeLogEntry(..))
 import Debian.Pretty (PP(PP, unPP))
 import Debian.Relation (ArchitectureReq(..), Relation(..), VersionReq(..))
@@ -22,6 +21,11 @@
 import Distribution.PackageDescription (Executable(..), PackageDescription(package))
 import Distribution.Simple.Compiler (Compiler(..))
 import Distribution.Version (foldVersionRange', VersionRange(..))
+#if MIN_VERSION_Cabal(2,0,0)
+import Distribution.Version (showVersion, Version)
+#else
+import Data.Version (showVersion, Version(..))
+#endif
 import Language.Haskell.Extension (Language(..))
 #if !MIN_VERSION_Cabal(1,21,0)
 import Language.Haskell.Extension (Extension(..), KnownExtension(..))
@@ -132,6 +136,9 @@
           (\ v -> text ">=" <> pPrint (PP v))
           (\ v -> text "<=" <> pPrint (PP v))
           (\ x _ -> text "=" <> pPrint (PP x) <> text ".*") -- not exactly right
+#if MIN_VERSION_Cabal(2,0,0)
+          (\ v _ -> text " >= " <> pPrint (PP v)) -- maybe this will do?
+#endif
           (\ x y -> text "(" <> x <> text " || " <> y <> text ")")
           (\ x y -> text "(" <> x <> text " && " <> y <> text ")")
           (\ x -> text "(" <> x <> text ")")
diff --git a/src/Debian/Policy.hs b/src/Debian/Policy.hs
--- a/src/Debian/Policy.hs
+++ b/src/Debian/Policy.hs
@@ -126,7 +126,7 @@
 -- installed.
 getDebhelperCompatLevel :: IO (Maybe Int)
 getDebhelperCompatLevel =
-    debianPackageVersion "debhelper" >>= return . fmap (read . takeWhile (/= '.') . version)
+    debianPackageVersion "debhelper" >>= return . fmap (min 9 . read . takeWhile (/= '.') . version)
 
 data StandardsVersion = StandardsVersion Int Int Int (Maybe Int) deriving (Eq, Ord, Show, Data, Typeable)