diff --git a/cblrepo.cabal b/cblrepo.cabal
--- a/cblrepo.cabal
+++ b/cblrepo.cabal
@@ -1,5 +1,5 @@
 name: cblrepo
-version: 0.16.0
+version: 0.17.0
 cabal-version: >= 1.6
 license: OtherLicense
 license-file: LICENSE-2.0
diff --git a/src/Add.hs b/src/Add.hs
--- a/src/Add.hs
+++ b/src/Add.hs
@@ -38,7 +38,7 @@
 -- {{{1 types
 data PkgType
     = GhcType String Version
-    | DistroType String Version Int
+    | DistroType String Version Int Int
     | RepoType GenericPackageDescription
     deriving (Eq, Show)
 
@@ -53,7 +53,7 @@
     idxPkgs <- asks $ cmdAddCbls . optsCmd
     --
     ghcPkgs <- asks  $ map (uncurry GhcType) . cmdAddGhcPkgs . optsCmd
-    distroPkgs <- asks $ map (\ (n, v, r) -> DistroType n v r) . cmdAddDistroPkgs . optsCmd
+    distroPkgs <- asks $ map (\ (n, v, x, r) -> DistroType n v x r) . cmdAddDistroPkgs . optsCmd
     genFilePkgs <- mapM (runCabalParseWithTempDir . fmap snd . Cbl.readFromFile . fst) filePkgs
     genIdxPkgs <- mapM ((runCabalParseWithTempDir . fmap snd . Cbl.readFromIdx) . (\ (a, b, _) -> (a, b))) idxPkgs
     genPkgs <- liftM (map RepoType) $ exitOnAnyLefts (genFilePkgs ++ genIdxPkgs)
@@ -79,7 +79,7 @@
         Cbl.runCabalParse cpe f
 
 getName (GhcType n _) = n
-getName (DistroType n _ _) = n
+getName (DistroType n _ _ _) = n
 getName (RepoType gpd) = pkgNameStr $ packageDescription gpd
 
 -- {{{1 addPkgs
@@ -96,7 +96,7 @@
 
 canBeAdded :: Version -> CblDB -> [(String, FlagAssignment)] -> PkgType -> Bool
 canBeAdded _ db _ (GhcType n v) = null $ checkDependants db n v
-canBeAdded _ db _ (DistroType n v _) = null $ checkDependants db n v
+canBeAdded _ db _ (DistroType n v _ _) = null $ checkDependants db n v
 canBeAdded ghcVer db flags pkg@(RepoType gpd) =  finable && depsOK
     where
         fa = fromMaybe [] $ lookup (getName pkg) flags
@@ -106,7 +106,7 @@
         depsOK = null $ checkDependants db n v
 
 pkgTypeToCblPkg _ _ _ (GhcType n v) = createGhcPkg n v
-pkgTypeToCblPkg _ _ _ (DistroType n v r) = createDistroPkg n v r
+pkgTypeToCblPkg _ _ _ (DistroType n v x r) = createDistroPkg n v x r
 pkgTypeToCblPkg ghcVer db flags pkg@(RepoType gpd) =
     let fa = fromMaybe [] $ lookup (getName pkg) flags
     in fromJust $ case finalizePkg ghcVer db fa gpd of
@@ -126,7 +126,7 @@
     in if null d
         then Nothing
         else Just ((n, v), d)
-findBreaking db (DistroType n v _) = let
+findBreaking db (DistroType n v _ _) = let
         d = checkDependants db n v
     in if null d
         then Nothing
diff --git a/src/ConvertDB.hs b/src/ConvertDB.hs
--- a/src/ConvertDB.hs
+++ b/src/ConvertDB.hs
@@ -37,7 +37,7 @@
     where
         doConvert o
             | ODB.isGhcPkg o = NDB.createGhcPkg n v
-            | ODB.isDistroPkg o = NDB.createDistroPkg n v r
+            | ODB.isDistroPkg o = NDB.createDistroPkg n v x r
             | ODB.isRepoPkg o = NDB.createRepoPkg n v x d f r
             | otherwise = error ""
             where
@@ -46,4 +46,4 @@
                 x = 0
                 d = ODB.pkgDeps o
                 f = ODB.pkgFlags o
-                r = read $ ODB.pkgRelease o
+                r = ODB.pkgRelease o
diff --git a/src/ListPkgs.hs b/src/ListPkgs.hs
--- a/src/ListPkgs.hs
+++ b/src/ListPkgs.hs
@@ -48,7 +48,7 @@
 printCblPkgShort p =
     putStrLn $ pkgName p ++ "  " ++ v ++ "-" ++ r ++ showFlagsIfPresent p
         where
-            v = display (pkgVersion p) ++ if isRepoPkg p then ("_" ++ show (pkgXRev p)) else ""
+            v = display (pkgVersion p) ++ if (not $ isGhcPkg p) then ("_" ++ show (pkgXRev p)) else ""
             r = if isGhcPkg p then "xx" else show (pkgRelease p)
             showFlagsIfPresent _p
                 | [] <- pkgFlags _p = ""
diff --git a/src/OldPkgDB.hs b/src/OldPkgDB.hs
--- a/src/OldPkgDB.hs
+++ b/src/OldPkgDB.hs
@@ -55,6 +55,7 @@
 import Control.Monad
 import Data.List
 import Data.Maybe
+import Data.Monoid
 import Distribution.PackageDescription
 import System.IO.Error
 import qualified Distribution.Package as P
@@ -68,35 +69,42 @@
 
 -- {{{1 types
 data Pkg
-    = GhcPkg { version :: V.Version }
-    | DistroPkg { version :: V.Version, release :: String }
-    | RepoPkg { version :: V.Version, xrev :: Int, deps :: [P.Dependency], flags :: FlagAssignment, release :: String }
+    = GhcPkg GhcPkgD
+    | DistroPkg DistroPkgD
+    | RepoPkg RepoPkgD
     deriving (Eq, Show)
 
+data GhcPkgD = GhcPkgD { gpVersion :: V.Version }
+    deriving (Eq, Show)
+
+data DistroPkgD = DistroPkgD { dpVersion :: V.Version , dpRelease :: Int }
+    deriving (Eq, Show)
+
+data RepoPkgD = RepoPkgD
+    { rpVersion :: V.Version
+    , rpXrev :: Int
+    , rpDeps :: [P.Dependency]
+    , rpFlags :: FlagAssignment, rpRelease :: Int
+    } deriving (Eq, Show)
+
 data CblPkg = CP String Pkg
     deriving (Eq, Show)
 
 type CblDB = [CblPkg]
 
 instance Ord CblPkg where
-    compare
-        (CP n1 GhcPkg { version = v1 })
-        (CP n2 GhcPkg { version = v2 }) =
-            compare (n1, v1) (n2, v2)
+    compare (CP n1 (GhcPkg d1)) (CP n2 (GhcPkg d2)) =
+            compare (n1, gpVersion d1) (n2, gpVersion d2)
     compare (CP _ GhcPkg {}) _ = LT
     compare _ (CP _ GhcPkg {}) = GT
 
-    compare
-        (CP n1 DistroPkg { version = v1, release = r1 })
-        (CP n2 DistroPkg { version = v2, release = r2 }) =
-            compare (n1, v1, r1) (n2, v2, r2)
+    compare (CP n1 (DistroPkg d1)) (CP n2 (DistroPkg d2)) =
+            compare (n1, dpVersion d1, dpRelease d1) (n2, dpVersion d2, dpRelease d2)
     compare (CP _ DistroPkg {}) _ = LT
     compare _ (CP _ DistroPkg {}) = GT
 
-    compare
-        (CP n1 RepoPkg { version = v1, release = r1 })
-        (CP n2 RepoPkg { version = v2, release = r2 }) =
-            compare (n1, v1, r1) (n2, v2, r2)
+    compare (CP n1 (RepoPkg d1)) (CP n2 (RepoPkg d2)) =
+            compare (n1, rpVersion d1, rpRelease d1) (n2, rpVersion d2, rpRelease d2)
 
 -- {{{1 packages
 pkgName :: CblPkg -> String
@@ -106,36 +114,38 @@
 pkgPkg (CP _ p) = p
 
 pkgVersion :: CblPkg -> V.Version
-pkgVersion (CP _ p) = version p
+pkgVersion (CP _ (GhcPkg d)) = gpVersion d
+pkgVersion (CP _ (DistroPkg d)) = dpVersion d
+pkgVersion (CP _ (RepoPkg d)) = rpVersion d
 
 pkgXRev :: CblPkg -> Int
-pkgXRev (CP _ RepoPkg { xrev = x }) = x
+pkgXRev (CP _ (RepoPkg d)) = rpXrev d
 pkgXRev _ = 0
 
 pkgDeps :: CblPkg -> [P.Dependency]
-pkgDeps (CP _ RepoPkg { deps = d}) = d
+pkgDeps (CP _ (RepoPkg d)) = rpDeps d
 pkgDeps _ = []
 
 pkgFlags :: CblPkg -> FlagAssignment
-pkgFlags (CP _ RepoPkg { flags = fa}) = fa
+pkgFlags (CP _ (RepoPkg d)) = rpFlags d
 pkgFlags _ = []
 
-pkgRelease :: CblPkg -> String
-pkgRelease (CP _ GhcPkg {}) = "xx"
-pkgRelease (CP _ DistroPkg { release = r }) = r
-pkgRelease (CP _ RepoPkg { release = r }) = r
+pkgRelease :: CblPkg -> Int
+pkgRelease (CP _ (GhcPkg _)) = (-1)
+pkgRelease (CP _ (DistroPkg d)) = dpRelease d
+pkgRelease (CP _ (RepoPkg d)) = rpRelease d
 
 createGhcPkg :: String -> V.Version -> CblPkg
-createGhcPkg n v = CP n (GhcPkg v)
+createGhcPkg n v = CP n (GhcPkg $ GhcPkgD v)
 
-createDistroPkg :: String -> V.Version -> String -> CblPkg
-createDistroPkg n v r = CP n (DistroPkg v r)
+createDistroPkg :: String -> V.Version -> Int -> CblPkg
+createDistroPkg n v r = CP n (DistroPkg (DistroPkgD v r))
 
-createRepoPkg :: String -> V.Version -> Int -> [P.Dependency] -> FlagAssignment -> String -> CblPkg
-createRepoPkg n v x d fa r = CP n (RepoPkg v x d fa r)
+createRepoPkg :: String -> V.Version -> Int -> [P.Dependency] -> FlagAssignment -> Int -> CblPkg
+createRepoPkg n v x d fa r = CP n (RepoPkg $ RepoPkgD v x d fa r)
 
 createCblPkg :: PackageDescription -> FlagAssignment -> CblPkg
-createCblPkg pd fa = createRepoPkg name version xrev deps fa "1"
+createCblPkg pd fa = createRepoPkg name version xrev deps fa 1
     where
         name = Util.Dist.pkgNameStr pd
         version = P.pkgVersion $ package pd
@@ -176,7 +186,7 @@
 addGhcPkg :: CblDB -> String -> V.Version -> CblDB
 addGhcPkg db n v = addPkg2 db (createGhcPkg n v)
 
-addDistroPkg :: CblDB -> String -> V.Version -> String -> CblDB
+addDistroPkg :: CblDB -> String -> V.Version -> Int -> CblDB
 addDistroPkg db n v r = addPkg2 db (createDistroPkg n v r)
 
 delPkg :: CblDB -> String -> CblDB
@@ -185,9 +195,7 @@
 bumpRelease :: CblDB -> String -> CblDB
 bumpRelease db n = maybe db (addPkg2 db . doBump) (lookupPkg db n)
     where
-        doBump (CP n' p@RepoPkg { release = r }) = CP n' (p { release = nr })
-            where
-                nr = show $ read r + (1 :: Int)
+        doBump (CP n' (RepoPkg d)) = CP n' (RepoPkg d { rpRelease = (rpRelease d + 1) })
         doBump p = p
 
 lookupPkg :: CblDB -> String -> Maybe CblPkg
@@ -222,7 +230,7 @@
     in (dN == name) ||
             (case lookupPkg db dN of
                 Nothing -> False
-                Just (CP _ p) -> V.withinRange (version p) dVR)
+                Just p -> V.withinRange (pkgVersion p) dVR)
 
 readDb :: FilePath -> IO CblDB
 readDb fp = handle
@@ -245,6 +253,9 @@
 $(deriveJSON defaultOptions { sumEncoding = ObjectWithSingleField, allNullaryToStringTag = False } ''V.VersionRange)
 $(deriveJSON defaultOptions { sumEncoding = ObjectWithSingleField, allNullaryToStringTag = False } ''FlagName)
 $(deriveJSON defaultOptions { sumEncoding = ObjectWithSingleField, allNullaryToStringTag = False } ''Pkg)
+$(deriveJSON defaultOptions { sumEncoding = ObjectWithSingleField, allNullaryToStringTag = False } ''GhcPkgD)
+$(deriveJSON defaultOptions { sumEncoding = ObjectWithSingleField, allNullaryToStringTag = False } ''DistroPkgD)
+$(deriveJSON defaultOptions { sumEncoding = ObjectWithSingleField, allNullaryToStringTag = False } ''RepoPkgD)
 $(deriveJSON defaultOptions { sumEncoding = ObjectWithSingleField, allNullaryToStringTag = False } ''CblPkg)
 
 instance ToJSON P.Dependency where
diff --git a/src/PkgDB.hs b/src/PkgDB.hs
--- a/src/PkgDB.hs
+++ b/src/PkgDB.hs
@@ -77,8 +77,11 @@
 data GhcPkgD = GhcPkgD { gpVersion :: V.Version }
     deriving (Eq, Show)
 
-data DistroPkgD = DistroPkgD { dpVersion :: V.Version , dpRelease :: Int }
-    deriving (Eq, Show)
+data DistroPkgD = DistroPkgD
+    { dpVersion :: V.Version
+    , dpXrev :: Int
+    , dpRelease :: Int
+    } deriving (Eq, Show)
 
 data RepoPkgD = RepoPkgD
     { rpVersion :: V.Version
@@ -119,6 +122,7 @@
 pkgVersion (CP _ (RepoPkg d)) = rpVersion d
 
 pkgXRev :: CblPkg -> Int
+pkgXRev (CP _ (DistroPkg d)) = dpXrev d
 pkgXRev (CP _ (RepoPkg d)) = rpXrev d
 pkgXRev _ = 0
 
@@ -138,8 +142,8 @@
 createGhcPkg :: String -> V.Version -> CblPkg
 createGhcPkg n v = CP n (GhcPkg $ GhcPkgD v)
 
-createDistroPkg :: String -> V.Version -> Int -> CblPkg
-createDistroPkg n v r = CP n (DistroPkg (DistroPkgD v r))
+createDistroPkg :: String -> V.Version -> Int -> Int -> CblPkg
+createDistroPkg n v x r = CP n (DistroPkg (DistroPkgD v x r))
 
 createRepoPkg :: String -> V.Version -> Int -> [P.Dependency] -> FlagAssignment -> Int -> CblPkg
 createRepoPkg n v x d fa r = CP n (RepoPkg $ RepoPkgD v x d fa r)
@@ -186,8 +190,8 @@
 addGhcPkg :: CblDB -> String -> V.Version -> CblDB
 addGhcPkg db n v = addPkg2 db (createGhcPkg n v)
 
-addDistroPkg :: CblDB -> String -> V.Version -> Int -> CblDB
-addDistroPkg db n v r = addPkg2 db (createDistroPkg n v r)
+addDistroPkg :: CblDB -> String -> V.Version -> Int -> Int -> CblDB
+addDistroPkg db n v x r = addPkg2 db (createDistroPkg n v x r)
 
 delPkg :: CblDB -> String -> CblDB
 delPkg db n = filter (\ p -> n /= pkgName p) db
diff --git a/src/Util/Misc.hs b/src/Util/Misc.hs
--- a/src/Util/Misc.hs
+++ b/src/Util/Misc.hs
@@ -100,19 +100,21 @@
 ghcPkgArgReader :: ReadM (String, Version)
 ghcPkgArgReader = pkgNVersionArgReader
 
-distroPkgArgReader :: ReadM (String, Version, Int)
+distroPkgArgReader :: ReadM (String, Version, Int, Int)
 distroPkgArgReader = let
         readDistroPkg = do
             (n, v) <- readPkgNVersion
             char ','
+            x <- many (satisfy (/= ','))
+            char ','
             r <- many (satisfy (/= ','))
-            return (n, v, read r)
+            return (n, v, read x, read r)
 
     in do
         s <- readerAsk
         case lastMay (readP_to_S readDistroPkg s) of
             Just (r, "") -> return r
-            _ -> fail $ "Cannot parse '" ++ s ++ "' as PKG,VER,REL"
+            _ -> fail $ "Cannot parse '" ++ s ++ "' as PKG,VER,XREV,REL"
 
 strCblFileArgReader :: ReadM (FilePath, FlagAssignment)
 strCblFileArgReader = let
@@ -154,7 +156,7 @@
 data Cmds
     = CmdAdd
         { patchDir :: FilePath, ghcVer :: Version, cmdAddGhcPkgs :: [(String, Version)]
-        , cmdAddDistroPkgs :: [(String, Version, Int)], cmdAddFileCbls :: [(FilePath, FlagAssignment)]
+        , cmdAddDistroPkgs :: [(String, Version, Int, Int)], cmdAddFileCbls :: [(FilePath, FlagAssignment)]
         , cmdAddCbls :: [(String, Version, FlagAssignment)] }
     | CmdBuildPkgs { pkgs :: [String] }
     | CmdBumpPkgs { inclusive :: Bool, pkgs :: [String] }