anchor.diff:                  shader
           )
   
  -    let runShader name createInput createOutput f =
  +    let runProgram name createInput createOutput f =
           pipeline {
  -            let! shader = getShader name createInput createOutput
  +            let! shader = getProgram name createInput createOutput
               return! shader.Run f
           }
  +
  +    let runSubPipeline name =
  +        Pipeline (
  +            fun context ->
  +                context.UseSubPipeline (name)
  +        )
  +
  +    let runProgramWithMesh<'T, 'Input when 'Input :> MeshInput> name createInput createOutput init f =
  +        Pipeline (
  +            fun context ->
  +                let program = context.ProgramCache.CreateShaderProgram (name)
  +                let input : 'Input = createInput program
  +                let output = createOutput program
  +
  +                let draw = (fun () -> program.Run RenderPass.Depth)
  +
  +                context.CurrentSubPipeline
  +                |> Option.iter (fun subPipeline ->
  +
  +                    subPipeline.TryGetLookup<'T> ()
  +                    |> Option.iter (fun lookup ->
  +
  +                        context.AddAction (fun () ->
  +                            Backend.useProgram program.programId
  +
  +                            input.Time.Set context.Time
  +                            input.View.Set context.View
  +                            input.Projection.Set context.Projection
  +
  +                            init input
  +
  +                            lookup
  +                            |> Seq.iter (fun pair ->
  +                                let key = pair.Key
  +                                let (texture, meshManager) = pair.Value
  +
  +                                input.Texture.Set texture.Buffer
  +
  +                                meshManager.ForEach (fun id (mesh, o) ->
  +                                    let o = 
  +                                        if o = null then Unchecked.defaultof<'T>
  +                                        else o :?> 'T
  +
  +                                    input.Position.Set mesh.Position
  +                                    input.Uv.Set mesh.Uv
  +                                    input.Color.Set mesh.Color
  +
  +                                    f o input draw
  +                                )
  +                            )
  +
  +                            program.Unbind ()
  +                            Backend.useProgram 0
  +                        )
  +                    )
  +                )
  +
  +                output 
  +        )
   
   open Pipeline
   
  
positive.code:         pipeline {
              let! renderTexture = captureFrame 1280 720 worldPipeline
  
              do! runShader "Fullscreen" FinalInput noOutput (fun input draw ->
                  input.Time.Set (getTime ())
                  input.Position.Set (getPosition ())
                  input.RenderTexture.Set renderTexture
  
negative.code:                 renderTexture
          )
  
      let getProgram name createInput createOutput =
          Pipeline (
              fun context ->
                  let shaderProgram = context.ProgramCache.CreateShaderProgram (name)
  