diff --git a/Changelog.md b/Changelog.md
--- a/Changelog.md
+++ b/Changelog.md
@@ -1,3 +1,8 @@
+# 0.1
+
+- Drop `random` dependency unconditionally.
+  https://github.com/phadej/splitmix/issues/34
+
 # 0.0.5
 
 - Add `nextInteger`
diff --git a/bench/Bench.hs b/bench/Bench.hs
--- a/bench/Bench.hs
+++ b/bench/Bench.hs
@@ -16,36 +16,37 @@
 -------------------------------------------------------------------------------
 
 -- infinite list
-genList :: R.RandomGen g => g -> [Int]
-genList = unfoldr (Just . R.next)
+genList :: (g -> (Int, g)) -> g -> [Int]
+genList next = unfoldr (Just . next)
 
 -- truncated
-genListN :: R.RandomGen g => g -> [Int]
-genListN = take 2048 . genList
+genListN :: (g -> (Int, g)) -> g -> [Int]
+genListN next = take 2048 . genList next
 
 randomList :: Int -> [Int]
-randomList = genListN . R.mkStdGen
+randomList = genListN R.random . R.mkStdGen
 
 tfRandomList :: Word64 -> [Int]
-tfRandomList w64 = genListN $ TF.seedTFGen (w64, w64, w64, w64)
+tfRandomList w64 = genListN R.random $ TF.seedTFGen (w64, w64, w64, w64)
 
 splitMixList :: Word64 -> [Int]
-splitMixList w64 = genListN $ SM.mkSMGen w64
+splitMixList w64 = genListN SM.nextInt $ SM.mkSMGen w64
 
 splitMix32List :: Word64 -> [Int]
-splitMix32List w64 = genListN $ SM32.mkSMGen $ fromIntegral w64
+splitMix32List w64 = genListN SM32.nextInt $ SM32.mkSMGen $ fromIntegral w64
 
 -------------------------------------------------------------------------------
 -- Tree
 -------------------------------------------------------------------------------
 
-genTree :: R.RandomGen g => g -> T.Tree Int
-genTree g = case R.next g of
-    ~(i, g') -> T.Node i $ case R.split g' of
-        (ga, gb) -> [genTree ga, genTree gb]
+genTree :: (g -> (Int, g)) -> (g -> (g, g)) -> g -> T.Tree Int
+genTree next split = go where
+    go g = case next g of
+        ~(i, g') -> T.Node i $ case split g' of
+            (ga, gb) -> [go ga, go gb]
 
-genTreeN :: R.RandomGen g => g -> T.Tree Int
-genTreeN = cutTree 9 . genTree
+genTreeN :: (g -> (Int, g)) -> (g -> (g, g)) -> g -> T.Tree Int
+genTreeN next split = cutTree 9 . genTree next split
   where
     cutTree :: Int -> T.Tree a -> T.Tree a
     cutTree n (T.Node x forest)
@@ -53,16 +54,16 @@
         | otherwise = T.Node x (map (cutTree (n - 1)) forest)
 
 randomTree :: Int -> T.Tree Int
-randomTree = genTreeN . R.mkStdGen
+randomTree = genTreeN R.next R.split . R.mkStdGen
 
 tfRandomTree :: Word64 -> T.Tree Int
-tfRandomTree w64 = genTreeN $ TF.seedTFGen (w64, w64, w64, w64)
+tfRandomTree w64 = genTreeN R.next R.split $ TF.seedTFGen (w64, w64, w64, w64)
 
 splitMixTree :: Word64 -> T.Tree Int
-splitMixTree w64 = genTreeN $ SM.mkSMGen w64
+splitMixTree w64 = genTreeN SM.nextInt SM.splitSMGen $ SM.mkSMGen w64
 
 splitMix32Tree :: Word64 -> T.Tree Int
-splitMix32Tree w64 = genTreeN $ SM32.mkSMGen $ fromIntegral w64
+splitMix32Tree w64 = genTreeN SM32.nextInt SM32.splitSMGen $ SM32.mkSMGen $ fromIntegral w64
 
 -------------------------------------------------------------------------------
 -- List Word64
@@ -92,14 +93,14 @@
 -- Tree Word64
 -------------------------------------------------------------------------------
 
-genTree64 :: R.RandomGen g => (g -> (Word64, g)) -> g -> T.Tree Word64
-genTree64 r = go where
+genTree64 ::(g -> (Word64, g)) -> (g -> (g, g)) -> g -> T.Tree Word64
+genTree64 r split = go where
     go g = case r g of
-        ~(i, g') -> T.Node i $ case R.split g' of
+        ~(i, g') -> T.Node i $ case split g' of
             (ga, gb) -> [go ga, go gb]
 
-genTreeN64 :: R.RandomGen g => (g -> (Word64, g)) -> g -> T.Tree Word64
-genTreeN64 r = cutTree 9 . genTree64 r
+genTreeN64 :: (g -> (Word64, g)) -> (g -> (g, g)) -> g -> T.Tree Word64
+genTreeN64 r split = cutTree 9 . genTree64 r split
   where
     cutTree :: Word64 -> T.Tree a -> T.Tree a
     cutTree n (T.Node x forest)
@@ -107,16 +108,16 @@
         | otherwise = T.Node x (map (cutTree (n - 1)) forest)
 
 randomTree64 :: Int -> T.Tree Word64
-randomTree64 = genTreeN64 R.random . R.mkStdGen
+randomTree64 = genTreeN64 R.random R.split . R.mkStdGen
 
 tfRandomTree64 :: Word64 -> T.Tree Word64
-tfRandomTree64 w64 = genTreeN64 TF.random $ TF.seedTFGen (w64, w64, w64, w64)
+tfRandomTree64 w64 = genTreeN64 TF.random R.split $ TF.seedTFGen (w64, w64, w64, w64)
 
 splitMixTree64 :: Word64 -> T.Tree Word64
-splitMixTree64 w64 = genTreeN64 SM.nextWord64 $ SM.mkSMGen w64
+splitMixTree64 w64 = genTreeN64 SM.nextWord64 SM.splitSMGen $ SM.mkSMGen w64
 
 splitMix32Tree64 :: Word64 -> T.Tree Word64
-splitMix32Tree64 w64 = genTreeN64 SM32.nextWord64 $ SM32.mkSMGen $ fromIntegral w64
+splitMix32Tree64 w64 = genTreeN64 SM32.nextWord64 SM32.splitSMGen $ SM32.mkSMGen $ fromIntegral w64
 
 -------------------------------------------------------------------------------
 -- Main
diff --git a/bench/Range.hs b/bench/Range.hs
--- a/bench/Range.hs
+++ b/bench/Range.hs
@@ -8,7 +8,6 @@
 import Data.List        (unfoldr)
 import Data.Word        (Word32, Word64)
 
-import qualified System.Random            as R
 import qualified System.Random.SplitMix32 as SM
 
 #if defined(__GHCJS__)
@@ -21,7 +20,7 @@
 main = do
     gen <- SM.newSMGen
 
-    bench gen (\g h -> R.randomR (0, pred h) g)
+    -- bench gen (\g h -> R (0, pred h) g)
     bench gen classicMod
     bench gen intMult
     bench gen bitmaskWithRejection
diff --git a/splitmix.cabal b/splitmix.cabal
--- a/splitmix.cabal
+++ b/splitmix.cabal
@@ -1,6 +1,6 @@
 cabal-version:      >=1.10
 name:               splitmix
-version:            0.0.5
+version:            0.1
 synopsis:           Fast Splittable PRNG
 description:
   Pure Haskell implementation of SplitMix described in
@@ -58,11 +58,6 @@
   manual:      True
   default:     False
 
-flag random
-  description: Providen RandomGen SMGen instance
-  manual:      True
-  default:     True
-
 library
   default-language: Haskell2010
   ghc-options:      -Wall
@@ -80,9 +75,6 @@
       base     >=4.3     && <4.15
     , deepseq  >=1.3.0.0 && <1.5
     , time     >=1.2.0.3 && <1.10
-
-  if flag(random)
-    build-depends: random >=1.0 && <1.2
 
   if flag(optimised-mixer)
     cpp-options: -DOPTIMISED_MIX32=1
diff --git a/src/System/Random/SplitMix.hs b/src/System/Random/SplitMix.hs
--- a/src/System/Random/SplitMix.hs
+++ b/src/System/Random/SplitMix.hs
@@ -69,10 +69,6 @@
 import Control.DeepSeq (NFData (..))
 #endif
 
-#ifdef MIN_VERSION_random
-import qualified System.Random as R
-#endif
-
 #if !__GHCJS__
 import System.CPUTime (cpuTimePrecision, getCPUTime)
 #endif
@@ -396,16 +392,6 @@
     let hi = fromIntegral (cpu `div` cpuTimePrecision) :: Word32
 #endif
     return $ fromIntegral hi `shiftL` 32 .|. fromIntegral lo
-
--------------------------------------------------------------------------------
--- System.Random
--------------------------------------------------------------------------------
-
-#ifdef MIN_VERSION_random
-instance R.RandomGen SMGen where
-    next = nextInt
-    split = splitSMGen
-#endif
 
 -------------------------------------------------------------------------------
 -- Hugs
diff --git a/src/System/Random/SplitMix32.hs b/src/System/Random/SplitMix32.hs
--- a/src/System/Random/SplitMix32.hs
+++ b/src/System/Random/SplitMix32.hs
@@ -53,10 +53,6 @@
 import Control.DeepSeq (NFData (..))
 #endif
 
-#ifdef MIN_VERSION_random
-import qualified System.Random as R
-#endif
-
 #if !__GHCJS__
 import System.CPUTime (cpuTimePrecision, getCPUTime)
 #endif
@@ -375,13 +371,3 @@
     let hi = fromIntegral (cpu `div` cpuTimePrecision) :: Word32
 #endif
     return $ fromIntegral hi `shiftL` 32 .|. fromIntegral lo
-
--------------------------------------------------------------------------------
--- System.Random
--------------------------------------------------------------------------------
-
-#ifdef MIN_VERSION_random
-instance R.RandomGen SMGen where
-    next = nextInt
-    split = splitSMGen
-#endif