anchor.diff:          let create (s : ISurface) =
               match SurfaceCompilers.compile ctx signature s with
                   | Success program -> program
  -                | Error e -> failwithf "[GL] surface compilation failed: %s" e
  +                | Error e -> 
  +                    Log.error "[GL] surface compilation failed: %s" e
  +                    failwithf "[GL] surface compilation failed: %s" e
   
           programCache.GetOrCreate<ISurface>(surface, {
               create = fun b      -> create b
  
positive.code:     static let vaoUpdateStats = updateStats ResourceKind.VertexArrayObject
      static let uniformLocationUpdateStats = updateStats ResourceKind.UniformLocation
  
      let bufferManager = Sharing.BufferManager(ctx)
      let arrayBufferManager = Sharing.ArrayBufferManager(ctx)
      let textureManager = Sharing.TextureManager(ctx)
  
      let arrayBufferCache = ResourceCache<Buffer>()
      let bufferCache = ResourceCache<Buffer>()
      let textureCache = ResourceCache<Texture>()
      let indirectBufferCache = ResourceCache<IndirectBuffer>()
      let programCache = ResourceCache<Program>()
      let samplerCache = ResourceCache<Sampler>()
      let vaoCache = ResourceCache<VertexArrayObject>()
      let uniformLocationCache = ResourceCache<UniformLocation>()
  
      let uniformBufferManagers = ConcurrentDictionary<int * list<ActiveUniform>, UniformBufferManager>()
  
      new(parent, ctx, shareTextures, shareBuffers) = ResourceManager(Some parent, ctx, shareTextures, shareBuffers)
      new(ctx, shareTextures, shareBuffers) = ResourceManager(None, ctx, shareTextures, shareBuffers)
  
      member x.Context = ctx
  
  
negative.code:             )
  
          member x.Create(data : IBuffer) =
              if active then
                  let shared = get data
                  shared.Acquire()
                  shared :> Buffer
              else
                  ctx.CreateBuffer data
  
          member x.Update(b : Buffer, data : IBuffer) : Buffer =
              if active then
                  match b with
                      | :? RefCountedBuffer as b ->
                      
                          let newShared = get data
                          if newShared = b then
                              b :> Buffer
                          else
                              newShared.Acquire()
                              b.Release()
                              newShared :> Buffer
                      | _ ->
                          ctx.Upload(b, data)
                          b
              else
                  ctx.Upload(b, data)
                  b
  
          member x.Delete(b : Buffer) =
              if active then
                  match b with
                      | :? RefCountedBuffer as b -> b.Release()
                      | _ -> ctx.Delete b
              else
                  ctx.Delete b
  
      type ArrayBufferManager(ctx : Context, active : bool) =
          let cache = ConcurrentDictionary<Array, RefCountedBuffer>()
  
          let get (b : Array) =
  