anchor.diff:  
                   let bucket =
                       {
  -                        Transforms = ResizeArray ()
  +                        GetTransforms = ResizeArray ()
                           Positions = ResizeArray ()
                           Uvs = ResizeArray ()
                           Colors = ResizeArray ()
  +                        RefIndices = ResizeArray ()
                       }
   
                   textureLookup.Add (textureId, (texture, bucket))
   
                   (texture, bucket)
   
  -        bucket.Transforms.Add transformComp
  +        let indexRef = ref bucket.GetTransforms.Count
  +
  +        bucket.GetTransforms.Add transformComp
           bucket.Positions.Add position
           bucket.Uvs.Add uv
           bucket.Colors.Add color
  +        bucket.RefIndices.Add indexRef
  +
  +        let deletion =
  +            fun () ->
  +                let lastIndexRef = bucket.RefIndices.[bucket.RefIndices.Count - 1]
  +
  +                let originalIndex = !indexRef
  +                let lastIndex = !lastIndexRef
  +
  +                lastIndexRef := originalIndex
  +
  +                bucket.GetTransforms.[originalIndex] <- bucket.GetTransforms.[lastIndex]
  +                bucket.Positions.[originalIndex] <- bucket.Positions.[lastIndex]
  +                bucket.Uvs.[originalIndex] <- bucket.Uvs.[lastIndex]
  +                bucket.Colors.[originalIndex] <- bucket.Colors.[lastIndex]
  +                bucket.RefIndices.[originalIndex] <- bucket.RefIndices.[lastIndex]
  +
  +                bucket.GetTransforms.RemoveAt (lastIndex) |> ignore
  +                bucket.Positions.RemoveAt (lastIndex) |> ignore
  +                bucket.Uvs.RemoveAt (lastIndex) |> ignore
  +                bucket.Colors.RemoveAt (lastIndex) |> ignore
  +                bucket.RefIndices.RemoveAt (lastIndex) |> ignore
  +
  +        this.Deletion.Add (ent, deletion);
       
       member this.ForEach f =
           this.Lookup
  
positive.code: // TODO: We could make this instanced.
  type RenderBucket =
      {
          Transforms: TransformComponent ResizeArray
          Positions: Vector3ArrayBuffer ResizeArray
          Uvs: Vector2ArrayBuffer ResizeArray
          Colors: Color ResizeArray
      }
  
  type RenderState =
      {
          Lookup: Dictionary<int, Dictionary<int, Texture2DBuffer option * RenderBucket>>
      }
  
      member this.Add (programId, textureId, texture, transformComp, position, uv, color) =
          let textureLookup =
              match this.Lookup.TryGetValue (programId) with
              | true, lookup -> lookup
  
negative.code: // Fixme: global
  let state = 
      {
          Deletion = Dictionary ()
          Lookup = Dictionary ()
      }
  
  