anchor.diff:                  | x when x > skip -> skip
                   | x -> x
   
  -            let acc = gl.Accumulator + deltaTime
  +            let updateAcc = gl.UpdateAccumulator + deltaTime
  +
  +            // We do not want our render accumulator going out of control,
  +            // so let's put a limit of its interval.
  +            let renderAcc = 
  +                match gl.RenderAccumulator with
  +                | x when x > gl.RenderInterval -> gl.RenderInterval
  +                | x -> x + deltaTime
   
               let rec processUpdate gl =
  -                if gl.Accumulator >= targetUpdateInterval
  +                if gl.UpdateAccumulator >= targetUpdateInterval
                   then
                       let state = update gl.UpdateTime targetUpdateInterval gl.State
                       let renderInterval = time () - currentTime
  
positive.code:                             State = state
                              PreviousState = gl.State
                              UpdateTime = gl.UpdateTime + targetUpdateInterval
                              Accumulator = gl.Accumulator - targetUpdateInterval
                              RenderInterval = renderInterval }
                  else
                      gl
  
              let processRender gl =
                  if currentTime >= gl.LastRenderTime + gl.RenderInterval then
                      render (gl.Accumulator / targetUpdateInterval) gl.PreviousState gl.State
                      { gl with 
                          LastTime = currentTime
                          LastRenderTime = currentTime }
                  else            
                      { gl with 
                          LastTime = currentTime }
                           
              { gl with Accumulator = acc }
              |> processUpdate
              |> processRender
              |> loop
  
negative.code:         State: 'T
          PreviousState: 'T
          LastTime: float
          UpdateTime: float
          UpdateAccumulator: float
          RenderAccumulator: float
          RenderInterval: float }
  
      let start (state: 'T) (update: float -> float -> 'T -> 'T) (render: float -> 'T -> 'T -> unit) =
  