anchor.diff:      GL.ClearColor(0.1f, 0.2f, 0.5f, 0.0f)
   
       refresh_drawables ()
  -    (world_bounds :> IDrawable).prepare program
   
       base.OnLoad e
   
     override o.OnUnload(e) =
       GL.UseProgram(0)
  -    GL.DeleteProgram(program)
  -    GL.DeleteShader(vertex_shader)
  -    GL.DeleteShader(fragment_shader)
  +    for program in programs do
  +      GL.DeleteProgram(program)
  +    for shader in shaders do
  +      GL.DeleteShader(int32 shader)
       for drawable in drawables do
         drawable.destroy ()
       base.OnUnload e
  
positive.code:     let fluid = get_drawables (fun c -> c.media = Fluid)
      let solids = get_drawables (fun c -> c.media = Solid)
  
      // draw in a specific order for transparency reasons.
      cells <- fluid @ solids @ air
      for (cell: IDrawable) in cells do
        cell.prepare program
  
      drawables <- cells @ [(world_bounds :> IDrawable)]
  
    override o.OnLoad e =
  
      o.Cursor <- MouseCursor.Empty
  
      camera.initialize ()
  
      vertex_shader <-
        let shader = GL.CreateShader(ShaderType.VertexShader)
        GL.ShaderSource(shader, File.ReadAllText vertex_file)
        GL.CompileShader(shader)
        shader
      fragment_shader <-
        let shader = GL.CreateShader(ShaderType.FragmentShader)
        GL.ShaderSource(shader, File.ReadAllText fragment_file)
        GL.CompileShader(shader)
        shader
      program <-
        let program = GL.CreateProgram()
        GL.AttachShader(program, vertex_shader)
        GL.AttachShader(program, fragment_shader)
        GL.LinkProgram(program)
        program
  
      // testing
      let _ =
        printfn "%O" <| GL.GetString StringName.Extensions
        let shader = GL.CreateShader(ShaderType.VertexShader)
        GL.ShaderSource(shader, File.ReadAllText "src/splashy/shaders/normal.vert")
        GL.CompileShader(shader)
        let shader = GL.CreateShader(ShaderType.FragmentShader)
        GL.ShaderSource(shader, File.ReadAllText "src/splashy/shaders/normal.frag")
        GL.CompileShader(shader)
        let shader = GL.CreateShader(ShaderType.GeometryShader)
        GL.ShaderSource(shader, File.ReadAllText "src/splashy/shaders/normal.geom")
        GL.CompileShader(shader)
  
      let mutable s = ""
      GL.GetProgramInfoLog(program, &s)
      if not (Seq.isEmpty s) then
        failwith (sprintf "Shader compilation failed:\n%A" s)
      GL.UseProgram(program)
  
      projection_location <- GL.GetUniformLocation(program, "projectionMatrix")
      model_view_location <- GL.GetUniformLocation(program, "modelViewMatrix")
      vertex_location <- GL.GetUniformLocation(program, "vertex_mat")
  
      // set other GL states.
      GL.Enable(EnableCap.DepthTest)
  
negative.code: 
    do base.VSync <- VSyncMode.On
  
    let mutable shaders = []
    let mutable programs = []
    let mutable current_program = 0
  
    // configuration.
    let continuous = false
  
    let mutable projection_location = 0
    let mutable model_view_location = 0
  