diff --git a/ChangeLog.md b/ChangeLog.md
--- a/ChangeLog.md
+++ b/ChangeLog.md
@@ -4,6 +4,10 @@
 Since `rhine` reexports modules from `dunai`,
 every major version in `dunai` triggers a major version in `rhine`.
 
+## 0.6.0
+
+* Synced with `dunai` version numbers
+* Supported GHC 8.8.3
 
 ## 0.5.1.0
 
diff --git a/rhine.cabal b/rhine.cabal
--- a/rhine.cabal
+++ b/rhine.cabal
@@ -1,6 +1,6 @@
 name:                rhine
 
-version:             0.5.1.1
+version:             0.6.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.1.1
+  tag:      v0.6.0
 
 
 library
@@ -98,16 +98,17 @@
   -- other-extensions:
 
   -- Other library packages from which modules are imported.
-  build-depends:       base         >= 4.9      && < 4.13
-                    ,  dunai        == 0.5.1.*
-                    ,  transformers == 0.5.*
-                    ,  time         == 1.8.*
-                    ,  free         == 5.1.*
-                    ,  containers   == 0.6.*
-                    ,  vector-sized == 1.4.*
-                    ,  deepseq      == 1.4.*
-                    ,  random       == 1.1.*
-                    ,  MonadRandom  == 0.5.*
+  build-depends:       base         >= 4.9 && < 5
+                     , dunai        >= 0.6
+                     , transformers == 0.5.*
+                     , time         >= 1.8
+                     , free         == 5.1.*
+                     , containers   == 0.6.*
+                     , vector-sized == 1.4.*
+                     , deepseq      == 1.4.*
+                     , random       == 1.1.*
+                     , MonadRandom  == 0.5.*
+                     , simple-affine-space
 
   -- Directories containing source files.
   hs-source-dirs:      src
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
@@ -31,6 +31,8 @@
 import Control.Monad.Trans.MSF.Reader (readerS)
 import Data.MonadicStreamFunction (constM, sumFrom, iPre, feedback)
 import Data.MonadicStreamFunction.Instances.VectorSpace ()
+
+-- simple-affine-space
 import Data.VectorSpace
 
 -- rhine
@@ -143,8 +145,8 @@
 -- | The output of @integralFrom v0@ is the numerical Euler integral
 --   of the input, with initial offset @v0@.
 integralFrom
-  :: ( Monad m, VectorSpace v
-     , Groundfield v ~ Diff td)
+  :: ( Monad m, VectorSpace v s
+     , s ~ Diff td)
   => v -> BehaviorF m td v v
 integralFrom v0 = proc v -> do
   _sinceLast <- timeInfoOf sinceLast -< ()
@@ -152,8 +154,8 @@
 
 -- | Euler integration, with zero initial offset.
 integral
-  :: ( Monad m, VectorSpace v
-     , Groundfield v ~ Diff td)
+  :: ( Monad m, VectorSpace v s
+     , s ~ Diff td)
   => BehaviorF m td v v
 integral = integralFrom zeroVector
 
@@ -162,8 +164,8 @@
 --   with a Newton difference quotient.
 --   The input is initialised with @v0@.
 derivativeFrom
-  :: ( Monad m, VectorSpace v
-     , Groundfield v ~ Diff td)
+  :: ( Monad m, VectorSpace v s
+     , s ~ Diff td)
   => v -> BehaviorF m td v v
 derivativeFrom v0 = proc v -> do
   vLast         <- iPre v0  -< v
@@ -172,16 +174,16 @@
 
 -- | Numerical derivative with input initialised to zero.
 derivative
-  :: ( Monad m, VectorSpace v
-     , Groundfield v ~ Diff td)
+  :: ( Monad m, VectorSpace v s
+     , s ~ Diff td)
   => BehaviorF m td v v
 derivative = derivativeFrom zeroVector
 
 -- | Like 'derivativeFrom', but uses three samples to compute the derivative.
 --   Consequently, it is delayed by one sample.
 threePointDerivativeFrom
-  :: ( Monad m, VectorSpace v
-     , Groundfield v ~ Diff td)
+  :: ( Monad m, VectorSpace v s
+     , s ~ Diff td)
   => v -- ^ The initial position
   -> BehaviorF m td v v
 threePointDerivativeFrom v0 = proc v -> do
@@ -192,8 +194,8 @@
 -- | Like 'threePointDerivativeFrom',
 --   but with the initial position initialised to 'zeroVector'.
 threePointDerivative
-  :: ( Monad m, VectorSpace v
-     , Groundfield v ~ Diff td)
+  :: ( Monad m, VectorSpace v s
+     , s ~ Diff td)
   => BehaviorF m td v v
 threePointDerivative = threePointDerivativeFrom zeroVector
 
@@ -207,10 +209,10 @@
 --   so a weight of 1 simply repeats the past value unchanged,
 --   whereas a weight of 0 outputs the current value.
 weightedAverageFrom
-  :: ( Monad m, VectorSpace v
-     , Groundfield v ~ Diff td)
+  :: ( Monad m, VectorSpace v s
+     , s ~ Diff td)
   => v -- ^ The initial position
-  -> BehaviorF m td (v, Groundfield v) v
+  -> BehaviorF m td (v, s) v
 weightedAverageFrom v0 = feedback v0 $ proc ((v, weight), vAvg) -> do
   let
     vAvg' = weight *^ vAvg ^+^ (1 - weight) *^ v
@@ -221,9 +223,9 @@
 --   all features below a given time constant @t@.
 --   (Equivalently, it filters out frequencies above @1 / (2 * pi * t)@.)
 averageFrom
-  :: ( Monad m, VectorSpace v
-     , Floating (Groundfield v)
-     , Groundfield v ~ Diff td)
+  :: ( Monad m, VectorSpace v s
+     , Floating s
+     , s ~ Diff td)
   => v -- ^ The initial position
   -> Diff td -- ^ The time scale on which the signal is averaged
   -> BehaviorF m td v v
@@ -236,9 +238,9 @@
 
 -- | An average, or low pass, initialised to zero.
 average
-  :: ( Monad m, VectorSpace v
-     , Floating (Groundfield v)
-     , Groundfield v ~ Diff td)
+  :: ( Monad m, VectorSpace v s
+     , Floating s
+     , s ~ Diff td)
   => Diff td -- ^ The time scale on which the signal is averaged
   -> BehaviourF m td v v
 average = averageFrom zeroVector
@@ -248,8 +250,8 @@
 --   if the supplied time scale is much bigger
 --   than the average time difference between two ticks.
 averageLinFrom
-  :: ( Monad m, VectorSpace v
-     , Groundfield v ~ Diff td)
+  :: ( Monad m, VectorSpace v s
+     , s ~ Diff td)
   => v -- ^ The initial position
   -> Diff td -- ^ The time scale on which the signal is averaged
   -> BehaviourF m td v v
@@ -261,8 +263,8 @@
 
 -- | Linearised version of 'average'.
 averageLin
-  :: ( Monad m, VectorSpace v
-     , Groundfield v ~ Diff td)
+  :: ( Monad m, VectorSpace v s
+     , s ~ Diff td)
   => Diff td -- ^ The time scale on which the signal is averaged
   -> BehaviourF m td v v
 averageLin = averageLinFrom zeroVector
@@ -271,36 +273,36 @@
 
 -- | Alias for 'average'.
 lowPass
-  :: ( Monad m, VectorSpace v
-     , Floating (Groundfield v)
-     , Groundfield v ~ Diff td)
+  :: ( Monad m, VectorSpace v s
+     , Floating s
+     , s ~ Diff td)
   => Diff td
   -> BehaviourF m td v v
 lowPass = average
 
 -- | Filters out frequencies below @1 / (2 * pi * t)@.
 highPass
-  :: ( Monad m, VectorSpace v
-     , Floating (Groundfield v)
-     , Groundfield v ~ Diff td)
+  :: ( Monad m, VectorSpace v s
+     , Floating s
+     , s ~ Diff td)
   => Diff td -- ^ The time constant @t@
   -> BehaviourF m td v v
 highPass t = clId ^-^ lowPass t
 
 -- | Filters out frequencies other than @1 / (2 * pi * t)@.
 bandPass
-  :: ( Monad m, VectorSpace v
-     , Floating (Groundfield v)
-     , Groundfield v ~ Diff td)
+  :: ( Monad m, VectorSpace v s
+     , Floating s
+     , s ~ Diff td)
   => Diff td -- ^ The time constant @t@
   -> BehaviourF m td v v
 bandPass t = lowPass t >>> highPass t
 
 -- | Filters out the frequency @1 / (2 * pi * t)@.
 bandStop
-  :: ( Monad m, VectorSpace v
-     , Floating (Groundfield v)
-     , Groundfield v ~ Diff td)
+  :: ( Monad m, VectorSpace v s
+     , Floating s
+     , s ~ Diff td)
   => Diff td -- ^ The time constant @t@
   -> BehaviourF m td v v
 bandStop t = clId ^-^ bandPass t
@@ -326,16 +328,16 @@
     appendValue (ti, a) tias  = takeWhileL (recentlySince ti) $ (ti, a) <| tias
     recentlySince ti (ti', _) = diffTime (absolute ti) (absolute ti') < dTime
 
--- | Delay a signal by certain time span.
+-- | Delay a signal by certain time span,
+--   initialising with the first input.
 delayBy
-  :: (Monad m, Ord (Diff (Time cl)), TimeDomain (Time cl))
-  => Diff (Time cl) -- ^ The time span to delay the signal
-  -> ClSF m cl a a
+  :: (Monad m, Ord (Diff td), TimeDomain td)
+  => Diff td            -- ^ The time span to delay the signal
+  -> BehaviorF m td a a
 delayBy dTime = historySince dTime >>> arr (viewr >>> safeHead) >>> lastS undefined >>> arr snd
   where
     safeHead EmptyR   = Nothing
     safeHead (_ :> a) = Just a
--- TODO Think about how to do it without undefined (maybe exceptions)
 
 -- * Timers
 
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
@@ -45,7 +45,7 @@
   type Time (Periodic v) = Integer
   type Tag  (Periodic v) = ()
   initClock cl = return
-    ( cycleS (theList cl) >>> withSideEffect wait >>> sumS &&& arr (const ())
+    ( cycleS (theList cl) >>> withSideEffect wait >>> (accumulateWith (+) 0) &&& arr (const ())
     , 0
     )
 
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
@@ -11,7 +11,7 @@
 -- containers
 import Data.Sequence
 
--- dunai
+-- simple-affine-space
 import Data.VectorSpace
 
 -- rhine
@@ -23,9 +23,9 @@
 -- | A simple linear interpolation based on the last calculated position and velocity.
 linear
   :: ( Monad m, Clock m cl1, Clock m cl2
-     , VectorSpace v
-     , Groundfield v ~ Diff (Time cl1)
-     , Groundfield v ~ Diff (Time cl2)
+     , VectorSpace v s
+     , s ~ Diff (Time cl1)
+     , s ~ Diff (Time cl2)
      )
   => v -- ^ The initial velocity (derivative of the signal)
   -> v -- ^ The initial position
@@ -36,7 +36,7 @@
   >>-^ proc ((velocity, lastPosition), sinceInit1) -> do
     sinceInit2 <- timeInfoOf sinceInit -< ()
     let diff = sinceInit2 - sinceInit1
-    returnA -< lastPosition ^+^ velocity ^* diff
+    returnA -< lastPosition ^+^ diff *^ velocity
 
 {- |
 sinc-Interpolation, or Whittaker-Shannon-Interpolation.
@@ -51,13 +51,13 @@
 -}
 sinc
   :: ( Monad m, Clock m cl1, Clock m cl2
-     , VectorSpace v
-     , Ord (Groundfield v)
-     , Floating (Groundfield v)
-     , Groundfield v ~ Diff (Time cl1)
-     , Groundfield v ~ Diff (Time cl2)
+     , VectorSpace v s
+     , Ord (s)
+     , Floating (s)
+     , s ~ Diff (Time cl1)
+     , s ~ Diff (Time cl2)
      )
-  => Groundfield v
+  => s
   -- ^ The size of the interpolation window
   --   (for how long in the past to remember incoming values)
   -> ResamplingBuffer m cl1 cl2 v v
@@ -67,7 +67,7 @@
   where
     mkSinc sinceInit2 (TimeInfo {..}, as)
       = let t = pi * (sinceInit2 - sinceInit) / sinceLast
-        in  as ^* (sin t / t)
+        in  (sin t / t) *^ as
     vectorSum = foldr (^+^) zeroVector
 
 -- TODO Do we want to give initial values?
@@ -80,9 +80,10 @@
 --   if the ticks of @cl2@ are delayed by two ticks of @cl1@.
 cubic
   :: ( Monad m
-     , VectorSpace v
-     , Groundfield v ~ Diff (Time cl1)
-     , Groundfield v ~ Diff (Time cl2)
+     , VectorSpace v s
+     , Floating v, Eq v
+     , s ~ Diff (Time cl1)
+     , s ~ Diff (Time cl2)
      )
   => ResamplingBuffer m cl1 cl2 v v
 cubic = ((iPre zeroVector &&& threePointDerivative) &&& (sinceInitS >-> iPre 0))
diff --git a/src/FRP/Rhine/Type.hs b/src/FRP/Rhine/Type.hs
--- a/src/FRP/Rhine/Type.hs
+++ b/src/FRP/Rhine/Type.hs
@@ -8,7 +8,7 @@
 import FRP.Rhine.SN
 
 {- |
-A 'Rhine' consists of un 'SN' together with a clock of matching type 'cl'.
+A 'Rhine' consists of a 'SN' together with a clock of matching type 'cl'.
 It is a reactive program, possibly with open inputs and outputs.
 If the input and output types 'a' and 'b' are both '()',
 that is, the 'Rhine' is "closed",