diff --git a/ChangeLog.md b/ChangeLog.md
--- a/ChangeLog.md
+++ b/ChangeLog.md
@@ -4,6 +4,13 @@
 Since `rhine` reexports modules from `dunai`,
 every major version in `dunai` triggers a major version in `rhine`.
 
+
+## 0.5.1.0
+
+* Synced with `dunai` version numbers
+* Supported GHC 8.6
+* Added support for randomness with `RandT` in `ClSF`s
+
 ## 0.5.0.0
 
 * Deprecated GHC 7.*
diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -2,4 +2,4 @@
 --------
 
 This is the main library.
-For details, visit [[https://github.com/turion/rhine]].
+For details, visit [https://github.com/turion/rhine](https://github.com/turion/rhine).
diff --git a/rhine.cabal b/rhine.cabal
--- a/rhine.cabal
+++ b/rhine.cabal
@@ -1,6 +1,6 @@
 name:                rhine
 
-version:             0.5.0.1
+version:             0.5.1.0
 
 synopsis: Functional Reactive Programming with type-level clocks
 
@@ -46,7 +46,7 @@
 source-repository this
   type:     git
   location: git@github.com:turion/rhine.git
-  tag:      v0.5.0.1
+  tag:      v0.5.1.0
 
 
 library
@@ -65,6 +65,7 @@
     FRP.Rhine.ClSF
     FRP.Rhine.ClSF.Core
     FRP.Rhine.ClSF.Except
+    FRP.Rhine.ClSF.Random
     FRP.Rhine.ClSF.Reader
     FRP.Rhine.ClSF.Upsample
     FRP.Rhine.ClSF.Util
@@ -89,6 +90,7 @@
     FRP.Rhine.Type
 
   other-modules:
+    FRP.Rhine.ClSF.Random.Util
     FRP.Rhine.ClSF.Except.Util
     FRP.Rhine.Schedule.Util
 
@@ -96,14 +98,16 @@
   -- other-extensions:
 
   -- Other library packages from which modules are imported.
-  build-depends:       base         >= 4.9      && < 4.12
-                    ,  dunai        == 0.4.0.*
+  build-depends:       base         >= 4.9      && < 4.13
+                    ,  dunai        == 0.5.1.*
                     ,  transformers == 0.5.*
                     ,  time         == 1.8.*
                     ,  free         == 5.1.*
-                    ,  containers   == 0.5.*
-                    ,  vector-sized >= 0.6      && < 1.1
+                    ,  containers   == 0.6.*
+                    ,  vector-sized == 1.2.*
                     ,  deepseq      == 1.4.*
+                    ,  random       == 1.1.*
+                    ,  MonadRandom  == 0.5.*
 
   -- Directories containing source files.
   hs-source-dirs:      src
@@ -111,6 +115,9 @@
   ghc-options:         -Wall
                        -Wno-unticked-promoted-constructors
                        -Wno-type-defaults
+
+  if impl(ghc >= 8.6)
+    default-extensions: NoStarIsType
 
   -- Base language which the package is written in.
   default-language:    Haskell2010
diff --git a/src/FRP/Rhine.hs b/src/FRP/Rhine.hs
--- a/src/FRP/Rhine.hs
+++ b/src/FRP/Rhine.hs
@@ -17,8 +17,6 @@
 -- dunai
 import Data.MonadicStreamFunction         as X hiding ((>>>^), (^>>>))
 import Data.VectorSpace                   as X
-import Data.VectorSpace.Specific ()
-import Data.VectorSpace.Tuples ()
 
 -- rhine
 import FRP.Rhine.Clock                    as X
@@ -49,7 +47,6 @@
 import FRP.Rhine.ResamplingBuffer.Collect as X
 import FRP.Rhine.ResamplingBuffer.Timeless as X
 import FRP.Rhine.ResamplingBuffer.KeepLast as X
-import FRP.Rhine.ResamplingBuffer.Util as X
 
 import FRP.Rhine.Schedule.Trans as X
 import FRP.Rhine.Schedule.Concurrently as X
diff --git a/src/FRP/Rhine/ClSF.hs b/src/FRP/Rhine/ClSF.hs
--- a/src/FRP/Rhine/ClSF.hs
+++ b/src/FRP/Rhine/ClSF.hs
@@ -14,5 +14,6 @@
 -- rhine
 import FRP.Rhine.ClSF.Core   as X
 import FRP.Rhine.ClSF.Except as X
+import FRP.Rhine.ClSF.Random as X
 import FRP.Rhine.ClSF.Reader as X
 import FRP.Rhine.ClSF.Util   as X
diff --git a/src/FRP/Rhine/ClSF/Core.hs b/src/FRP/Rhine/ClSF/Core.hs
--- a/src/FRP/Rhine/ClSF/Core.hs
+++ b/src/FRP/Rhine/ClSF/Core.hs
@@ -23,7 +23,7 @@
 import Control.Monad.Trans.Reader (ReaderT, mapReaderT, withReaderT)
 
 -- dunai
-import Data.MonadicStreamFunction (MSF, arrM, arrM_, liftMSFPurer, liftMSFTrans)
+import Data.MonadicStreamFunction (MSF, arrM, constM, morphS, liftTransS)
 import Data.MonadicStreamFunction as X hiding ((>>>^), (^>>>))
 
 -- rhine
@@ -65,7 +65,7 @@
   => (forall c. m1 c -> m2 c)
   -> ClSF m1 cl a b
   -> ClSF m2 cl a b
-hoistClSF hoist = liftMSFPurer $ mapReaderT hoist
+hoistClSF hoist = morphS $ mapReaderT hoist
 
 -- | Hoist a 'ClSF' and its clock along a monad morphism.
 hoistClSFAndClock
@@ -74,7 +74,7 @@
   -> ClSF m1 cl a b
   -> ClSF m2 (HoistClock m1 m2 cl) a b
 hoistClSFAndClock hoist
-  = liftMSFPurer $ withReaderT (retag id) . mapReaderT hoist
+  = morphS $ withReaderT (retag id) . mapReaderT hoist
 
 -- | Lift a 'ClSF' into a monad transformer.
 liftClSF
@@ -93,7 +93,7 @@
 -- | A monadic stream function without dependency on time
 --   is a 'ClSF' for any clock.
 timeless :: Monad m => MSF m a b -> ClSF m cl a b
-timeless = liftMSFTrans
+timeless = liftTransS
 
 -- | Utility to lift Kleisli arrows directly to 'ClSF's.
 arrMCl :: Monad m => (a -> m b) -> ClSF m cl a b
@@ -101,7 +101,7 @@
 
 -- | Version without input.
 constMCl :: Monad m => m b -> ClSF m cl a b
-constMCl = timeless . arrM_
+constMCl = timeless . constM
 
 {- | Call a 'ClSF' every time the input is 'Just a'.
 
diff --git a/src/FRP/Rhine/ClSF/Except.hs b/src/FRP/Rhine/ClSF/Except.hs
--- a/src/FRP/Rhine/ClSF/Except.hs
+++ b/src/FRP/Rhine/ClSF/Except.hs
@@ -43,7 +43,7 @@
 
 -- | Immediately throw the given exception.
 throw :: Monad m => e -> MSF (ExceptT e m) a b
-throw = arrM_ . throwE
+throw = constM . throwE
 
 -- | Do not throw an exception.
 pass :: Monad m => MSF (ExceptT e m) a a
@@ -110,13 +110,13 @@
 
 -- | Leave the monad context, to use the 'ClSFExcept' as an 'Arrow'.
 runClSFExcept :: Monad m => ClSFExcept m cl a b e -> ClSF (ExceptT e m) cl a b
-runClSFExcept = liftMSFPurer commuteExceptReader . runMSFExcept
+runClSFExcept = morphS commuteExceptReader . runMSFExcept
 
 -- | Enter the monad context in the exception
 --   for 'ClSF's in the 'ExceptT' monad.
 --   The 'ClSF' will be run until it encounters an exception.
 try :: Monad m => ClSF (ExceptT e m) cl a b -> ClSFExcept m cl a b e
-try = MSFE.try . liftMSFPurer commuteReaderExcept
+try = MSFE.try . morphS commuteReaderExcept
 
 -- | Within the same tick, perform a monadic action,
 --   and immediately throw the value as an exception.
diff --git a/src/FRP/Rhine/ClSF/Random.hs b/src/FRP/Rhine/ClSF/Random.hs
new file mode 100644
--- /dev/null
+++ b/src/FRP/Rhine/ClSF/Random.hs
@@ -0,0 +1,97 @@
+{-# LANGUAGE RankNTypes #-}
+{-# LANGUAGE TypeFamilies #-}
+-- | Create 'ClSF's with randomness without 'IO'.
+--   Uses the @MonadRandom@ package.
+--   This module copies the API from @dunai@'s
+--   'Control.Monad.Trans.MSF.Random'.
+
+module FRP.Rhine.ClSF.Random
+  ( module FRP.Rhine.ClSF.Random
+  , module X
+  )
+  where
+
+
+-- transformers
+import Control.Monad.IO.Class
+
+-- random
+import System.Random (newStdGen)
+
+-- MonadRandom
+import Control.Monad.Random
+
+-- dunai
+import Control.Monad.Trans.MSF.Except (performOnFirstSample)
+import qualified Control.Monad.Trans.MSF.Random as MSF
+import Control.Monad.Trans.MSF.Random as X hiding (runRandS, evalRandS, getRandomS, getRandomRS, getRandomRS_)
+
+-- rhine
+import FRP.Rhine.ClSF.Core
+import FRP.Rhine.ClSF.Random.Util
+
+-- * Generating random values from the 'RandT' transformer
+
+-- | Generates random values, updating the generator on every step.
+runRandS
+  :: (RandomGen g, Monad m)
+  => ClSF (RandT g m) cl a     b
+  -> g -- ^ The initial random seed
+  -> ClSF          m  cl a (g, b)
+runRandS clsf g = MSF.runRandS (morphS commuteReaderRand clsf) g
+
+-- | Updates the generator every step but discards the generator.
+evalRandS
+  :: (RandomGen g, Monad m)
+  => ClSF (RandT g m) cl a b
+  -> g
+  -> ClSF          m  cl a b
+evalRandS clsf g = runRandS clsf g >>> arr snd
+
+-- | Updates the generator every step but discards the value,
+--   only outputting the generator.
+execRandS
+  :: (RandomGen g, Monad m)
+  => ClSF (RandT g m) cl a b
+  -> g
+  -> ClSF          m  cl a g
+execRandS clsf g = runRandS clsf g >>> arr fst
+
+-- | Evaluates the random computation by using the global random generator.
+evalRandIOS
+  :: Monad m
+  =>     ClSF (RandT StdGen m) cl a b
+  -> IO (ClSF               m  cl a b)
+evalRandIOS clsf = do
+  g <- newStdGen
+  return $ evalRandS clsf g
+
+-- | Evaluates the random computation by using the global random generator on the first tick.
+evalRandIOS'
+  :: MonadIO m
+  => ClSF (RandT StdGen m) cl a b
+  -> ClSF               m  cl a b
+evalRandIOS' = performOnFirstSample . liftIO . evalRandIOS
+
+-- * Creating random behaviours
+
+-- | Produce a random value at every tick.
+getRandomS
+  :: (MonadRandom m, Random a)
+  => Behaviour m time a
+getRandomS = constMCl getRandom
+
+-- | Produce a random value at every tick,
+--   within a range given per tick.
+getRandomRS
+  :: (MonadRandom m, Random a)
+  => BehaviourF m time (a, a) a
+getRandomRS = arrMCl getRandomR
+
+-- | Produce a random value at every tick,
+--   within a range given once.
+getRandomRS_
+  :: (MonadRandom m, Random a)
+  => (a, a)
+  -> Behaviour m time a
+getRandomRS_ = constMCl . getRandomR
diff --git a/src/FRP/Rhine/ClSF/Random/Util.hs b/src/FRP/Rhine/ClSF/Random/Util.hs
new file mode 100644
--- /dev/null
+++ b/src/FRP/Rhine/ClSF/Random/Util.hs
@@ -0,0 +1,13 @@
+module FRP.Rhine.ClSF.Random.Util where
+
+
+-- transformers
+import Control.Monad.Trans.Reader
+
+-- MonadRandom
+import Control.Monad.Random
+
+-- | Commute one 'ReaderT' layer past a 'RandT' layer.
+commuteReaderRand :: ReaderT r (RandT g m) a -> RandT g (ReaderT r m) a
+commuteReaderRand (ReaderT f) = liftRandT $ \g -> ReaderT $ \r -> runRandT (f r) g
+
diff --git a/src/FRP/Rhine/ClSF/Reader.hs b/src/FRP/Rhine/ClSF/Reader.hs
--- a/src/FRP/Rhine/ClSF/Reader.hs
+++ b/src/FRP/Rhine/ClSF/Reader.hs
@@ -32,7 +32,7 @@
   :: Monad m
   => ClSF m cl (a, r) b -> ClSF (ReaderT r m) cl a b
 readerS behaviour
-  = liftMSFPurer commuteReaders $ MSF.readerS $ arr swap >>> behaviour
+  = morphS commuteReaders $ MSF.readerS $ arr swap >>> behaviour
 
 -- | Remove ("run") a 'ReaderT' layer from the monad stack
 --   by making it an explicit input to the behaviour.
@@ -40,7 +40,7 @@
   :: Monad m
   => ClSF (ReaderT r m) cl a b -> ClSF m cl (a, r) b
 runReaderS behaviour
-  = arr swap >>> (MSF.runReaderS $ liftMSFPurer commuteReaders behaviour)
+  = arr swap >>> (MSF.runReaderS $ morphS commuteReaders behaviour)
 
 -- | Remove a 'ReaderT' layer by passing the readonly environment explicitly.
 runReaderS_
diff --git a/src/FRP/Rhine/ClSF/Util.hs b/src/FRP/Rhine/ClSF/Util.hs
--- a/src/FRP/Rhine/ClSF/Util.hs
+++ b/src/FRP/Rhine/ClSF/Util.hs
@@ -29,7 +29,7 @@
 
 -- dunai
 import Control.Monad.Trans.MSF.Reader (readerS)
-import Data.MonadicStreamFunction (arrM_, sumFrom, delay, feedback)
+import Data.MonadicStreamFunction (constM, sumFrom, iPre, feedback)
 import Data.MonadicStreamFunction.Instances.VectorSpace ()
 import Data.VectorSpace
 
@@ -42,7 +42,7 @@
 
 -- | Read the environment variable, i.e. the 'TimeInfo'.
 timeInfo :: Monad m => ClSF m cl a (TimeInfo cl)
-timeInfo = arrM_ ask
+timeInfo = constM ask
 
 {- | Utility to apply functions to the current 'TimeInfo',
 such as record selectors:
@@ -52,7 +52,7 @@
 @
 -}
 timeInfoOf :: Monad m => (TimeInfo cl -> b) -> ClSF m cl a b
-timeInfoOf f = arrM_ $ asks f
+timeInfoOf f = constM $ asks f
 
 -- | Continuously return the time difference since the last tick.
 sinceLastS :: Monad m => ClSF m cl a (Diff (Time cl))
@@ -166,7 +166,7 @@
      , Groundfield v ~ Diff td)
   => v -> BehaviorF m td v v
 derivativeFrom v0 = proc v -> do
-  vLast         <- delay v0 -< v
+  vLast         <- iPre v0  -< v
   TimeInfo {..} <- timeInfo -< ()
   returnA                   -< (v ^-^ vLast) ^/ sinceLast
 
@@ -186,7 +186,7 @@
   -> BehaviorF m td v v
 threePointDerivativeFrom v0 = proc v -> do
   dv  <- derivativeFrom v0 -< v
-  dv' <- delay zeroVector  -< dv
+  dv' <- iPre zeroVector   -< dv
   returnA                  -< (dv ^+^ dv') ^/ 2
 
 -- | Like 'threePointDerivativeFrom',
diff --git a/src/FRP/Rhine/Clock.hs b/src/FRP/Rhine/Clock.hs
--- a/src/FRP/Rhine/Clock.hs
+++ b/src/FRP/Rhine/Clock.hs
@@ -235,7 +235,7 @@
   type Tag  (HoistClock m1 m2 cl) = Tag  cl
   initClock HoistClock {..} = do
     (runningClock, initialTime) <- monadMorphism $ initClock unhoistedClock
-    let hoistMSF = liftMSFPurer
+    let hoistMSF = morphS
     -- TODO Look out for API changes in dunai here
     return
       ( hoistMSF monadMorphism runningClock
diff --git a/src/FRP/Rhine/Clock/Periodic.hs b/src/FRP/Rhine/Clock/Periodic.hs
--- a/src/FRP/Rhine/Clock/Periodic.hs
+++ b/src/FRP/Rhine/Clock/Periodic.hs
@@ -23,8 +23,6 @@
 import GHC.TypeLits (Nat, KnownNat, natVal)
 
 -- dunai
-import Control.Monad.Trans.MSF.Except
-import Control.Monad.Trans.MSF.Maybe (listToMaybeS, runMaybeT)
 import Data.MonadicStreamFunction
 
 -- rhine
diff --git a/src/FRP/Rhine/Clock/Realtime/Busy.hs b/src/FRP/Rhine/Clock/Realtime/Busy.hs
--- a/src/FRP/Rhine/Clock/Realtime/Busy.hs
+++ b/src/FRP/Rhine/Clock/Realtime/Busy.hs
@@ -24,7 +24,7 @@
   initClock _ = do
     initialTime <- getCurrentTime
     return
-      ( arrM_ getCurrentTime
+      ( constM getCurrentTime
         &&& arr (const ())
       , initialTime
       )
diff --git a/src/FRP/Rhine/Clock/Realtime/Event.hs b/src/FRP/Rhine/Clock/Realtime/Event.hs
--- a/src/FRP/Rhine/Clock/Realtime/Event.hs
+++ b/src/FRP/Rhine/Clock/Realtime/Event.hs
@@ -44,7 +44,6 @@
 
 -- rhine
 import FRP.Rhine.ClSF
-import FRP.Rhine.Clock
 import FRP.Rhine.Schedule
 import FRP.Rhine.Schedule.Concurrently
 
@@ -68,7 +67,7 @@
 e.g. @runEventChanT $ flow myRhine@.
 This way, exactly one channel is created.
 
-Caution: Don't use this with 'liftMSFPurer',
+Caution: Don't use this with 'morphS',
 since it would create a new channel every tick.
 Instead, create one @chan :: Chan c@, e.g. with 'newChan',
 and then use 'withChanS'.
@@ -154,7 +153,7 @@
   initClock _ = do
     initialTime <- liftIO getCurrentTime
     return
-      ( arrM_ $ do
+      ( constM $ do
           chan  <- ask
           event <- liftIO $ readChan chan
           time  <- liftIO $ getCurrentTime
diff --git a/src/FRP/Rhine/Clock/Realtime/Stdin.hs b/src/FRP/Rhine/Clock/Realtime/Stdin.hs
--- a/src/FRP/Rhine/Clock/Realtime/Stdin.hs
+++ b/src/FRP/Rhine/Clock/Realtime/Stdin.hs
@@ -33,7 +33,7 @@
   initClock _ = do
     initialTime <- liftIO getCurrentTime
     return
-      ( arrM_ $ liftIO $ do
+      ( constM $ liftIO $ do
           line <- getLine
           time <- getCurrentTime
           return (time, line)
diff --git a/src/FRP/Rhine/Reactimation.hs b/src/FRP/Rhine/Reactimation.hs
--- a/src/FRP/Rhine/Reactimation.hs
+++ b/src/FRP/Rhine/Reactimation.hs
@@ -9,7 +9,7 @@
 
 
 -- dunai
-import Data.MonadicStreamFunction
+import Data.MonadicStreamFunction.InternalCore
 
 -- rhine
 import FRP.Rhine.Clock
diff --git a/src/FRP/Rhine/Reactimation/Tick.hs b/src/FRP/Rhine/Reactimation/Tick.hs
--- a/src/FRP/Rhine/Reactimation/Tick.hs
+++ b/src/FRP/Rhine/Reactimation/Tick.hs
@@ -13,6 +13,7 @@
 
 -- dunai
 import Data.MonadicStreamFunction
+import Data.MonadicStreamFunction.InternalCore
 
 -- rhine
 import FRP.Rhine.Clock
diff --git a/src/FRP/Rhine/ResamplingBuffer/Interpolation.hs b/src/FRP/Rhine/ResamplingBuffer/Interpolation.hs
--- a/src/FRP/Rhine/ResamplingBuffer/Interpolation.hs
+++ b/src/FRP/Rhine/ResamplingBuffer/Interpolation.hs
@@ -13,7 +13,6 @@
 
 -- dunai
 import Data.VectorSpace
-import Data.VectorSpace.Tuples
 
 -- rhine
 import FRP.Rhine.ClSF
@@ -86,8 +85,8 @@
      , Groundfield v ~ Diff (Time cl2)
      )
   => ResamplingBuffer m cl1 cl2 v v
-cubic = ((delay zeroVector &&& threePointDerivative) &&& (sinceInitS >-> delay 0))
-    >-> (clId &&& delay (zeroVector, 0))
+cubic = ((iPre zeroVector &&& threePointDerivative) &&& (sinceInitS >-> iPre 0))
+    >-> (clId &&& iPre (zeroVector, 0))
    ^->> keepLast ((zeroVector, 0), (zeroVector, 0))
    >>-^ proc (((dv, v), t1), ((dv', v'), t1')) -> do
      t2 <- sinceInitS -< ()
diff --git a/src/FRP/Rhine/ResamplingBuffer/MSF.hs b/src/FRP/Rhine/ResamplingBuffer/MSF.hs
--- a/src/FRP/Rhine/ResamplingBuffer/MSF.hs
+++ b/src/FRP/Rhine/ResamplingBuffer/MSF.hs
@@ -5,6 +5,9 @@
 {-# LANGUAGE RecordWildCards #-}
 module FRP.Rhine.ResamplingBuffer.MSF where
 
+-- dunai
+import Data.MonadicStreamFunction.InternalCore
+
 -- rhine
 import FRP.Rhine.ResamplingBuffer
 
diff --git a/src/FRP/Rhine/ResamplingBuffer/Util.hs b/src/FRP/Rhine/ResamplingBuffer/Util.hs
--- a/src/FRP/Rhine/ResamplingBuffer/Util.hs
+++ b/src/FRP/Rhine/ResamplingBuffer/Util.hs
@@ -8,6 +8,9 @@
 -- transformers
 import Control.Monad.Trans.Reader (runReaderT)
 
+-- dunai
+import Data.MonadicStreamFunction.InternalCore
+
 -- rhine
 import FRP.Rhine.Clock
 import FRP.Rhine.ClSF
diff --git a/src/FRP/Rhine/Schedule.hs b/src/FRP/Rhine/Schedule.hs
--- a/src/FRP/Rhine/Schedule.hs
+++ b/src/FRP/Rhine/Schedule.hs
@@ -64,7 +64,7 @@
   where
     initSchedule' cl1 cl2 = hoist
       $ first (hoistMSF hoist) <$> initSchedule cl1 cl2
-    hoistMSF = liftMSFPurer
+    hoistMSF = morphS
     -- TODO This should be a dunai issue
 
 -- | Swaps the clocks for a given schedule.
@@ -123,7 +123,7 @@
        (HoistClock (ReaderT r m) m cl1) (HoistClock (ReaderT r m) m cl2)
   -> Schedule (ReaderT r m) cl1 cl2
 readerSchedule Schedule {..}
-  = Schedule $ \cl1 cl2 -> ReaderT $ \r -> first liftMSFTrans
+  = Schedule $ \cl1 cl2 -> ReaderT $ \r -> first liftTransS
   <$> initSchedule
         (HoistClock cl1 $ flip runReaderT r)
         (HoistClock cl2 $ flip runReaderT r)
diff --git a/src/FRP/Rhine/Schedule/Concurrently.hs b/src/FRP/Rhine/Schedule/Concurrently.hs
--- a/src/FRP/Rhine/Schedule/Concurrently.hs
+++ b/src/FRP/Rhine/Schedule/Concurrently.hs
@@ -46,7 +46,7 @@
   _ <- launchSubthread cl2 Right iMVar mvar
   initTime <- takeMVar iMVar -- The first clock to be initialised sets the first time stamp
   _        <- takeMVar iMVar -- Initialise the second clock
-  return (arrM_ $ takeMVar mvar, initTime)
+  return (constM $ takeMVar mvar, initTime)
   where
     launchSubthread cl leftright iMVar mvar = forkIO $ do
       (runningClock, initTime) <- initClock cl
@@ -78,7 +78,7 @@
   (_       , w2) <- lift $ takeMVar iMVar
   tell w1
   tell w2
-  return (arrM_ (WriterT $ takeMVar mvar), initTime)
+  return (constM (WriterT $ takeMVar mvar), initTime)
   where
     launchSubthread cl leftright iMVar mvar = lift $ forkIO $ do
       ((runningClock, initTime), w) <- runWriterT $ initClock cl
@@ -107,7 +107,7 @@
   catchAndDrain mvar $ do
     initTime <- ExceptT $ takeMVar iMVar -- The first clock to be initialised sets the first time stamp
     _        <- ExceptT $ takeMVar iMVar -- Initialise the second clock
-    let runningSchedule = arrM_ $ do
+    let runningSchedule = constM $ do
           eTick <- lift $ takeMVar mvar
           case eTick of
             Right tick -> return tick
@@ -122,14 +122,14 @@
         Right (runningClock, initTime) -> do
           putMVar iMVar $ Right initTime
           Left e <- runExceptT $ reactimate $ runningClock >>> proc (td, tag2) -> do
-            arrM (lift . putMVar mvar)              -< Right (td, leftright tag2)
-            me <- arrM_ (lift $ readIORef errorref) -< ()
-            _  <- throwMaybe                        -< me
+            arrM (lift . putMVar mvar)               -< Right (td, leftright tag2)
+            me <- constM (lift $ readIORef errorref) -< ()
+            _  <- throwMaybe                         -< me
             returnA -< ()
           putMVar mvar $ Left e -- Either throw own exception or acknowledge the exception from the other clock
         Left e -> void $ putMVar iMVar $ Left e
     catchAndDrain mvar initScheduleAction = catchE initScheduleAction $ \e -> do
-      _ <- reactimate $ (arrM_ $ ExceptT $ takeMVar mvar) >>> arr (const ()) -- Drain the mvar until the other clock acknowledges the exception
+      _ <- reactimate $ (constM $ ExceptT $ takeMVar mvar) >>> arr (const ()) -- Drain the mvar until the other clock acknowledges the exception
       throwE e
 
 -- | As 'concurrentlyExcept', with a single possible exception value.
diff --git a/src/FRP/Rhine/Schedule/Trans.hs b/src/FRP/Rhine/Schedule/Trans.hs
--- a/src/FRP/Rhine/Schedule/Trans.hs
+++ b/src/FRP/Rhine/Schedule/Trans.hs
@@ -8,6 +8,9 @@
 {-# LANGUAGE TypeFamilies #-}
 module FRP.Rhine.Schedule.Trans where
 
+-- dunai
+import Data.MonadicStreamFunction.InternalCore
+
 -- rhine
 import Control.Monad.Schedule
 import FRP.Rhine.Clock
diff --git a/src/FRP/Rhine/TimeDomain.hs b/src/FRP/Rhine/TimeDomain.hs
--- a/src/FRP/Rhine/TimeDomain.hs
+++ b/src/FRP/Rhine/TimeDomain.hs
@@ -16,10 +16,6 @@
 -- time
 import Data.Time.Clock (UTCTime, diffUTCTime)
 
--- dunai
-import Data.VectorSpace.Specific ()
-
-
 -- | A time domain is an affine space representing a notion of time,
 --   such as real time, simulated time, steps, or a completely different notion.
 class TimeDomain time where