diff --git a/src/Synthesizer/Dimensional/Amplitude/Control.hs b/src/Synthesizer/Dimensional/Amplitude/Control.hs
--- a/src/Synthesizer/Dimensional/Amplitude/Control.hs
+++ b/src/Synthesizer/Dimensional/Amplitude/Control.hs
@@ -68,7 +68,7 @@
 
 {-# INLINE piecewiseConstantGeneric #-}
 piecewiseConstantGeneric ::
-   (SigG.Write sig y) =>
+   (SigG.Produce sig y) =>
    SigA.T rate amp (PC.T y) ->
    SigA.T rate amp (sig y)
 piecewiseConstantGeneric =
diff --git a/src/Synthesizer/Dimensional/Amplitude/Cut.hs b/src/Synthesizer/Dimensional/Amplitude/Cut.hs
--- a/src/Synthesizer/Dimensional/Amplitude/Cut.hs
+++ b/src/Synthesizer/Dimensional/Amplitude/Cut.hs
@@ -301,7 +301,7 @@
 zip ::
    (Ord y, Field.C y, Dim.C u,
     Module.C y yv0, Module.C y yv1,
-    SigG.Read sig yv0, SigG.Transform sig yv1, SigG.Transform sig (yv0,yv1)) =>
+    SigG.Consume sig yv0, SigG.Transform sig yv1, SigG.Transform sig (yv0,yv1)) =>
    Signal s u y sig yv0 -> Signal s u y sig yv1 -> Signal s u y sig (yv0,yv1)
 zip =
    merge (SigG.zipWithState (,)) . SigA.restore
@@ -310,7 +310,7 @@
 zipVolume ::
    (Field.C y, Dim.C u,
     Module.C y yv0, Module.C y yv1,
-    SigG.Read sig yv0, SigG.Transform sig yv1, SigG.Transform sig (yv0,yv1)) =>
+    SigG.Consume sig yv0, SigG.Transform sig yv1, SigG.Transform sig (yv0,yv1)) =>
    DN.T u y ->
    Signal s u y sig yv0 -> Signal s u y sig yv1 -> Signal s u y sig (yv0,yv1)
 zipVolume vol =
@@ -350,7 +350,7 @@
 zip3 ::
    (Ord y, Field.C y, Dim.C u,
     Module.C y yv0, Module.C y yv1, Module.C y yv2,
-    SigG.Read sig yv0, SigG.Read sig yv1,
+    SigG.Consume sig yv0, SigG.Consume sig yv1,
     SigG.Transform sig yv2, SigG.Transform sig (yv0, yv1, yv2)) =>
    Signal s u y sig yv0 -> Signal s u y sig yv1 -> Signal s u y sig yv2 ->
    Signal s u y sig (yv0,yv1,yv2)
@@ -363,7 +363,7 @@
 zip3Volume ::
    (Field.C y, Dim.C u,
     Module.C y yv0, Module.C y yv1, Module.C y yv2,
-    SigG.Read sig yv0, SigG.Read sig yv1,
+    SigG.Consume sig yv0, SigG.Consume sig yv1,
     SigG.Transform sig yv2, SigG.Transform sig (yv0, yv1, yv2)) =>
    DN.T u y ->
    Signal s u y sig yv0 -> Signal s u y sig yv1 -> Signal s u y sig yv2 ->
@@ -382,7 +382,7 @@
 selectBool ::
    (Ord y, Field.C y, Dim.C u,
     Module.C y yv,
-    SigG.Read sig yv,
+    SigG.Consume sig yv,
     SigG.Transform sig Bool, SigG.Transform sig yv) =>
    Signal s u y sig yv {- ^ False -} ->
    Signal s u y sig yv {- ^ True -} ->
diff --git a/src/Synthesizer/Dimensional/Causal/Process.hs b/src/Synthesizer/Dimensional/Causal/Process.hs
--- a/src/Synthesizer/Dimensional/Causal/Process.hs
+++ b/src/Synthesizer/Dimensional/Causal/Process.hs
@@ -142,7 +142,7 @@
 
 {-# INLINE applyFst #-}
 applyFst ::
-   (SigG.Read sig yv) =>
+   (SigG.Consume sig yv) =>
    T s (Sample.T amp yv, restSampleIn) restSampleOut ->
    SigA.T (Rate.Phantom s) amp (sig yv) ->
    T s restSampleIn restSampleOut
@@ -150,7 +150,7 @@
 
 {-# INLINE applyFlatFst #-}
 applyFlatFst ::
-   (Flat.C yv amp, SigG.Read sig yv) =>
+   (Flat.C yv amp, SigG.Consume sig yv) =>
    T s (Sample.T (Amp.Flat yv) yv, restSampleIn) restSampleOut ->
    SigA.T (Rate.Phantom s) amp (sig yv) ->
    T s restSampleIn restSampleOut
@@ -160,7 +160,7 @@
 
 {-# INLINE feedFst #-}
 feedFst ::
-   (SigG.Read sig yv) =>
+   (SigG.Consume sig yv) =>
    SigA.T (Rate.Phantom s) amp (sig yv) ->
    T s restSample (Sample.T amp yv, restSample)
 feedFst x =
@@ -170,7 +170,7 @@
 
 {-# INLINE applySnd #-}
 applySnd ::
-   (SigG.Read sig yv) =>
+   (SigG.Consume sig yv) =>
    T s (restSampleIn, Sample.T amp yv) restSampleOut ->
    SigA.T (Rate.Phantom s) amp (sig yv) ->
    T s restSampleIn restSampleOut
@@ -178,7 +178,7 @@
 
 {-# INLINE feedSnd #-}
 feedSnd ::
-   (SigG.Read sig yv) =>
+   (SigG.Consume sig yv) =>
    SigA.T (Rate.Phantom s) amp (sig yv) ->
    T s restSample (restSample, Sample.T amp yv)
 feedSnd x =
diff --git a/src/Synthesizer/Dimensional/ChunkySize/Signal.hs b/src/Synthesizer/Dimensional/ChunkySize/Signal.hs
--- a/src/Synthesizer/Dimensional/ChunkySize/Signal.hs
+++ b/src/Synthesizer/Dimensional/ChunkySize/Signal.hs
@@ -32,7 +32,7 @@
 
 {-# INLINE store #-}
 store ::
-   (SigC.Write sig yv) =>
+   (SigC.Produce sig yv) =>
    Size s ->
    Signal s amp (Sig.T yv) ->
    Signal s amp (sig yv)
@@ -44,7 +44,7 @@
 Move to a new module Analysis in order to be consistent with other Analysis modules?
 -}
 {-# INLINE length #-}
-length :: (CutC.Read sig) =>
+length :: (CutC.Consume sig) =>
    Signal s amp sig ->
    Size s
 length =
diff --git a/src/Synthesizer/Dimensional/Cyclic/Analysis.hs b/src/Synthesizer/Dimensional/Cyclic/Analysis.hs
--- a/src/Synthesizer/Dimensional/Cyclic/Analysis.hs
+++ b/src/Synthesizer/Dimensional/Cyclic/Analysis.hs
@@ -39,7 +39,7 @@
 {- * Positions -}
 
 {-# INLINE period #-}
-period :: (Field.C t, Dim.C u, CutG.Read body) =>
+period :: (Field.C t, Dim.C u, CutG.Consume body) =>
    SigA.T (Rate.Dimensional u t) amp (SigC.T body) ->
    DN.T u t
 period = makePhysicalPeriod (fromIntegral . CutG.length)
diff --git a/src/Synthesizer/Dimensional/Cyclic/Signal.hs b/src/Synthesizer/Dimensional/Cyclic/Signal.hs
--- a/src/Synthesizer/Dimensional/Cyclic/Signal.hs
+++ b/src/Synthesizer/Dimensional/Cyclic/Signal.hs
@@ -77,10 +77,10 @@
 -}
 {-# INLINE fromSignal #-}
 fromSignal ::
-   (Additive.C yv, SigG.Write sig yv) =>
+   (Additive.C yv, SigG.Produce sig yv) =>
    Int -> sig yv -> T (sig yv)
 fromSignal n  =
-   fromPeriod . Cyclic.fromSignal SigG.defaultLazySize n
+   fromPeriod . Cyclic.fromSignal n
 
 {- |
 Convert a cyclic signal to a straight signal containing a loop.
diff --git a/src/Synthesizer/Dimensional/Duration.hs b/src/Synthesizer/Dimensional/Duration.hs
new file mode 100644
--- /dev/null
+++ b/src/Synthesizer/Dimensional/Duration.hs
@@ -0,0 +1,38 @@
+module Synthesizer.Dimensional.Duration where
+
+import qualified Synthesizer.Dimensional.Process as Proc
+
+import Control.Applicative ((<$>))
+
+import qualified Algebra.ToInteger     as ToInteger
+import qualified Algebra.Field         as Field
+import qualified Algebra.RealRing      as RealRing
+
+import qualified Number.DimensionTerm        as DN
+import qualified Algebra.DimensionTerm       as Dim
+import Number.DimensionTerm ((*&))
+
+import qualified NumericPrelude.Numeric as NP
+
+
+{- |
+This type is intended to hold a duration
+which is an integer with respect to the sampling rate.
+It allows to do exact duration computations, i.e. without rounding errors.
+The trade-off is that it is bound to a certain sampling rate
+and you must convert to different sampling rates explicitly.
+-}
+newtype T s i = Cons i
+
+fromTime ::
+   (Dim.C u, ToInteger.C i, RealRing.C t) =>
+   DN.T u t -> Proc.T s u t (T s i)
+fromTime t = Cons . RealRing.round <$> Proc.toTimeScalar t
+
+toTime ::
+   (Dim.C u, ToInteger.C i, Field.C t) =>
+   Proc.T s u t (T s i -> DN.T u t)
+toTime =
+   (\sampleRate (Cons dur) -> NP.fromIntegral dur *& DN.unrecip sampleRate)
+   <$>
+   Proc.getSampleRate
diff --git a/src/Synthesizer/Dimensional/Process.hs b/src/Synthesizer/Dimensional/Process.hs
--- a/src/Synthesizer/Dimensional/Process.hs
+++ b/src/Synthesizer/Dimensional/Process.hs
@@ -27,7 +27,6 @@
       run, {-share,-} withParam, getSampleRate,
       toTimeScalar,    toFrequencyScalar,
       toTimeDimension, toFrequencyDimension,
-      intFromTime, intFromTime98,
       DimensionGradient, toGradientScalar,
       loop, pure,
       ($:), ($::), ($^), ($#),
@@ -40,7 +39,6 @@
 
 import Number.DimensionTerm ((*&), (&/&), ) -- ((&*&), )
 
-import qualified Algebra.RealRing      as RealRing
 import qualified Algebra.Field          as Field
 import qualified Algebra.Ring           as Ring
 
@@ -50,7 +48,6 @@
 import qualified Control.Applicative as App
 import Control.Applicative (Applicative)
 
-import NumericPrelude.Numeric
 import NumericPrelude.Base
 
 import qualified Prelude as P
@@ -172,27 +169,3 @@
 (~*&) = toTimeScalar
 (~/&) = toFrequencyScalar
 -}
-
-
-checkedChunkSize ::
-   String -> Int -> Int
-checkedChunkSize funcName cs =
-   if cs>0
-     then cs
-     else error $ funcName ++ ": negative chunkSize"
-
-intFromTime ::
-   (RealRing.C t, Dim.C u) =>
-   String ->
-   DN.T u t ->
-   T s u t Int
-intFromTime funcName t =
-   fmap (checkedChunkSize funcName . RealRing.ceiling) $ toTimeScalar t
-
-intFromTime98 ::
-   (Ring.C t, RealFrac t, Dim.C u) =>
-   String ->
-   DN.T u t ->
-   T s u t Int
-intFromTime98 funcName t =
-   fmap (checkedChunkSize funcName . P.ceiling) $ toTimeScalar t
diff --git a/src/Synthesizer/Dimensional/Rate/Cut.hs b/src/Synthesizer/Dimensional/Rate/Cut.hs
--- a/src/Synthesizer/Dimensional/Rate/Cut.hs
+++ b/src/Synthesizer/Dimensional/Rate/Cut.hs
@@ -12,13 +12,13 @@
    concat, append, ) where
 
 import qualified Synthesizer.Dimensional.Process as Proc
+import qualified Synthesizer.Dimensional.Duration as Dur
 import qualified Synthesizer.Dimensional.Rate as Rate
 import qualified Synthesizer.Dimensional.Amplitude as Amp
 
 import qualified Synthesizer.Dimensional.Signal.Private as SigA
 import qualified Synthesizer.Generic.Cut as CutG
 
-import qualified Number.DimensionTerm        as DN
 import qualified Algebra.DimensionTerm       as Dim
 
 -- import qualified Number.NonNegative     as NonNeg
@@ -44,36 +44,31 @@
 -}
 {-# INLINE splitAt #-}
 splitAt :: (CutG.Transform sig, RealRing.C t, Dim.C u) =>
-   DN.T u t ->
    Proc.T s u t
-      (Signal s amp sig ->
+      (Dur.T s Int ->
+       Signal s amp sig ->
        (Signal s amp sig, Signal s amp sig))
-splitAt t' =
-   flip fmap (Proc.toTimeScalar t') $
-   \t x ->
-      let (y,z) = CutG.splitAt (RealRing.round t) $ SigA.body x
+splitAt =
+   Proc.pure $ \(Dur.Cons t) x ->
+      let (y,z) = CutG.splitAt t $ SigA.body x
       in  (SigA.replaceBody y x,
            SigA.replaceBody z x)
 
 {-# INLINE take #-}
 take :: (CutG.Transform sig, RealRing.C t, Dim.C u) =>
-   DN.T u t ->
    Proc.T s u t
-      (Signal s amp sig ->
+      (Dur.T s Int ->
+       Signal s amp sig ->
        Signal s amp sig)
-take t' =
-   flip fmap (Proc.toTimeScalar t') $
-   \t -> SigA.processBody (CutG.take (RealRing.round t))
+take = Proc.pure $ \(Dur.Cons t) -> SigA.processBody (CutG.take t)
 
 {-# INLINE drop #-}
 drop :: (CutG.Transform sig, RealRing.C t, Dim.C u) =>
-   DN.T u t ->
    Proc.T s u t
-      (Signal s amp sig ->
+      (Dur.T s Int ->
+       Signal s amp sig ->
        Signal s amp sig)
-drop t' =
-   flip fmap (Proc.toTimeScalar t') $
-   \t -> SigA.processBody (CutG.drop (RealRing.round t))
+drop = Proc.pure $ \(Dur.Cons t) -> SigA.processBody (CutG.drop t)
 
 
 {-# INLINE concat #-}
diff --git a/src/Synthesizer/Dimensional/Rate/Dirac.hs b/src/Synthesizer/Dimensional/Rate/Dirac.hs
--- a/src/Synthesizer/Dimensional/Rate/Dirac.hs
+++ b/src/Synthesizer/Dimensional/Rate/Dirac.hs
@@ -48,7 +48,7 @@
    mempty = Cons Mn.mempty
    mappend (Cons x) (Cons y) = Cons (Mn.mappend x y)
 
-instance Cut.Read (sig Bool) => Cut.Read (T s sig) where
+instance Cut.Consume (sig Bool) => Cut.Consume (T s sig) where
    {-# INLINE null #-}
    null = Cut.null . decons
    {-# INLINE length #-}
diff --git a/src/Synthesizer/Dimensional/Rate/Filter.hs b/src/Synthesizer/Dimensional/Rate/Filter.hs
--- a/src/Synthesizer/Dimensional/Rate/Filter.hs
+++ b/src/Synthesizer/Dimensional/Rate/Filter.hs
@@ -22,6 +22,7 @@
 
    {- ** Delay -}
    delay,
+   delayStorable,
    phaseModulation,
    phaser,
    phaserStereo,
@@ -64,6 +65,7 @@
 import qualified Synthesizer.Dimensional.Amplitude.Filter       as FiltV
 import qualified Synthesizer.Dimensional.Process as Proc
 import qualified Synthesizer.Dimensional.Amplitude as Amp
+import qualified Synthesizer.Dimensional.Duration as Dur
 import qualified Synthesizer.Dimensional.Rate as Rate
 
 import Synthesizer.Dimensional.Process
@@ -90,6 +92,7 @@
 import qualified Synthesizer.Plain.Filter.Recursive.Chebyshev   as Cheby
 import qualified Synthesizer.Plain.Filter.Recursive             as FiltRec
 
+import qualified Synthesizer.Storable.Filter.NonRecursive as FiltNRSt
 import qualified Synthesizer.Storable.Signal as SigSt
 import qualified Synthesizer.Generic.Filter.Recursive.Comb as Comb
 
@@ -115,6 +118,8 @@
 -- import qualified Algebra.VectorSpace    as VectorSpace
 import qualified Algebra.Module         as Module
 
+import qualified Data.StorableVector.Lazy.Typed as SVT
+
 import Foreign.Storable (Storable, )
 
 -- import qualified Data.List as List
@@ -210,23 +215,31 @@
                  toStorable)
 
 {-# INLINE delay #-}
-delay :: (Additive.C yv, RealRing.C t, Dim.C u, SigG.Write sig yv) =>
-      DN.T u t
-   -> Proc.T s u t (
-        SigA.T (Rate.Phantom s) amp (sig yv)
+delay :: (Additive.C yv, RealRing.C t, Dim.C u, SigG.Produce sig yv) =>
+   Proc.T s u t (
+        Dur.T s Int
+     -> SigA.T (Rate.Phantom s) amp (sig yv)
      -> SigA.T (Rate.Phantom s) amp (sig yv))
-delay time =
-   flip fmap (toTimeScalar time) $
-   \t -> SigA.processBody (DelayG.static (round t))
+delay =
+   Proc.pure $ \(Dur.Cons t) -> SigA.processBody (DelayG.static t)
 
+{-# INLINE delayStorable #-}
+delayStorable :: (Additive.C yv, RealRing.C t, Dim.C u, Storable yv) =>
+   Proc.T s u t (
+        Dur.T s Int
+     -> SigA.T (Rate.Phantom s) amp (SigSt.T yv)
+     -> SigA.T (Rate.Phantom s) amp (SigSt.T yv))
+delayStorable =
+   Proc.pure $ \(Dur.Cons t) -> SigA.processBody (FiltNRSt.delay t)
 
+
 {-# INLINE toStorable #-}
-toStorable :: (Storable a) => Sig.T a -> SigSt.T a
-toStorable = Sig.toStorableSignal SigSt.defaultChunkSize
+toStorable :: (Storable a) => Sig.T a -> SVT.DefaultVector a
+toStorable = SigG.fromState
 
 {-# INLINE fromStorable #-}
-fromStorable :: (Storable a) => SigSt.T a -> Sig.T a
-fromStorable = Sig.fromStorableSignal
+fromStorable :: (Storable a) => SVT.DefaultVector a -> Sig.T a
+fromStorable = SigG.toState
 
 {-# INLINE phaseModulation #-}
 phaseModulation ::
@@ -258,7 +271,7 @@
 {-# INLINE phaseModulationGeneric #-}
 phaseModulationGeneric ::
    (Additive.C yv, RealField.C q, Dim.C u,
-    SigG.Transform sig q, SigG.Transform sig yv, SigG.Write sig yv) =>
+    SigG.Transform sig q, SigG.Transform sig yv, SigG.Produce sig yv) =>
       Interpolation.T q yv
    -> DN.T u q
           {- ^ minimal deviation from current time, usually negative -}
@@ -590,11 +603,10 @@
 {- | Infinitely many equi-delayed exponentially decaying echos. -}
 {-# INLINE comb #-}
 comb :: (RealRing.C t, Module.C y yv, Dim.C u, Storable yv) =>
-   DN.T u t -> y -> Proc.T s u t (Signal s amp yv -> Signal s amp yv)
-comb time gain =
-   do t <- toTimeScalar time
-      return $ SigA.processBody
-         (fromStorable . Comb.run (round t) gain . toStorable)
+   y -> Proc.T s u t (Dur.T s Int -> Signal s amp yv -> Signal s amp yv)
+comb gain =
+   return $ \(Dur.Cons t) ->
+      SigA.processBody (fromStorable . Comb.run t gain . toStorable)
 
 
 -- * auxiliary functions
diff --git a/src/Synthesizer/Dimensional/RateAmplitude/Cut.hs b/src/Synthesizer/Dimensional/RateAmplitude/Cut.hs
--- a/src/Synthesizer/Dimensional/RateAmplitude/Cut.hs
+++ b/src/Synthesizer/Dimensional/RateAmplitude/Cut.hs
@@ -23,7 +23,7 @@
    zip3,        zip3Volume,
    mergeStereo, mergeStereoVolume,
    arrange,     arrangeVolume,
-   arrangeStorableVolume,
+   arrangeStorableVolume, arrangeStorableTypedVolume,
   ) where
 
 import qualified Synthesizer.Dimensional.Amplitude.Cut as CutV
@@ -31,18 +31,19 @@
 import qualified Synthesizer.Storable.Cut as CutSt
 import qualified Synthesizer.Storable.Signal as SigSt
 import qualified Synthesizer.State.Cut as CutS
-import qualified Synthesizer.State.Signal as Sig
+import qualified Synthesizer.State.Signal as SigS
 import qualified Synthesizer.Generic.Signal as SigG
 
 import qualified Synthesizer.Frame.Stereo as Stereo
 import Foreign.Storable (Storable, )
 
 import qualified Synthesizer.Dimensional.Amplitude as Amp
+import qualified Synthesizer.Dimensional.Duration as Dur
 import qualified Synthesizer.Dimensional.Rate as Rate
 
 import qualified Synthesizer.Dimensional.Signal.Private as SigA
 import qualified Synthesizer.Dimensional.Process as Proc
-import Synthesizer.Dimensional.Process (($#), toTimeScalar, intFromTime98, )
+import Synthesizer.Dimensional.Process (($#), toTimeScalar, )
 import Synthesizer.Dimensional.Signal.Private (toAmplitudeScalar, )
 
 import qualified Number.DimensionTerm        as DN
@@ -58,39 +59,37 @@
 import qualified Algebra.RealRing           as RealRing
 import qualified Algebra.Field               as Field
 import qualified Algebra.Ring                as Ring
+import qualified Algebra.Additive            as Additive
 
+import qualified Data.StorableVector.Lazy.Typed as SVT
 import qualified Data.List as List
 
-import NumericPrelude.Base ((.), ($), Ord, (<=), map, return, )
+import NumericPrelude.Base ((.), ($), Ord, (<=), map, fmap, return, )
 -- import NumericPrelude.Numeric
-import Prelude (RealFrac, )
+import Prelude (Int, RealFrac, )
 
 
 {- * dissection -}
 
 {-# INLINE splitAt #-}
 splitAt :: (RealRing.C t, Dim.C u, Dim.C v, Storable yv) =>
-   DN.T u t -> Proc.T s u t (SigA.R s v y yv -> (SigA.R s v y yv, SigA.R s v y yv))
-splitAt t' =
-   do t <- toTimeScalar t'
-      return $ \x ->
-         let (ss0,ss1) = Sig.splitAt (RealRing.round t) (SigA.body x)
-         in  (SigA.replaceBody ss0 x,
-              SigA.replaceBody ss1 x)
+   Proc.T s u t (Dur.T s Int -> SigA.R s v y yv -> (SigA.R s v y yv, SigA.R s v y yv))
+splitAt =
+   CutR.splitAt
 
 {-# INLINE take #-}
 take :: (RealRing.C t, Dim.C u, Dim.C v) =>
-   DN.T u t -> Proc.T s u t (SigA.R s v y yv -> SigA.R s v y yv)
-take t' =
-   CutR.take t'
-   -- fmap (fst.) $ splitAt t
+   Proc.T s u t (Dur.T s Int -> SigA.R s v y yv -> SigA.R s v y yv)
+take =
+   CutR.take
+   -- fmap (fst.) $ splitAt
 
 {-# INLINE drop #-}
 drop :: (RealRing.C t, Dim.C u, Dim.C v) =>
-   DN.T u t -> Proc.T s u t (SigA.R s v y yv -> SigA.R s v y yv)
-drop t' =
-   CutR.drop t'
-   -- fmap (snd.) $ splitAt t
+   Proc.T s u t (Dur.T s Int -> SigA.R s v y yv -> SigA.R s v y yv)
+drop =
+   CutR.drop
+   -- fmap (snd.) $ splitAt
 
 {-# INLINE takeUntilPause #-}
 takeUntilPause ::
@@ -242,19 +241,21 @@
     RealFrac t,
     Ord y, Field.C y, Dim.C v,
     Module.C y yv, Storable yv) =>
-      DN.T u t  {- ^ Maximum chunk size -}
-   -> DN.T u t  {- ^ Unit of the time values in the time ordered list. -}
+      DN.T u t  {- ^ Unit of the time values in the time ordered list. -}
    -> Proc.T s u t (
-         EventList.T (NonNeg.T t) (SigA.R s v y yv)
+         Dur.T s Int
+               {- v Maximum chunk size -}
+      -> EventList.T (NonNeg.T t) (SigA.R s v y yv)
                {- v A list of pairs: (relative start time, signal part),
                     The start time is relative
                     to the start time of the previous event. -}
       -> SigA.R s v y yv)
                {- ^ The mixed signal. -}
-arrange chunkSize unit' =
+arrange unit' =
+   Proc.withParam $ \chunkSize ->
    Proc.withParam $ \sched ->
       let amp = List.maximum (map SigA.actualAmplitude (EventList.getBodies sched))
-      in  arrangeVolume chunkSize amp unit' $# sched
+      in  (arrangeVolume amp unit' $# chunkSize) $# sched
 
 
 {- |
@@ -268,30 +269,31 @@
     RealFrac t,
     Field.C y, Dim.C v,
     Module.C y yv, Storable yv) =>
-      DN.T u t  {- ^ Maximum chunk size -}
-   -> DN.T v y  {- ^ Output volume -}
+      DN.T v y  {- ^ Output volume -}
    -> DN.T u t  {- ^ Unit of the time values in the time ordered list. -}
    -> Proc.T s u t (
-         EventList.T (NonNeg.T t) (SigA.R s v y yv)
+         Dur.T s Int
+            {- v Maximum chunk size -}
+      -> EventList.T (NonNeg.T t) (SigA.R s v y yv)
             {- v A list of pairs: (relative start time, signal part),
                  The start time is relative
                  to the start time of the previous event. -}
       -> SigA.R s v y yv)
             {- ^ The mixed signal. -}
-arrangeVolume chunkSize' amp unit' =
+arrangeVolume amp unit' =
    do unit <- toTimeScalar unit'
-      chunkSize <-
-         intFromTime98 "Dimensional.Cut.arrangeStorableVolume" chunkSize'
-      return $ \sched ->
-         let z =
+      return $ \(Dur.Cons chunkSize) sched' ->
+         let sched =
+                EventList.mapBody
+                   (SigS.toStorableSignal (SigSt.chunkSize chunkSize) .
+                    SigA.vectorSamples (toAmplitudeScalar z))
+                sched'
+             z =
                 SigA.fromBody amp $
                 SigG.toState $
                 CutSt.arrange (SigSt.chunkSize chunkSize) $ 
                 EventList.resample
-                   (NonNeg.fromNumberMsg "Dimensional.Cut.arrangeVolume" unit) $
-                EventList.mapBody
-                   (SigG.fromState (SigG.LazySize chunkSize) .
-                    SigA.vectorSamples (toAmplitudeScalar z))
+                   (NonNeg.fromNumberMsg "Dimensional.Cut.arrangeVolume" unit)
                 sched
          in  z
 
@@ -301,22 +303,21 @@
     RealFrac t,
     Field.C y, Dim.C v,
     Module.C y yv, Storable yv) =>
-      DN.T u t  {- ^ Maximum chunk size -}
-   -> DN.T v y  {- ^ Output volume -}
+      DN.T v y  {- ^ Output volume -}
    -> DN.T u t  {- ^ Unit of the time values in the time ordered list. -}
    -> Proc.T s u t (
-         EventList.T (NonNeg.T t)
+         Dur.T s Int
+            {- v Maximum chunk size -}
+      -> EventList.T (NonNeg.T t)
             (SigA.T (Rate.Phantom s) (Amp.Dimensional v y) (SigSt.T yv))
             {- v A list of pairs: (relative start time, signal part),
                  The start time is relative
                  to the start time of the previous event. -}
       -> (SigA.T (Rate.Phantom s) (Amp.Dimensional v y) (SigSt.T yv)))
             {- ^ The mixed signal. -}
-arrangeStorableVolume chunkSize' amp unit' =
+arrangeStorableVolume amp unit' =
    do unit <- toTimeScalar unit'
-      chunkSize <-
-         intFromTime98 "Dimensional.Cut.arrangeStorableVolume" chunkSize'
-      return $ \sched ->
+      return $ \(Dur.Cons chunkSize) sched ->
          let z =
                 SigA.fromBody amp $
                 CutSt.arrange (SigSt.chunkSize chunkSize) $
@@ -324,5 +325,46 @@
                    (NonNeg.fromNumberMsg "Dimensional.Cut.arrangeStorableVolume" unit) $
                 EventList.mapBody
                    (SigA.vectorSamples (toAmplitudeScalar z))
+                sched
+         in  z
+
+
+
+-- ToDo: move to synthesizer-core?
+arrangeTyped ::
+   (SVT.Size size, Additive.C a, Storable a) =>
+   SVT.ChunkSize size ->
+   EventList.T NonNeg.Int (SVT.Vector size a) -> SVT.Vector size a
+arrangeTyped chunkSize =
+   SVT.fromVectorLazy .
+   CutSt.arrange (SVT.lazyChunkSize chunkSize) .
+   fmap SVT.toVectorLazy
+
+{-# INLINE arrangeStorableTypedVolume #-}
+arrangeStorableTypedVolume ::
+   (Ring.C t, Dim.C u,
+    RealFrac t,
+    Field.C y, Dim.C v,
+    Module.C y yv, Storable yv,
+    SVT.Size size) =>
+      DN.T v y  {- ^ Output volume -}
+   -> DN.T u t  {- ^ Unit of the time values in the time ordered list. -}
+   -> Proc.T s u t (
+         EventList.T (NonNeg.T t)
+            (SigA.T (Rate.Phantom s) (Amp.Dimensional v y) (SVT.Vector size yv))
+            {- v A list of pairs: (relative start time, signal part),
+                 The start time is relative
+                 to the start time of the previous event. -}
+      -> (SigA.T (Rate.Phantom s) (Amp.Dimensional v y) (SVT.Vector size yv)))
+            {- ^ The mixed signal. -}
+arrangeStorableTypedVolume amp unit' =
+   do unit <- toTimeScalar unit'
+      return $ \sched ->
+         let z =
+                SigA.fromBody amp $
+                arrangeTyped SVT.chunkSize $
+                EventList.resample
+                   (NonNeg.fromNumberMsg "Dimensional.Cut.arrangeStorableTypedVolume" unit) $
+                EventList.mapBody (SigA.vectorSamples (toAmplitudeScalar z))
                 sched
          in  z
diff --git a/src/Synthesizer/Dimensional/RateAmplitude/Demonstration.hs b/src/Synthesizer/Dimensional/RateAmplitude/Demonstration.hs
--- a/src/Synthesizer/Dimensional/RateAmplitude/Demonstration.hs
+++ b/src/Synthesizer/Dimensional/RateAmplitude/Demonstration.hs
@@ -37,6 +37,7 @@
 
 import qualified Synthesizer.Dimensional.Wave as WaveD
 import qualified Synthesizer.Dimensional.Amplitude as Amp
+import qualified Synthesizer.Dimensional.Duration as Dur
 import qualified Synthesizer.Dimensional.Rate as Rate
 import Synthesizer.Dimensional.Wave ((&*~), )
 
@@ -180,6 +181,9 @@
                    (DN.frequency 1, DN.frequency 1000)))
 
 
+second :: (RealField.C q) => q -> Proc.T s Dim.Time q (Dur.T s Int)
+second t = Dur.fromTime $ DN.time t
+
 {-# INLINE airplane #-}
 airplane ::
    (RealField.C q, Trans.C q, Module.C q q, Random q, Storable q) =>
@@ -188,7 +192,7 @@
    SigA.share
       (Noise.white (DN.frequency 20000) (DN.voltage 0.2))
       (\noise ->
-          Cut.take (DN.time 5) $: (Disp.mix
+          Cut.take $: second 5 $: (Disp.mix
              $: noise
              $: (Filt.frequencyModulation IpMod.linear
                     $- DN.scalar 1.001
@@ -229,7 +233,7 @@
 windStereo =
    SigA.share
       wind
-      (\w -> Cut.mergeStereo $: w $: (Cut.drop (DN.time 0.2) $: w))
+      (\w -> Cut.mergeStereo $: w $: (Cut.drop $: second 0.2 $: w))
 
 
 
@@ -370,7 +374,7 @@
       $- DN.frequency 4
       $: (Cut.concatVolume (DN.scalar 1) $:
           mapM (\p ->
-             Cut.take (DN.time (1/6))
+             Cut.take $: second (1/6)
               $: Ctrl.constant (DN.scalar (fromInteger p / 12)))
               (randomRs (0,24) (mkStdGen 3141)))
 
@@ -434,7 +438,9 @@
    Proc.T s Dim.Time q (SigA.R s Dim.Voltage q q)
 bubbles =
    let delay = 0.24
-   in  Filt.comb (DN.time delay) (0.5 `asTypeOf` delay) $:
+   in  Filt.comb (0.5 `asTypeOf` delay)
+       $: Dur.fromTime (DN.time delay)
+       $:
        (Osci.freqMod (DN.voltage 0.5 &*~ Wave.sine) zero $:
          (DispA.mapExponential 0.5 (DN.frequency 440) $^
             (Disp.mix
@@ -455,8 +461,9 @@
                (Disp.mix
                   $: Osci.static (DN.scalar 1.5 &*~ Wave.saw) zero (DN.frequency 0.5)
                   $: Osci.static (DN.scalar 0.5 &*~ Wave.saw) zero f))
-   in  Filt.comb (DN.time delay) (0.5 `asTypeOf` delay) $:
-          (Cut.mergeStereo
+   in  Filt.comb (0.5 `asTypeOf` delay)
+       $: Dur.fromTime (DN.time delay)
+       $: (Cut.mergeStereo
               $: channel (DN.frequency 10)
               $: channel (DN.frequency 9.23))
 
@@ -466,8 +473,8 @@
    (RealField.C q, Trans.C q, Module.C q q, Random q, Storable q) =>
    Proc.T s Dim.Time q (SigA.R s Dim.Voltage q q)
 dampedEcho =
-   FiltA.combProc (DN.time 0.2)
-            (Filt.firstOrderLowpass $- DN.frequency 1000)
+   FiltA.combProc (Filt.firstOrderLowpass $- DN.frequency 1000)
+      $: Dur.fromTime (DN.time 0.2)
       $: (Filt.envelope
             $: CtrlR.exponential2 (DN.time 0.1)
             $: Osci.static (DN.voltage 1 &*~ Wave.saw) zero (DN.frequency 440))
@@ -495,7 +502,7 @@
    (RealField.C q, Trans.C q) =>
    Proc.T s Dim.Time q (SigA.T (Rate.Phantom s) (Amp.Flat q) (Sig.T q))
 staticSine =
-   CutR.take (DN.time 10)
+   CutR.take $: second 10
       $: (Osci.static (WaveD.flat Wave.sine) zero (DN.frequency 440))
 
 
@@ -637,7 +644,7 @@
    in  renderToAIFF
        File.renderTimeVoltageMonoDoubleToInt16
        subName
-       (Cut.take (DN.time 10) $: fmap filterSelect sound)
+       (Cut.take $: second 10 $: fmap filterSelect sound)
 
 renderFilter ::
    (Interpol.C Double param,
@@ -708,9 +715,9 @@
              File.renderTimeVoltageStereoDoubleToInt16
              name (fromSound sound)) $
 
-         ("bass-filter", Sound (Cut.take (DN.time 15) $: bassFilter)) :
-         ("wind",        Sound (Cut.take (DN.time 10) $: windStereo)) :
-         ("bubbles",     Sound (Cut.take (DN.time 10) $: bubblesStereo)) :
+         ("bass-filter", Sound (Cut.take $: second 15 $: bassFilter)) :
+         ("wind",        Sound (Cut.take $: second 10 $: windStereo)) :
+         ("bubbles",     Sound (Cut.take $: second 10 $: bubblesStereo)) :
          []
 
       mapM_
@@ -775,38 +782,38 @@
          but we leave them for demonstration purposes.
          -}
          ("moog-saw-direct",
-                         Sound (Cut.take (DN.time 10) $: moogSawDirect)) :
+                         Sound (Cut.take $: second 10 $: moogSawDirect)) :
          ("moog-saw-causal",
-                         Sound (Cut.take (DN.time 10) $: moogSawCausal)) :
+                         Sound (Cut.take $: second 10 $: moogSawCausal)) :
 
          ("allpass-phaser-direct",
-                         Sound (Cut.take (DN.time 10) $: allpassPhaserDirect)) :
+                         Sound (Cut.take $: second 10 $: allpassPhaserDirect)) :
          ("allpass-phaser-causal",
-                         Sound (Cut.take (DN.time 10) $: allpassPhaserCausal)) :
+                         Sound (Cut.take $: second 10 $: allpassPhaserCausal)) :
 
          ("universal-lowpass",
-                         Sound (Cut.take (DN.time 10) $: universalLowpassDirect)) :
+                         Sound (Cut.take $: second 10 $: universalLowpassDirect)) :
          ("universal-lowpass-sync",
-                         Sound (Cut.take (DN.time 10) $: universalLowpassSync)) :
+                         Sound (Cut.take $: second 10 $: universalLowpassSync)) :
          ("universal-lowpass-async-linear",
-                         Sound (Cut.take (DN.time 10) $: universalLowpassAsyncLinear)) :
+                         Sound (Cut.take $: second 10 $: universalLowpassAsyncLinear)) :
          ("universal-lowpass-async-constant",
-                         Sound (Cut.take (DN.time 10) $: universalLowpassAsyncConstant)) :
+                         Sound (Cut.take $: second 10 $: universalLowpassAsyncConstant)) :
 
-         ("sine-low",    Sound (Cut.take (DN.time 1) $: sineLow)) :
-         ("sine-high",   Sound (Cut.take (DN.time 1) $: sineHigh)) :
-         ("sine-mix",    Sound (Cut.take (DN.time 1) $: sineMix)) :
-         ("exponential", Sound (Cut.take (DN.time 1) $: DN.voltage 1 &*^ exponential)) :
-         ("ping",        Sound (Cut.take (DN.time 1) $: ping)) :
-         ("ping-saw",    Sound (Cut.take (DN.time 1) $: pingSaw)) :
+         ("sine-low",    Sound (Cut.take $: second 1 $: sineLow)) :
+         ("sine-high",   Sound (Cut.take $: second 1 $: sineHigh)) :
+         ("sine-mix",    Sound (Cut.take $: second 1 $: sineMix)) :
+         ("exponential", Sound (Cut.take $: second 1 $: DN.voltage 1 &*^ exponential)) :
+         ("ping",        Sound (Cut.take $: second 1 $: ping)) :
+         ("ping-saw",    Sound (Cut.take $: second 1 $: pingSaw)) :
 
---         ("saw",         Sound (Cut.take (DN.time 2) $: saw)) :
-         ("saw-vibrato", Sound (Cut.take (DN.time 2) $: sawVibrato)) :
-         ("saw-chorus",  Sound (Cut.take (DN.time 2) $: sawChorus)) :
+--         ("saw",         Sound (Cut.take $: second 2 $: saw)) :
+         ("saw-vibrato", Sound (Cut.take $: second 2 $: sawVibrato)) :
+         ("saw-chorus",  Sound (Cut.take $: second 2 $: sawChorus)) :
 
-         ("wasp",        Sound (Cut.take (DN.time  5) $: wasp (DN.frequency 110))) :
-         ("trapezoid",   Sound (Cut.take (DN.time  5) $: trapezoid)) :
-         ("damped-echo", Sound (Cut.take (DN.time  4) $: dampedEcho)) :
+         ("wasp",        Sound (Cut.take $: second 5 $: wasp (DN.frequency 110))) :
+         ("trapezoid",   Sound (Cut.take $: second 5 $: trapezoid)) :
+         ("damped-echo", Sound (Cut.take $: second 4 $: dampedEcho)) :
          ("chirp",       Sound (amplitudeModulationChirp)) :
          ("airplane",        Sound airplane) :
          {- This becomes considerably faster, if other effects are not rendered.
@@ -829,7 +836,7 @@
             renderToAIFF
             File.renderTimeVoltageMonoDoubleToInt16
             fileName
-            (Cut.take (DN.time 1) $: fromSound tone)
+            (Cut.take $: second 1 $: fromSound tone)
 
 
 {-
diff --git a/src/Synthesizer/Dimensional/RateAmplitude/Filter.hs b/src/Synthesizer/Dimensional/RateAmplitude/Filter.hs
--- a/src/Synthesizer/Dimensional/RateAmplitude/Filter.hs
+++ b/src/Synthesizer/Dimensional/RateAmplitude/Filter.hs
@@ -70,6 +70,7 @@
 import qualified Synthesizer.Dimensional.Amplitude.Filter as FiltV
 -- import qualified Synthesizer.Dimensional.ControlledProcess as CProc
 import qualified Synthesizer.Dimensional.Process as Proc
+import qualified Synthesizer.Dimensional.Duration as Dur
 import qualified Synthesizer.Dimensional.Rate as Rate
 
 -- import Synthesizer.Dimensional.Process ((.:), (.^), )
@@ -81,12 +82,12 @@
 import qualified Synthesizer.State.Signal as Sig
 -- import Synthesizer.Plain.Signal (Modifier)
 
-import Synthesizer.Dimensional.Process
-   (DimensionGradient, toTimeScalar, {- toFrequencyScalar, -} )
+import Synthesizer.Dimensional.Process (DimensionGradient, )
 
 {-
 import qualified Synthesizer.Frame.Stereo as Stereo
 -}
+import qualified Data.StorableVector.Lazy.Typed as SVT
 import Foreign.Storable (Storable, )
 
 {-
@@ -105,8 +106,8 @@
 -}
 import qualified Synthesizer.State.Filter.NonRecursive as FiltNR
 
-import qualified Synthesizer.Storable.Signal as SigSt
 import qualified Synthesizer.Generic.Filter.Recursive.Comb as Comb
+import qualified Synthesizer.Generic.Signal as SigG
 
 import qualified Number.DimensionTerm        as DN
 import qualified Algebra.DimensionTerm       as Dim
@@ -126,6 +127,8 @@
 
 -- import Control.Monad(liftM2)
 
+import Data.Function.HT (Id)
+
 import NumericPrelude.Numeric hiding (negate)
 import NumericPrelude.Base as P
 import Prelude ()
@@ -543,7 +546,7 @@
 {- | Infinitely many equi-delayed exponentially decaying echos. -}
 {-# INLINE comb #-}
 comb :: (RealRing.C t, Module.C y yv, Dim.C u, Dim.C v, Storable yv) =>
-   DN.T u t -> y -> Proc.T s u t (SigA.R s v y yv -> SigA.R s v y yv)
+   y -> Proc.T s u t (Dur.T s Int -> SigA.R s v y yv -> SigA.R s v y yv)
 comb = FiltR.comb
 
 
@@ -552,23 +555,21 @@
 combProc ::
    (RealRing.C t, Absolute.C y, Field.C y, Module.C y yv,
     Dim.C u, Dim.C v, Storable yv) =>
-   DN.T u t ->
    Proc.T s u t (SigA.R s v y yv -> SigA.R s v y yv) ->
-   Proc.T s u t (SigA.R s v y yv -> SigA.R s v y yv)
-combProc time proc =
+   Proc.T s u t (Dur.T s Int -> SigA.R s v y yv -> SigA.R s v y yv)
+combProc proc =
    do f <- proc
-      t <- fmap round $ toTimeScalar time
-      let chunkSize = SigSt.chunkSize t
-      return $ \x ->
+      return $ \(Dur.Cons t) x ->
          SigA.processBody
-            (Sig.fromStorableSignal .
+            (SigG.toState .
              Comb.runProc t
-                (Sig.toStorableSignal chunkSize .
+                (SigG.fromState .
                  SigA.vectorSamples (SigA.toAmplitudeScalar x) .
                  f .
                  SigA.fromBody (SigA.actualAmplitude x) .
-                 Sig.fromStorableSignal) .
-             Sig.toStorableSignal chunkSize) x
+                 SigG.toState) .
+             (id :: Id (SVT.DefaultVector a)) .
+             SigG.fromState) x
 
 {-
 combProc time proc sr x =
diff --git a/src/Synthesizer/Dimensional/RateAmplitude/Instrument.hs b/src/Synthesizer/Dimensional/RateAmplitude/Instrument.hs
--- a/src/Synthesizer/Dimensional/RateAmplitude/Instrument.hs
+++ b/src/Synthesizer/Dimensional/RateAmplitude/Instrument.hs
@@ -31,7 +31,7 @@
 
 import qualified Synthesizer.Dimensional.Amplitude.Flat as Flat
 import qualified Synthesizer.Dimensional.Sample as Sample
--- import qualified Synthesizer.Dimensional.Rate as Rate
+import qualified Synthesizer.Dimensional.Duration as Dur
 
 -- import qualified Synthesizer.Storable.Signal as SigSt
 import Foreign.Storable (Storable, )
@@ -244,7 +244,9 @@
 fatPad freq =
    let env =
           Cut.append
-             $: (Cut.take (DN.time 0.7) $:
+             $: (Cut.take
+                  $: (Dur.fromTime $ DN.time 0.7)
+                  $:
                   Ctrl.cubicHermite
                    (DN.time 0,   (DN.fromNumber 0,   DN.frequency 1 &*& DN.fromNumber 5))
                    (DN.time 0.7, (DN.fromNumber 0.5, DN.frequency 1 &*& DN.fromNumber 0)))
@@ -265,11 +267,11 @@
    (RealField.C a, Trans.C a, Module.C a a, Random a) =>
    DN.T Dim.Frequency a -> Proc.T s Dim.Time a (SigA.R s Dim.Voltage a a)
 brass freq =
-   let blobEnv = Piece.runState
+   let blobEnv = Piece.run
           (DN.fromNumber 0  |# (DN.time 0.05, Piece.cosine) #|-
            DN.fromNumber 1 -|# (DN.time 0.05, Piece.cosine) #|
            DN.fromNumber 0)
-       adsr = Piece.runState
+       adsr = Piece.run
           (DN.fromNumber 0 |# (DN.time 0.1, Piece.cubic (DN.frequency 1 &*& DN.fromNumber 10) (DN.frequency 1 &*& DN.fromNumber 0)) #|-
            DN.fromNumber 0.5 -|# (DN.time 1, Piece.step) #|-
            DN.fromNumber 0.5 -|# (DN.time 0.3, Piece.exponential (DN.fromNumber 0)) #|
@@ -506,8 +508,8 @@
    DN.T Dim.Frequency a ->
    Proc.T s Dim.Time a (SigA.R s Dim.Voltage a a)
 noiseBass freq =
-   FiltA.combProc (DN.unrecip freq)
-      (Filt.firstOrderLowpass $- DN.frequency 2000)
+   FiltA.combProc (Filt.firstOrderLowpass $- DN.frequency 2000)
+      $: Dur.fromTime (DN.unrecip freq)
       $: noisePerc
 
 {-|
@@ -524,8 +526,8 @@
    Proc.T s Dim.Time a (SigA.R s Dim.Voltage a a)
 electroTom =
    let ks =
-         FiltA.combProc (DN.time (1/30))
-            (Filt.firstOrderLowpass $- (DN.frequency 1000))
+         FiltA.combProc (Filt.firstOrderLowpass $- (DN.frequency 1000))
+            $: Dur.fromTime (DN.time (1/30))
             $: noisePerc
    in  Filt.frequencyModulation Interpolation.linear
           $: CtrlR.exponential2 (DN.time 0.3)
@@ -536,7 +538,9 @@
    (RealField.C q, Trans.C q, Module.C q q, Random q) =>
    Proc.T s Dim.Time q (SigA.R s Dim.Voltage q q)
 bassDrum =
-   Cut.take (DN.time 0.15) $:
+   Cut.take
+   $: (Dur.fromTime $ DN.time 0.15)
+   $:
    (Disp.mix
     $: (Filt.firstOrderLowpass
           $- (DN.frequency 5000)
diff --git a/src/Synthesizer/Dimensional/RateAmplitude/Piece.hs b/src/Synthesizer/Dimensional/RateAmplitude/Piece.hs
--- a/src/Synthesizer/Dimensional/RateAmplitude/Piece.hs
+++ b/src/Synthesizer/Dimensional/RateAmplitude/Piece.hs
@@ -16,7 +16,6 @@
 import qualified Synthesizer.Dimensional.Process as Proc
 import Synthesizer.Dimensional.Process
           (toTimeScalar, toGradientScalar, DimensionGradient, )
--- import Synthesizer.Dimensional.Process (($:), ($#), )
 
 import qualified Synthesizer.Dimensional.Amplitude as Amp
 import qualified Synthesizer.Dimensional.Rate as Rate
@@ -39,7 +38,6 @@
 -- import Control.Monad.Fix (mfix, )
 import Control.Monad (liftM3, )
 
-import NumericPrelude.Numeric (zero, )
 import NumericPrelude.Base
 import Prelude ()
 
@@ -48,13 +46,13 @@
 type T s u v sig q =
    Piecewise.Piece
       (DN.T u q) (DN.T v q)
-      (DN.T v q -> SigG.LazySize -> q ->
+      (DN.T v q -> q ->
        Proc.T s u q (SigA.T (Rate.Phantom s) (Amp.Flat q) (sig q)))
 
 type Sequence s u v sig q =
    Piecewise.T
       (DN.T u q) (DN.T v q)
-      (DN.T v q -> SigG.LazySize -> q ->
+      (DN.T v q -> q ->
        Proc.T s u q (SigA.T (Rate.Phantom s) (Amp.Flat q) (sig q)))
 
 
@@ -64,12 +62,11 @@
 infinite descriptions cannot be used here.
 -}
 {-# INLINE run #-}
-run :: (Trans.C q, RealRing.C q, Dim.C u, Dim.C v, SigG.Write sig q) =>
-   DN.T u q ->
+run :: (Trans.C q, RealRing.C q, Dim.C u, Dim.C v, SigG.Produce sig q) =>
    Sequence s u v sig q ->
    Proc.T s u q (SigA.T (Rate.Phantom s) (Amp.Dimensional v q) (sig q))
-run lazySize cs =
-   runVolume lazySize cs $
+run cs =
+   runVolume cs $
    maximum $
    map (\c -> max (DN.abs (Piecewise.pieceY0 c))
                   (DN.abs (Piecewise.pieceY1 c))) cs
@@ -77,39 +74,38 @@
 
 {-# INLINE runVolume #-}
 runVolume ::
-   (Trans.C q, RealRing.C q, Dim.C u, Dim.C v, SigG.Write sig q) =>
-   DN.T u q ->
+   (Trans.C q, RealRing.C q, Dim.C u, Dim.C v, SigG.Produce sig q) =>
    Sequence s u v sig q ->
    DN.T v q ->
    Proc.T s u q (SigA.T (Rate.Phantom s) (Amp.Dimensional v q) (sig q))
-runVolume lazySize' cs amplitude =
+runVolume cs amplitude =
    -- it would be nice if we could re-use Piece.run
    do ts0 <- mapM (toTimeScalar . Piecewise.pieceDur) cs
-      lazySize <-
-         Proc.intFromTime "Dimensional.Piece.runVolume" lazySize'
       fmap (SigA.fromBody amplitude . SigG.concat) $
          sequence $ zipWith
             (\(n,t) (Piecewise.PieceData c yi0 yi1 d) ->
                  fmap (SigG.take n . SigA.body) $
-                 Piecewise.computePiece c yi0 yi1 d amplitude (SigG.LazySize lazySize) t)
+                 Piecewise.computePiece c yi0 yi1 d amplitude t)
             (Piecewise.splitDurations ts0)
             cs
 
 
+{-# DEPRECATED runState "Use 'run' instead." #-}
 {-# INLINE runState #-}
 runState :: (Trans.C q, RealRing.C q, Dim.C u, Dim.C v) =>
    Sequence s u v Sig.T q ->
    Proc.T s u q (SigA.R s v q q)
-runState = run zero
+runState = run
 
 
+{-# DEPRECATED runStateVolume "Use 'runVolume' instead." #-}
 {-# INLINE runStateVolume #-}
 runStateVolume ::
    (Trans.C q, RealRing.C q, Dim.C u, Dim.C v) =>
    Sequence s u v Sig.T q ->
    DN.T v q ->
    Proc.T s u q (SigA.R s v q q)
-runStateVolume = runVolume zero
+runStateVolume = runVolume
 
 
 {-# INLINE toAmpScalar #-}
@@ -120,65 +116,65 @@
    DN.divToScalar y amp
 
 {-# INLINE make #-}
-make :: (Field.C q, Dim.C u, Dim.C v, SigG.Write sig q) =>
+make :: (Field.C q, Dim.C u, Dim.C v, SigG.Produce sig q) =>
    Piece.T sig q -> T s u v sig q
 make piece =
-   Piecewise.pieceFromFunction $ \ y0 y1 d amplitude lazySize t0 ->
+   Piecewise.pieceFromFunction $ \ y0 y1 d amplitude t0 ->
       flip fmap (toTimeScalar d) (\d' ->
          SigA.flatFromBody $
          Piecewise.computePiece piece
             (toAmpScalar amplitude y0)
             (toAmpScalar amplitude y1)
-            d' lazySize t0)
+            d' t0)
 
 {-# INLINE step #-}
-step :: (Field.C q, Dim.C u, Dim.C v, SigG.Write sig q) => T s u v sig q
+step :: (Field.C q, Dim.C u, Dim.C v, SigG.Produce sig q) => T s u v sig q
 step =
    make Piece.step
 
 {-# INLINE linear #-}
-linear :: (Field.C q, Dim.C u, Dim.C v, SigG.Write sig q) => T s u v sig q
+linear :: (Field.C q, Dim.C u, Dim.C v, SigG.Produce sig q) => T s u v sig q
 linear =
    make Piece.linear
 
 {-# INLINE exponential #-}
-exponential :: (Trans.C q, Dim.C u, Dim.C v, SigG.Write sig q) =>
+exponential :: (Trans.C q, Dim.C u, Dim.C v, SigG.Produce sig q) =>
    DN.T v q -> T s u v sig q
 exponential saturation =
-   Piecewise.pieceFromFunction $ \ y0 y1 d amplitude lazySize t0 ->
+   Piecewise.pieceFromFunction $ \ y0 y1 d amplitude t0 ->
       flip fmap (toTimeScalar d) (\d' ->
          SigA.flatFromBody $
          Piecewise.computePiece
             (Piece.exponential (toAmpScalar amplitude saturation))
             (toAmpScalar amplitude y0)
             (toAmpScalar amplitude y1)
-            d' lazySize t0)
+            d' t0)
 
 {-# INLINE cosine #-}
-cosine :: (Trans.C q, Dim.C u, Dim.C v, SigG.Write sig q) => T s u v sig q
+cosine :: (Trans.C q, Dim.C u, Dim.C v, SigG.Produce sig q) => T s u v sig q
 cosine =
    make Piece.cosine
 
 {-# INLINE halfSine #-}
-halfSine :: (Trans.C q, Dim.C u, Dim.C v, SigG.Write sig q) =>
+halfSine :: (Trans.C q, Dim.C u, Dim.C v, SigG.Produce sig q) =>
    Piece.FlatPosition -> T s u v sig q
 halfSine pos =
    make (Piece.halfSine pos)
 
 {-# INLINE cubic #-}
-cubic :: (Field.C q, Dim.C u, Dim.C v, SigG.Write sig q) =>
+cubic :: (Field.C q, Dim.C u, Dim.C v, SigG.Produce sig q) =>
    DN.T (DimensionGradient u v) q ->
    DN.T (DimensionGradient u v) q ->
    T s u v sig q
 cubic yd0 yd1 =
-   Piecewise.pieceFromFunction $ \ y0 y1 d amplitude lazySize t0 ->
+   Piecewise.pieceFromFunction $ \ y0 y1 d amplitude t0 ->
       liftM3 (\d' yd0' yd1' ->
          SigA.flatFromBody $
             Piecewise.computePiece
                (Piece.cubic yd0' yd1')
                (toAmpScalar amplitude y0)
                (toAmpScalar amplitude y1)
-               d' lazySize t0)
+               d' t0)
          (toTimeScalar d)
          (toGradientScalar amplitude yd0)
          (toGradientScalar amplitude yd1)
diff --git a/src/Synthesizer/Dimensional/RateAmplitude/Rain.hs b/src/Synthesizer/Dimensional/RateAmplitude/Rain.hs
--- a/src/Synthesizer/Dimensional/RateAmplitude/Rain.hs
+++ b/src/Synthesizer/Dimensional/RateAmplitude/Rain.hs
@@ -40,6 +40,7 @@
 import qualified Synthesizer.Dimensional.Amplitude.Flat as Flat
 import qualified Synthesizer.Dimensional.Amplitude as Amp
 import qualified Synthesizer.Dimensional.Sample as Sample
+import qualified Synthesizer.Dimensional.Duration as Dur
 import qualified Synthesizer.Dimensional.Rate as Rate
 
 import qualified Synthesizer.Frame.Stereo as Stereo
@@ -55,7 +56,7 @@
 
 import Synthesizer.Utility (balanceLevel, )
 
-import qualified Synthesizer.Storable.Signal as SigSt
+import qualified Data.StorableVector.Lazy.Typed as SVT
 
 import qualified Algebra.DimensionTerm as Dim
 import qualified Number.DimensionTerm  as DN
@@ -130,13 +131,13 @@
    fromIntegral pc / 12 + fromIntegral oct
 
 
-type Signal s amp a = SigA.T (Rate.Phantom s) amp (SigSt.T a)
+type Signal s amp a = SigA.T (Rate.Phantom s) amp (SVT.DefaultVector a)
 type Flat = Amp.Flat Double
 type Volt = Amp.Dimensional Dim.Voltage Double
 
 {-
 delay ::
-   (SigG2.Transform sig y (Stereo.T y), SigG.Write sig y,
+   (SigG2.Transform sig y (Stereo.T y), SigG.Produce sig y,
     Additive.C y, Amp.Primitive amp,
     RealField.C t, Dim.C u) =>
    DN.T u t ->
@@ -149,12 +150,13 @@
    Proc.T s Dim.Time Double
       (Signal s Flat Double -> Signal s Flat (Stereo.T Double))
 delay time =
-   let (appDelay, merge) =
+   let (delTime, merge) =
           if time>=zero
-            then (Filt.delay time, flip CutA.mergeStereoPrimitive)
-            else (Filt.delay (negate time), CutA.mergeStereoPrimitive)
-   in  flip fmap appDelay
-          (\del x -> merge x (del x))
+            then (time, flip CutA.mergeStereoPrimitive)
+            else (negate time, CutA.mergeStereoPrimitive)
+   in  fmap
+         (\del x -> merge x (del x))
+         (Filt.delay $: Dur.fromTime delTime)
 
 {-# INLINE bell #-}
 bell ::
@@ -163,8 +165,8 @@
    Proc.T s Dim.Time Double (Signal s Flat (Stereo.T Double))
 bell del freq =
    delay del .:
-   SigA.store timeUnit .:
-   CutR.take (DN.time 1) .:
+   SigA.storeTyped .:
+   (CutR.take $: Dur.fromTime (DN.time 1)) .:
    (Filt.envelope $: CtrlR.exponential2 (DN.time 0.2)) $:
    Osci.static (WaveD.flat Wave.sine) zero freq
 
@@ -188,7 +190,7 @@
    DN.Time Double ->
    Proc.T s Dim.Time Double (SigA.R s Dim.Scalar Double Double)
 stringEnvelope duration =
-   Piece.runState $
+   Piece.run $
       DN.scalar 0.01 |#
          (stringAttack,
           Piece.halfSine Piece.FlatRight) #|-
@@ -318,8 +320,7 @@
 chordSnds =
    EventList.traverseBody
       (\(tones,dur) ->
-          (SigA.store timeUnit .:
-           Disp.mixMulti) $:
+          (SigA.storeTyped .: Disp.mixMulti) $:
           mapM
              (strings (fromIntegral (dur*chordTicks) *& timeUnit) .
               (*& DN.frequency 440) . (2**) .
@@ -415,7 +416,7 @@
 simpleStorable :: Proc.T s Dim.Time Double (Signal s Volt (Stereo.T Double))
 simpleStorable =
    FiltA.amplify 0.5 $^
-   (Cut.arrangeStorableVolume timeUnit (DN.voltage 1) timeUnit
+   (Cut.arrangeStorableTypedVolume (DN.voltage 1) timeUnit
 --      $: chordSnds
 --      $: evolvingDropSnds
       $: -- fmap (EventList.fromPairList . drop 1100 . EventList.toPairList)
@@ -469,8 +470,9 @@
 --      "rain-long.aiff"
       "rain-short.aiff"
       ((CutA.dropWhile (DN.voltage 1) (zero==) .^
-        Cut.take
-           ((2 * NonNeg.toNumber partTicks +
-             fromIntegral stringAttackTicks) *& timeUnit))
+        (Cut.take
+          $: (Dur.fromTime $
+               (2 * NonNeg.toNumber partTicks +
+                fromIntegral stringAttackTicks) *& timeUnit)))
          $: simple)
      >> return ()
diff --git a/src/Synthesizer/Dimensional/RateAmplitude/Traumzauberbaum.hs b/src/Synthesizer/Dimensional/RateAmplitude/Traumzauberbaum.hs
--- a/src/Synthesizer/Dimensional/RateAmplitude/Traumzauberbaum.hs
+++ b/src/Synthesizer/Dimensional/RateAmplitude/Traumzauberbaum.hs
@@ -33,6 +33,7 @@
 import Synthesizer.Dimensional.Amplitude.Displacement (mapExponential, )
 
 import qualified Synthesizer.Dimensional.Sample as Sample
+import qualified Synthesizer.Dimensional.Duration as Dur
 
 import qualified Synthesizer.Frame.Stereo as Stereo
 
@@ -178,9 +179,9 @@
    DN.voltage 1 &*~ Wave.trapezoid p
 
 
-{-# INLINE timeUnit #-}
-timeUnit :: DN.T Dim.Time Double
-timeUnit = DN.time 0.2
+{-# INLINE intDur #-}
+intDur :: Int -> Proc.T s Dim.Time Double (Dur.T s Int)
+intDur dur = Dur.fromTime (fromIntegral dur *& DN.time 0.2)
 
 {-# INLINE pitchControl #-}
 pitchControl ::
@@ -189,7 +190,8 @@
 pitchControl =
    Cut.concatVolume (DN.scalar 1) $:
    (mapM (\(p,dur) ->
-      Cut.take (fromIntegral dur *& timeUnit)
+      Cut.take
+       $: intDur dur
        $: Ctrl.constant (DN.scalar (assemblePitch p))) melody)
 
 
@@ -307,7 +309,7 @@
    Proc.T s Dim.Time Double (SigA.R s Dim.Voltage Double (Stereo.T Double))
 chordAccompaniment =
    Cut.concat $::
-   (map (\(chd,dur) -> Cut.take (fromIntegral dur *& timeUnit) $: makeChord chd) chords)
+   (map (\(chd,dur) -> Cut.take $: intDur dur $: makeChord chd) chords)
 
 
 
@@ -318,12 +320,14 @@
 bassControl =
    Cut.concatVolume (DN.scalar 1) $::
    (map (\(p,dur) ->
-      Cut.take (fromIntegral dur *& timeUnit)
+      Cut.take
+       $: intDur dur
        $: Ctrl.constant (DN.scalar (assemblePitch p))) bass)
 {-
    Cut.concatVolume (DN.scalar 1) $:
    (mapM (\(p,dur) ->
-      Cut.take (fromIntegral dur *& timeUnit)
+      Cut.take
+       $: intDur dur
        $: Ctrl.constant (DN.scalar (assemblePitch p))) bass)
 -}
 
@@ -411,7 +415,8 @@
          $: (mapExponential 2 (DN.frequency 440) $^
                (Cut.concatVolume (DN.scalar 1) $:
                    (mapM (\p ->
-                      Cut.take (2 *& timeUnit)
+                      Cut.take
+                         $: intDur 2
                          $: Ctrl.constant (DN.scalar (assemblePitch p))) harmony)))
          $: accompaniment)
 
diff --git a/src/Synthesizer/Dimensional/Signal.hs b/src/Synthesizer/Dimensional/Signal.hs
--- a/src/Synthesizer/Dimensional/Signal.hs
+++ b/src/Synthesizer/Dimensional/Signal.hs
@@ -7,7 +7,7 @@
    asTypeOfAmplitude,
    render, apply,
    cache, bindCached, share,
-   store, restore,
+   store, storeTyped, restore,
    ($-),  ($&),
    (&*^), (&*>^),
    ) where
diff --git a/src/Synthesizer/Dimensional/Signal/Private.hs b/src/Synthesizer/Dimensional/Signal/Private.hs
--- a/src/Synthesizer/Dimensional/Signal/Private.hs
+++ b/src/Synthesizer/Dimensional/Signal/Private.hs
@@ -7,6 +7,7 @@
 module Synthesizer.Dimensional.Signal.Private where
 
 import qualified Synthesizer.Dimensional.Amplitude as Amp
+import qualified Synthesizer.Dimensional.Duration as Dur
 import qualified Synthesizer.Dimensional.Rate as Rate
 
 import qualified Synthesizer.Dimensional.Process as Proc
@@ -19,7 +20,8 @@
 import qualified Synthesizer.Storable.Signal as SigSt
 import qualified Synthesizer.Frame.Stereo as Stereo
 import qualified Synthesizer.Basic.Binary as BinSmp
-import Data.Int (Int16, )
+import qualified Data.StorableVector.Lazy.Typed as SVT
+import Data.Int (Int, Int16, )
 import Foreign.Storable (Storable, )
 
 import qualified Synthesizer.State.Signal as Sig
@@ -150,7 +152,7 @@
 Of course, for stereo signals @Stereo.T@ should be prefered.
 -}
 zip ::
-   (SigG.Transform sig y1, SigG.Transform sig (y0,y1), SigG.Read sig y0) =>
+   (SigG.Transform sig y1, SigG.Transform sig (y0,y1), SigG.Consume sig y0) =>
    T (Rate.Phantom s) amp0 (sig y0) ->
    T (Rate.Phantom s) amp1 (sig y1) ->
    T (Rate.Phantom s) (amp0,amp1) (sig (y0,y1))
@@ -233,22 +235,40 @@
 
 
 
+{-# INLINE lazyFromDefaultTypedVector #-}
+lazyFromDefaultTypedVector ::
+   (Storable yv) =>
+   T rate amp (SVT.DefaultVector yv) -> T rate amp (SigSt.T yv)
+lazyFromDefaultTypedVector =
+   processBody SVT.toVectorLazy
+
 {-# INLINE store #-}
 store ::
    (RealRing.C t, Dim.C u, Storable yv) =>
-   DN.T u t ->
    Proc.T s u t (
+      Dur.T s Int ->
       {-
       Rate.Phantom required,
       because chunk size is dicretized with respect to the process' sample rate
       -}
       T (Rate.Phantom s) amp (Sig.T yv) ->
       T (Rate.Phantom s) amp (SigSt.T yv))
-store chunkSize =
-   fmap
-      (\cs -> processBody (Sig.toStorableSignal (SigSt.chunkSize cs)))
-      (Proc.intFromTime "Dimensional.Signal.store" chunkSize)
+store =
+   Proc.pure $ \(Dur.Cons cs) ->
+      processBody (Sig.toStorableSignal (SigSt.chunkSize cs))
 
+{-# INLINE storeTyped #-}
+storeTyped ::
+   (SVT.Size size, RealRing.C t, Dim.C u, Storable yv) =>
+   Proc.T s u t (
+      {-
+      Rate.Phantom required,
+      because chunk size is dicretized with respect to the process' sample rate
+      -}
+      T (Rate.Phantom s) amp (Sig.T yv) ->
+      T (Rate.Phantom s) amp (SVT.Vector size yv))
+storeTyped = Proc.pure $ processBody SigG.fromState
+
 {-
 better use ChunkySize.Signal.store
 we do not need Proc context
@@ -266,7 +286,7 @@
 
 {-# INLINE restore #-}
 restore ::
-   (SigG.Read sig yv) =>
+   (SigG.Consume sig yv) =>
    T rate amp (sig yv) ->
    T rate amp (Sig.T yv)
 restore =
diff --git a/synthesizer-dimensional.cabal b/synthesizer-dimensional.cabal
--- a/synthesizer-dimensional.cabal
+++ b/synthesizer-dimensional.cabal
@@ -1,5 +1,5 @@
 Name:           synthesizer-dimensional
-Version:        0.8.1.1
+Version:        0.9
 License:        GPL
 License-File:   LICENSE
 Author:         Henning Thielemann <haskell@henning-thielemann.de>
@@ -33,24 +33,24 @@
   Location:    http://code.haskell.org/synthesizer/dimensional/
 
 Source-Repository this
-  Tag:         0.8.1.1
+  Tag:         0.9
   Type:        darcs
   Location:    http://code.haskell.org/synthesizer/dimensional/
 
 Library
   Build-Depends:
-    synthesizer-core >=0.8.1 && <0.9,
+    synthesizer-core >=0.9 && <0.10,
     transformers >=0.2 && <0.7,
-    semigroups >=0.1 && <1.0,
+    semigroups >=0.1 && <1,
     event-list >=0.1 && <0.2,
     non-negative >=0.1 && <0.2,
     numeric-prelude >=0.3 && <0.5,
     storable-record >=0.0.1 && <0.1,
     sox >=0.2 && <0.3,
-    storablevector >=0.2.3 && <0.3,
-    bytestring >= 0.9 && <0.12,
-    random >=1.0 && <2.0,
-    utility-ht >=0.0.5 && <0.1,
+    storablevector >=0.2.12 && <0.3,
+    bytestring >= 0.9 && <0.13,
+    random >=1.0 && <1.4,
+    utility-ht >=0.0.13 && <0.1,
     base >= 4 && <5
 
   If impl(ghc>=7.0)
@@ -66,6 +66,7 @@
     Synthesizer.Dimensional.Amplitude
     Synthesizer.Dimensional.Sample
     Synthesizer.Dimensional.Rate
+    Synthesizer.Dimensional.Duration
     Synthesizer.Dimensional.Arrow
     Synthesizer.Dimensional.Map
     Synthesizer.Dimensional.Map.Displacement
@@ -120,6 +121,7 @@
     Build-Depends:
       synthesizer-dimensional,
       synthesizer-core,
+      storablevector,
       numeric-prelude,
       event-list,
       utility-ht,
@@ -141,7 +143,7 @@
 Executable demonstration
   If flag(buildExamples)
     Build-Depends:
-      explicit-exception >=0.1.6 && <0.2,
+      explicit-exception >=0.1.6 && <0.3,
       old-time >=1.0 && <2,
 
       synthesizer-dimensional,