diff --git a/README.md b/README.md
index 9b03c06..898c656 100644
--- a/README.md
+++ b/README.md
@@ -63,6 +63,7 @@ Tarek Sherif writes a really helpful [WebGL 2 Examples](https://github.com/tsher
 |[fbo_rtt_draw_buffers](http://webglsamples.org/WebGL2Samples/#fbo_rtt_draw_buffers)|:white_check_mark:|TODO|:white_check_mark:|TODO|
 |[fbo_rtt_texture_array](http://webglsamples.org/WebGL2Samples/#fbo_rtt_texture_array)|:white_check_mark:|:white_check_mark:|:white_check_mark:|:white_check_mark:|
 |[fbo_rtt_depth_texture](http://webglsamples.org/WebGL2Samples/#fbo_rtt_depth_texture)|:white_check_mark:|TODO|:white_check_mark:|TODO|
+|[fbo_read_pixels](http://webglsamples.org/WebGL2Samples/#fbo_read_pixels)|:white_check_mark:|TODO|:white_check_mark:|TODO|
 |[fbo_blit](http://webglsamples.org/WebGL2Samples/#fbo_blit)|:white_check_mark:|:white_check_mark:|:white_check_mark:|:white_check_mark:|
 |[fbo_multisample](http://webglsamples.org/WebGL2Samples/#fbo_multisample)|:white_check_mark:|:white_check_mark:|:white_check_mark:|:white_check_mark:|
 |[fbo_new_blend_equation](http://webglsamples.org/WebGL2Samples/#fbo_new_blend_equation)|:white_check_mark:|:white_check_mark:|:white_check_mark:|:white_check_mark:|
diff --git a/index.html b/index.html
index 9b0b67f..87d4d67 100644
--- a/index.html
+++ b/index.html
@@ -205,7 +205,8 @@ <h1>WebGL 2.0 Samples</h1>
                 "fbo_new_blend_equation",
                 "fbo_rtt_draw_buffers",
                 "fbo_rtt_texture_array",
-                "fbo_rtt_depth_texture"
+                "fbo_rtt_depth_texture",
+                "fbo_read_pixels"
             ],
             "Sampler": [
                 "sampler_object",
diff --git a/samples/draw_image_space.html b/samples/draw_image_space.html
index 3eae98a..80460d3 100644
--- a/samples/draw_image_space.html
+++ b/samples/draw_image_space.html
@@ -37,7 +37,7 @@
 
         void main()
         {
-            color = texture(diffuse, vec2(gl_FragCoord.x, 1.0 - gl_FragCoord.y) / u_imageSize);
+            color = texture(diffuse, vec2(gl_FragCoord.x, u_imageSize.y - gl_FragCoord.y) / u_imageSize);
         }
     </script>
 
diff --git a/samples/fbo_read_pixels.html b/samples/fbo_read_pixels.html
new file mode 100644
index 0000000..9c6919e
--- /dev/null
+++ b/samples/fbo_read_pixels.html
@@ -0,0 +1,344 @@
+<!DOCTYPE html>
+<!-- Ported from the OpenGL Samples Pack https://github.com/g-truc/ogl-samples/blob/master/tests/gl-320-fbo-rtt-texture-array.cpp -->
+<html lang="en">
+
+<head>
+    <title>WebGL 2 Samples - fbo_read_pixels</title>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, user-scalable=no, minimum-scale=1.0, maximum-scale=1.0">
+    <link rel="stylesheet" href="style.css">
+    <script src="utility.js"></script>
+</head>
+
+<body>
+    <div id="info">WebGL 2 Samples - fbo_read_pixels</div>
+    <p id="description">
+        This sample demonstrates rendering to texture in a frame buffer using a texture array. And readpixels from this frame buffer. The data read is printed in the console.
+    </p>
+
+    <script id="vs-layer" type="x-shader/x-vertex">
+        #version 300 es
+        #define POSITION_LOCATION 0
+        #define TEXCOORD_LOCATION 4
+
+        precision highp float;
+        precision highp int;
+
+        uniform mat4 mvp;
+
+        layout(location = POSITION_LOCATION) in vec2 position;
+        layout(location = TEXCOORD_LOCATION) in vec2 textureCoordinates;
+
+        out vec2 v_st;
+
+        void main()
+        {
+            v_st = textureCoordinates;
+            gl_Position = mvp * vec4(position, 0.0, 1.0);
+        }
+    </script>
+
+    <script id="fs-layer" type="x-shader/x-fragment">
+        #version 300 es
+
+        precision highp float;
+        precision highp int;
+        precision lowp sampler2DArray;
+
+        uniform sampler2DArray diffuse;
+        uniform int layer;
+
+        in vec2 v_st;
+
+        out vec4 color;
+
+        void main()
+        {
+            color = texture(diffuse, vec3(v_st, float(layer)));
+        }
+    </script>
+
+    <script id="vs-multiple-output" type="x-shader/x-vertex">
+        #version 300 es
+        #define POSITION_LOCATION 0
+
+        precision highp float;
+        precision highp int;
+
+        uniform mat4 mvp;
+
+        layout(location = POSITION_LOCATION) in vec2 position;
+
+        void main()
+        {
+            gl_Position = mvp * vec4(position, 0.0, 1.0);
+        }
+    </script>
+
+    <script id="fs-multiple-output" type="x-shader/x-fragment">
+        #version 300 es
+
+        precision highp float;
+        precision highp int;
+
+        layout(location = 0) out vec4 red;
+        layout(location = 1) out vec4 green;
+        layout(location = 2) out vec4 blue;
+
+        void main()
+        {
+            red = vec4(0.5, 0.0, 0.0, 1.0);
+            green = vec4(0.0, 0.3, 0.0, 1.0);
+            blue = vec4(0.0, 0.0, 0.8, 1.0);
+        }
+    </script>
+
+    <script>
+    (function()  {
+        'use strict';
+
+        var canvas = document.createElement('canvas');
+        canvas.width = Math.min(window.innerWidth, window.innerHeight);
+        canvas.height = canvas.width;
+        document.body.appendChild(canvas);
+
+        var gl = canvas.getContext( 'webgl2', { antialias: false } );
+        var isWebGL2 = !!gl;
+        if(!isWebGL2) {
+            document.getElementById('info').innerHTML = 'WebGL 2 is not available.  See <a href="https://www.khronos.org/webgl/wiki/Getting_a_WebGL_Implementation">How to get a WebGL 2 implementation</a>';
+            return;
+        }
+
+        // -- Divide viewport
+
+        var windowSize = {
+            x: canvas.width,
+            y: canvas.height
+        };
+
+        var Textures = {
+            RED: 0,
+            GREEN: 1,
+            BLUE: 2,
+            MAX: 3
+        };
+
+        var viewport = new Array(Textures.MAX);
+
+        viewport[Textures.RED] = {
+            x: windowSize.x / 2,
+            y: 0,
+            z: windowSize.x / 2,
+            w: windowSize.y / 2
+        };
+
+        viewport[Textures.GREEN] = {
+            x: windowSize.x / 2,
+            y: windowSize.y / 2,
+            z: windowSize.x / 2,
+            w: windowSize.y / 2
+        };
+
+        viewport[Textures.BLUE] = {
+            x: 0,
+            y: windowSize.y / 2,
+            z: windowSize.x / 2,
+            w: windowSize.y / 2
+        };
+
+        // -- Initialize program
+
+        // Multiple out shaders
+        var multipleOutputProgram = createProgram(gl, getShaderSource('vs-multiple-output'), getShaderSource('fs-multiple-output'));
+
+        var multipleOutputUniformMvpLocation = gl.getUniformLocation(multipleOutputProgram, 'mvp');
+
+        // Layer shaders
+        var layerProgram = createProgram(gl, getShaderSource('vs-layer'), getShaderSource('fs-layer'));
+
+        var layerUniformMvpLocation = gl.getUniformLocation(layerProgram, 'mvp');
+        var layerUniformDiffuseLocation = gl.getUniformLocation(layerProgram, 'diffuse');
+        var layerUniformLayerLocation = gl.getUniformLocation(layerProgram, 'layer');
+
+        // -- Initialize buffer
+
+        var positions = new Float32Array([
+            -1.0, -1.0,
+             1.0, -1.0,
+             1.0,  1.0,
+             1.0,  1.0,
+            -1.0,  1.0,
+            -1.0, -1.0
+        ]);
+        var vertexPosBuffer = gl.createBuffer();
+        gl.bindBuffer(gl.ARRAY_BUFFER, vertexPosBuffer);
+        gl.bufferData(gl.ARRAY_BUFFER, positions, gl.STATIC_DRAW);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+
+        var texcoords = new Float32Array([
+            0.0, 0.0,
+            1.0, 0.0,
+            1.0, 1.0,
+            1.0, 1.0,
+            0.0, 1.0,
+            0.0, 0.0
+        ]);
+        var vertexTexBuffer = gl.createBuffer();
+        gl.bindBuffer(gl.ARRAY_BUFFER, vertexTexBuffer);
+        gl.bufferData(gl.ARRAY_BUFFER, texcoords, gl.STATIC_DRAW);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+
+        // -- Initialize vertex array
+
+        var multipleOutputVertexArray = gl.createVertexArray();
+        gl.bindVertexArray(multipleOutputVertexArray);
+
+        var multipleOutputVertexPosLocation = 0; // set with GLSL layout qualifier
+        gl.bindBuffer(gl.ARRAY_BUFFER, vertexPosBuffer);
+        gl.vertexAttribPointer(multipleOutputVertexPosLocation, 2, gl.FLOAT, false, 0, 0);
+        gl.enableVertexAttribArray(multipleOutputVertexPosLocation);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+
+        gl.bindVertexArray(null);
+
+        var layerVertexArray = gl.createVertexArray();
+        gl.bindVertexArray(layerVertexArray);
+
+        var layerVertexPosLocation = 0; // set with GLSL layout qualifier
+        gl.bindBuffer(gl.ARRAY_BUFFER, vertexPosBuffer);
+        gl.vertexAttribPointer(layerVertexPosLocation, 2, gl.FLOAT, false, 0, 0);
+        gl.enableVertexAttribArray(layerVertexPosLocation);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+
+        var layerVertexTexLocation = 4; // set with GLSL layout qualifier
+        gl.bindBuffer(gl.ARRAY_BUFFER, vertexTexBuffer);
+        gl.vertexAttribPointer(layerVertexTexLocation, 2, gl.FLOAT, false, 0, 0);
+        gl.enableVertexAttribArray(layerVertexTexLocation);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+
+        gl.bindVertexArray(null);
+
+        // -- Initialize texture
+
+        gl.activeTexture(gl.TEXTURE0);
+        var texture = gl.createTexture();
+        gl.bindTexture(gl.TEXTURE_2D_ARRAY, texture);
+        gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_BASE_LEVEL, 0);
+        gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MAX_LEVEL, 0);
+        gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+        gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+
+        var w = 16;
+        var h = 16;
+
+        gl.texImage3D(gl.TEXTURE_2D_ARRAY,
+            0,
+            gl.RGB8,
+            w,
+            h,
+            3,//depth
+            0,
+            gl.RGB,
+            gl.UNSIGNED_BYTE,
+            null);
+
+        // -- Initialize frame buffer
+
+        var frameBuffer = gl.createFramebuffer();
+        gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, frameBuffer);
+
+        var drawBuffers = new Array(3);
+        drawBuffers[Textures.RED] = gl.COLOR_ATTACHMENT0;
+        drawBuffers[Textures.GREEN] = gl.COLOR_ATTACHMENT1;
+        drawBuffers[Textures.BLUE] = gl.COLOR_ATTACHMENT2;
+
+        gl.framebufferTextureLayer(gl.DRAW_FRAMEBUFFER, gl.COLOR_ATTACHMENT0, texture, 0, Textures.RED);
+        gl.framebufferTextureLayer(gl.DRAW_FRAMEBUFFER, gl.COLOR_ATTACHMENT1, texture, 0, Textures.GREEN);
+        gl.framebufferTextureLayer(gl.DRAW_FRAMEBUFFER, gl.COLOR_ATTACHMENT2, texture, 0, Textures.BLUE);
+
+        var status = gl.checkFramebufferStatus(gl.DRAW_FRAMEBUFFER);
+        if (status != gl.FRAMEBUFFER_COMPLETE) {
+            console.log('fb status: ' + status.toString(16));
+            return;
+        }
+
+        gl.drawBuffers(drawBuffers);
+
+        gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, null);
+
+        // -- Render
+
+        // Clear color buffer
+        gl.clearColor(0.0, 0.0, 0.0, 1.0);
+        gl.clear(gl.COLOR_BUFFER_BIT);
+
+        // Pass 1
+        gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, frameBuffer);
+
+        // Bind program
+        gl.useProgram(multipleOutputProgram);
+
+        var matrix = new Float32Array([
+            1.0, 0.0, 0.0, 0.0,
+            0.0, 1.0, 0.0, 0.0,
+            0.0, 0.0, 1.0, 0.0,
+            0.0, 0.0, 0.0, 1.0
+        ]);
+        gl.uniformMatrix4fv(multipleOutputUniformMvpLocation, false, matrix);
+        gl.bindVertexArray(multipleOutputVertexArray);
+        gl.viewport(0, 0, w, h);
+        gl.drawArrays(gl.TRIANGLES, 0, 6);
+
+        // Pass 2
+        gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, null);
+
+        // Bind program
+        gl.useProgram(layerProgram);
+        gl.uniformMatrix4fv(layerUniformMvpLocation, false, matrix);
+        gl.uniform1i(layerUniformDiffuseLocation, 0);
+
+        gl.activeTexture(gl.TEXTURE0);
+        gl.bindTexture(gl.TEXTURE_2D_ARRAY, texture);
+        gl.bindVertexArray(layerVertexArray);
+
+        status = gl.checkFramebufferStatus(gl.DRAW_FRAMEBUFFER);
+        if (status != gl.FRAMEBUFFER_COMPLETE) {
+            console.log('fb status: ' + status.toString(16));
+            return;
+        }
+
+        for(var i = 0; i < Textures.MAX; ++i)
+        {
+            gl.viewport(viewport[i].x, viewport[i].y, viewport[i].z, viewport[i].w);
+            gl.uniform1i(layerUniformLayerLocation, i);
+
+            gl.drawArrays(gl.TRIANGLES, 0, 6);
+        }
+
+        var data = new Uint8Array( w * h * 4 * 3 );
+        gl.bindFramebuffer(gl.READ_FRAMEBUFFER, frameBuffer);
+        gl.readBuffer(gl.COLOR_ATTACHMENT0);
+        gl.readPixels(0, 0, w, h, gl.RGBA, gl.UNSIGNED_BYTE, data, 0);
+        gl.readBuffer(gl.COLOR_ATTACHMENT1);
+        gl.readPixels(0, 0, w, h, gl.RGBA, gl.UNSIGNED_BYTE, data, w * h * 4);
+        gl.readBuffer(gl.COLOR_ATTACHMENT2);
+        gl.readPixels(0, 0, w, h, gl.RGBA, gl.UNSIGNED_BYTE, data, w * h * 4 * 2);
+        console.log(data);
+
+        // Clean up
+        gl.deleteBuffer(vertexPosBuffer);
+        gl.deleteBuffer(vertexTexBuffer);
+        gl.deleteVertexArray(multipleOutputVertexArray);
+        gl.deleteVertexArray(layerVertexArray);
+        gl.deleteFramebuffer(frameBuffer);
+        gl.deleteTexture(texture);
+        gl.deleteProgram(multipleOutputProgram);
+        gl.deleteProgram(layerProgram);
+
+    })();
+    </script>
+    <div id="highlightedLines"  style="display: none">#L391-L327</div>
+
+</body>
+
+</html>
diff --git a/samples/fbo_rtt_texture_array.html b/samples/fbo_rtt_texture_array.html
index 8d303ad..b3b496a 100644
--- a/samples/fbo_rtt_texture_array.html
+++ b/samples/fbo_rtt_texture_array.html
@@ -13,7 +13,7 @@
 <body>
     <div id="info">WebGL 2 Samples - fbo_rtt_texture_array</div>
     <p id="description">
-        This sample demonstrates rendering to texture in a frame buffer using a texture array. And readpixels from this frame buffer.
+        This sample demonstrates rendering to texture in a frame buffer using a texture array. 
     </p>
 
     <script id="vs-layer" type="x-shader/x-vertex">
@@ -228,8 +228,6 @@
         gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
         gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
 
-        // var w = Math.floor(windowSize.x / 2);
-        // var h = Math.floor(windowSize.y / 2);
         var w = 16;
         var h = 16;
 
@@ -288,7 +286,8 @@
         ]);
         gl.uniformMatrix4fv(multipleOutputUniformMvpLocation, false, matrix);
         gl.bindVertexArray(multipleOutputVertexArray);
-        gl.drawArraysInstanced(gl.TRIANGLES, 0, 6, 1);
+        gl.viewport(0, 0, w, h);
+        gl.drawArrays(gl.TRIANGLES, 0, 6);
 
         // Pass 2
         gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, null);
@@ -313,21 +312,9 @@
             gl.viewport(viewport[i].x, viewport[i].y, viewport[i].z, viewport[i].w);
             gl.uniform1i(layerUniformLayerLocation, i);
 
-            gl.drawArraysInstanced(gl.TRIANGLES, 0, 6, 1);
+            gl.drawArrays(gl.TRIANGLES, 0, 6);
         }
 
-        console.log(w, h, w * h * 4);
-        var data = new Uint8Array( w * h * 4 * 3 );
-        gl.bindFramebuffer(gl.READ_FRAMEBUFFER, frameBuffer);
-        gl.readBuffer(gl.COLOR_ATTACHMENT0);
-        gl.readPixels(0, 0, w, h, gl.RGBA, gl.UNSIGNED_BYTE, data, 0);
-        gl.readBuffer(gl.COLOR_ATTACHMENT1);
-        gl.readPixels(0, 0, w, h, gl.RGBA, gl.UNSIGNED_BYTE, data, w * h * 4);
-        gl.readBuffer(gl.COLOR_ATTACHMENT2);
-        gl.readPixels(0, 0, w, h, gl.RGBA, gl.UNSIGNED_BYTE, data, w * h * 4 * 2);
-        console.log(data);
-        console.log( data.slice(w * h * 4 - 8, w * h * 4 + 12) );
-
         // Clean up
         gl.deleteBuffer(vertexPosBuffer);
         gl.deleteBuffer(vertexTexBuffer);
@@ -340,7 +327,7 @@
 
     })();
     </script>
-    <div id="highlightedLines"  style="display: none">#L223-L291</div>
+    <div id="highlightedLines"  style="display: none">#L223-L290</div>
 
 </body>
 
diff --git a/samples/glsl_flat_smooth_interpolators.html b/samples/glsl_flat_smooth_interpolators.html
index 1ba4035..d07e2a1 100644
--- a/samples/glsl_flat_smooth_interpolators.html
+++ b/samples/glsl_flat_smooth_interpolators.html
@@ -260,7 +260,7 @@
             // -- Render loop
             (function render() {
                 gl.clearColor(0.0, 0.0, 0.0, 1.0);
-                gl.clear(gl.COLOR_BUFFER_BIT);
+                gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
 
                 mat4.rotateY(modelView, modelView, rotatationSpeedY);
 
diff --git a/samples/query_occlusion.html b/samples/query_occlusion.html
index 0260735..8346198 100644
--- a/samples/query_occlusion.html
+++ b/samples/query_occlusion.html
@@ -21,11 +21,11 @@
         precision highp float;
         precision highp int;
 
-        layout(location = POSITION_LOCATION) in vec2 pos;
+        layout(location = POSITION_LOCATION) in vec3 pos;
 
         void main()
         {
-            gl_Position = vec4(pos,0.0,1.0);
+            gl_Position = vec4(pos, 1.0);
         }
     </script>
 
@@ -38,7 +38,7 @@
 
         void main()
         {
-            color = vec4(1.0,0.5,0.0,1.0);
+            color = vec4(1.0, 0.5, 0.0, 1.0);
         }
     </script>
 
@@ -64,12 +64,17 @@
         // -- Init Program
         var program = createProgram(gl, getShaderSource('vs'), getShaderSource('fs'));
         gl.useProgram(program);
+        gl.enable(gl.DEPTH_TEST);
 
         // -- Init Buffer
         var vertices = new Float32Array([
-            -0.3, -0.5,
-             0.3, -0.5,
-             0.0,  0.5
+            -0.3, -0.5, 0.0,
+             0.3, -0.5, 0.0,
+             0.0,  0.5, 0.0,
+
+             -0.3, -0.5, 0.5,
+             0.3, -0.5, 0.5,
+             0.0,  0.5, 0.5
         ]);
         var vertexPosBuffer = gl.createBuffer();
         gl.bindBuffer(gl.ARRAY_BUFFER, vertexPosBuffer);
@@ -81,7 +86,7 @@
 
         var vertexPosLocation = 0; // set with GLSL layout qualifier
         gl.enableVertexAttribArray(vertexPosLocation);
-        gl.vertexAttribPointer(vertexPosLocation, 2, gl.FLOAT, false, 0, 0);
+        gl.vertexAttribPointer(vertexPosLocation, 3, gl.FLOAT, false, 0, 0);
 
         gl.bindVertexArray(null);
 
@@ -90,12 +95,14 @@
 
         // -- Render
         gl.clearColor(0.0, 0.0, 0.0, 1.0);
-        gl.clear(gl.COLOR_BUFFER_BIT);
+        gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
 
         gl.bindVertexArray(vertexArray);
 
+        gl.drawArrays(gl.TRIANGLES, 0, 3);
+
         gl.beginQuery(gl.ANY_SAMPLES_PASSED, query);
-        gl.drawArraysInstanced(gl.TRIANGLES, 0, 3, 2);
+        gl.drawArrays(gl.TRIANGLES, 3, 3);
         gl.endQuery(gl.ANY_SAMPLES_PASSED);
 
         (function tick() {
@@ -117,6 +124,6 @@
         gl.deleteVertexArray(vertexArray);
     })();
     </script>
-    <div id="highlightedLines"  style="display: none">#L97-L112</div>
+    <div id="highlightedLines"  style="display: none">#L94-L119</div>
 </body>
 </html>
diff --git a/samples/texture_srgb.html b/samples/texture_srgb.html
index f02e3f0..7faa630 100644
--- a/samples/texture_srgb.html
+++ b/samples/texture_srgb.html
@@ -17,7 +17,7 @@
         <br>
         This is useful since because then we could work with the filtering math in linear space, then convert back to sRGB space for the color output.
         <br>
-        The output below is applied to a Guassian blur filter.
+        The output below is applied to a Gaussian blur filter.
 
     </p>
     <!-- Shader code is modified adapted from xissburg at http://xissburg.com/faster-gaussian-blur-in-glsl/ -->
diff --git a/samples/transform_feedback_instanced.html b/samples/transform_feedback_instanced.html
index 07aae2a..7d291b4 100644
--- a/samples/transform_feedback_instanced.html
+++ b/samples/transform_feedback_instanced.html
@@ -213,6 +213,9 @@
 
         var vertexArrays = [gl.createVertexArray(), gl.createVertexArray()];
 
+        // Transform feedback objects track output buffer state
+        var transformFeedbacks = [gl.createTransformFeedback(), gl.createTransformFeedback()];
+
         var vertexBuffers = new Array(vertexArrays.length);
 
         for (var va = 0; va < vertexArrays.length; ++va) {
@@ -227,7 +230,7 @@
 
             vertexBuffers[va][ROTATION_LOCATION] = gl.createBuffer();
             gl.bindBuffer(gl.ARRAY_BUFFER, vertexBuffers[va][ROTATION_LOCATION]);
-            gl.bufferData(gl.ARRAY_BUFFER, instanceOffsets, gl.STREAM_COPY);
+            gl.bufferData(gl.ARRAY_BUFFER, instanceRotations, gl.STREAM_COPY);
             gl.vertexAttribPointer(ROTATION_LOCATION, 1, gl.FLOAT, false, 0, 0);
             gl.enableVertexAttribArray(ROTATION_LOCATION);
 
@@ -245,10 +248,15 @@
             gl.vertexAttribDivisor(COLOR_LOCATION, 1); // attribute used once per instance
 
             gl.bindVertexArray(null);
-        }
+            gl.bindBuffer(gl.ARRAY_BUFFER, null);
+            
+            // Set up output
+            gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, transformFeedbacks[va]);
+            gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 0, vertexBuffers[va][OFFSET_LOCATION]);
+            gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 1, vertexBuffers[va][ROTATION_LOCATION]);
 
-        // -- Init TransformFeedback
-        var transformFeedback = gl.createTransformFeedback();
+            gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, null);
+        }
 
         render();
 
@@ -295,27 +303,28 @@
 
         function transform() {
             var programTransform = programs[PROGRAM_TRANSFORM];
+            var destinationIdx = (currentSourceIdx + 1) % 2;
 
             // Toggle source and destination VBO
-            var sourceVBO = vertexBuffers[currentSourceIdx];
             var sourceVAO = vertexArrays[currentSourceIdx];
 
-            var destinationVBO = vertexBuffers[(currentSourceIdx + 1) % 2];
-
-            gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, transformFeedback);
+            var destinationTransformFeedback = transformFeedbacks[destinationIdx];
 
             gl.useProgram(programTransform);
 
             gl.bindVertexArray(sourceVAO);
+            gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, destinationTransformFeedback);
+
+            // NOTE: The following two lines shouldn't be necessary, but are required to work in ANGLE
+            // due to a bug in its handling of transform feedback objects.
+            // https://bugs.chromium.org/p/angleproject/issues/detail?id=2051
+            gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 0, vertexBuffers[destinationIdx][OFFSET_LOCATION]);
+            gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 1, vertexBuffers[destinationIdx][ROTATION_LOCATION]);
 
             // Attributes per-vertex when doing transform feedback needs setting to 0 when doing transform feedback
             gl.vertexAttribDivisor(OFFSET_LOCATION, 0);
             gl.vertexAttribDivisor(ROTATION_LOCATION, 0);
 
-            // Set transform feedback buffer
-            gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, OFFSET_LOCATION, destinationVBO[OFFSET_LOCATION]);
-            gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, ROTATION_LOCATION, destinationVBO[ROTATION_LOCATION]);
-
             // Turn off rasterization - we are not drawing
             gl.enable(gl.RASTERIZER_DISCARD);
 
@@ -328,8 +337,8 @@
             gl.disable(gl.RASTERIZER_DISCARD);
             gl.useProgram(null);
             gl.bindBuffer(gl.ARRAY_BUFFER, null);
-            gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 0, null);
             gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, null);
+            gl.bindBuffer(gl.TRANSFORM_FEEDBACK_BUFFER, null);
 
             // Ping pong the buffers
             currentSourceIdx = (currentSourceIdx + 1) % 2;
@@ -369,7 +378,6 @@
 
         // If you have a long-running page, and need to delete WebGL resources, use:
         //
-        // gl.deleteTransformFeedback(transformFeedback);
         // gl.deleteProgram(programs[PROGRAM_TRANSFORM]);
         // gl.deleteProgram(programs[PROGRAM_DRAW]);
         // for (var i = 0; i < 2; ++i) {
@@ -379,9 +387,11 @@
         // }
         // gl.deleteVertexArray(vertexArrays[PROGRAM_TRANSFORM]);
         // gl.deleteVertexArray(vertexArrays[PROGRAM_DRAW]);
+        // gl.deleteTransformFeedback(transformFeedbacks[0]);
+        // gl.deleteTransformFeedback(transformFeedbacks[1]);
     })();
     </script>
-    <div id="highlightedLines"  style="display: none">#L243-L360</div>
+    <div id="highlightedLines"  style="display: none">#L221-L367</div>
 
 </body>
 
diff --git a/samples/transform_feedback_interleaved.html b/samples/transform_feedback_interleaved.html
index 07bc7b9..bc83729 100644
--- a/samples/transform_feedback_interleaved.html
+++ b/samples/transform_feedback_interleaved.html
@@ -172,6 +172,14 @@
         gl.bufferData(gl.ARRAY_BUFFER, SIZE_V4C4 * VERTEX_COUNT, gl.STATIC_COPY);
         gl.bindBuffer(gl.ARRAY_BUFFER, null);
 
+        // -- Init TransformFeedback: Track output buffer
+        var transformFeedback = gl.createTransformFeedback();
+        
+        gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, transformFeedback);
+        gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 0, buffers[PROGRAM_FEEDBACK]);
+        gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, null);
+        gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 0, null);
+
         // -- Init Vertex Array
         var vertexArrays = [gl.createVertexArray(), gl.createVertexArray()];
         gl.bindVertexArray(vertexArrays[PROGRAM_TRANSFORM]);
@@ -191,14 +199,11 @@
         gl.bindBuffer(gl.ARRAY_BUFFER, buffers[PROGRAM_FEEDBACK]);
         gl.vertexAttribPointer(vertexPosLocationFeedback, 4, gl.FLOAT, false, SIZE_V4C4, 0);
         gl.vertexAttribPointer(vertexColorLocationFeedback, 4, gl.FLOAT, false, SIZE_V4C4, SIZE_V4C4 / 2);
-        gl.bindBuffer(gl.ARRAY_BUFFER, null);
         gl.enableVertexAttribArray(vertexPosLocationFeedback);
         gl.enableVertexAttribArray(vertexColorLocationFeedback);
 
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
         gl.bindVertexArray(null);
-        
-        // -- Init TransformFeedback 
-        var transformFeedback = gl.createTransformFeedback();
 
         // -- Render
         gl.clearColor(0.0, 0.0, 0.0, 1.0);
@@ -208,8 +213,6 @@
         // Disable rasterization, vertices processing only
         gl.enable(gl.RASTERIZER_DISCARD);
         
-        gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, transformFeedback);
-
         gl.useProgram(programs[PROGRAM_TRANSFORM]);
         var matrix = new Float32Array([
             0.5, 0.0, 0.0, 0.0,
@@ -219,15 +222,15 @@
         ]);
         gl.uniformMatrix4fv(mvpLocation, false, matrix);
 
-        gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 0, buffers[PROGRAM_FEEDBACK]);
         gl.bindVertexArray(vertexArrays[PROGRAM_TRANSFORM]);
+        gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, transformFeedback);
 
         gl.beginTransformFeedback(gl.TRIANGLES);
         gl.drawArraysInstanced(gl.TRIANGLES, 0, VERTEX_COUNT, 1);
         gl.endTransformFeedback();
+        gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, null);
 
         gl.disable(gl.RASTERIZER_DISCARD);
-        gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 0, null);
 
         // Second draw, reuse captured attributes
         gl.useProgram(programs[PROGRAM_FEEDBACK]);
diff --git a/samples/transform_feedback_separated.html b/samples/transform_feedback_separated.html
index 6faf4b0..6ded664 100644
--- a/samples/transform_feedback_separated.html
+++ b/samples/transform_feedback_separated.html
@@ -186,7 +186,7 @@
         gl.bufferData(gl.ARRAY_BUFFER, positions.length * Float32Array.BYTES_PER_ELEMENT, gl.STATIC_COPY);
         gl.bindBuffer(gl.ARRAY_BUFFER, null);
 
-        // -- Init Vertex Array
+        // -- Init Transform Vertex Array
         var vertexArrays = [gl.createVertexArray(), gl.createVertexArray()];
         gl.bindVertexArray(vertexArrays[PROGRAM_TRANSFORM]);
 
@@ -198,6 +198,16 @@
 
         gl.bindVertexArray(null);
 
+        // -- Init TransformFeedback
+        var transformFeedback = gl.createTransformFeedback();
+        gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, transformFeedback);
+        gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 0, buffers[BufferType.POSITION]);
+        gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 1, buffers[BufferType.COLOR]);
+        gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, null);
+        gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 0, null);
+        gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 1, null);
+
+        // -- Init Feedback Vertex Array 
         gl.bindVertexArray(vertexArrays[PROGRAM_FEEDBACK]);
 
         var vertexPosLocationFeedback = 0; // set with GLSL layout qualifier
@@ -213,9 +223,6 @@
         gl.bindBuffer(gl.ARRAY_BUFFER, null);
         gl.bindVertexArray(null);
 
-        // -- Init TransformFeedback
-        var transformFeedback = gl.createTransformFeedback();
-
         // -- Render
 
         gl.clearColor(0.0, 0.0, 0.0, 1.0);
@@ -225,7 +232,6 @@
         // Disable rasterization, vertices processing only
         gl.enable(gl.RASTERIZER_DISCARD);
 
-        gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, transformFeedback);
 
         gl.useProgram(programs[PROGRAM_TRANSFORM]);
         var matrix = new Float32Array([
@@ -236,17 +242,15 @@
         ]);
         gl.uniformMatrix4fv(mvpLocation, false, matrix);
 
-        gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 0, buffers[BufferType.POSITION]);
-        gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 1, buffers[BufferType.COLOR]);
         gl.bindVertexArray(vertexArrays[PROGRAM_TRANSFORM]);
+        gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, transformFeedback);
 
         gl.beginTransformFeedback(gl.TRIANGLES);
         gl.drawArraysInstanced(gl.TRIANGLES, 0, VERTEX_COUNT, 1);
         gl.endTransformFeedback();
+        gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, null);
 
         gl.disable(gl.RASTERIZER_DISCARD);
-        gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 0, null);
-        gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 1, null);
 
         // Second draw, reuse captured attributes
         gl.useProgram(programs[PROGRAM_FEEDBACK]);
@@ -265,7 +269,7 @@
         gl.deleteVertexArray(vertexArrays[PROGRAM_FEEDBACK]);
     })();
     </script>
-    <div id="highlightedLines"  style="display: none">#L108-L255</div>
+    <div id="highlightedLines"  style="display: none">#L108-L251</div>
 
 </body>
 </html>
diff --git a/samples/transform_feedback_separated_2.html b/samples/transform_feedback_separated_2.html
index 483dbeb..860d594 100644
--- a/samples/transform_feedback_separated_2.html
+++ b/samples/transform_feedback_separated_2.html
@@ -149,11 +149,15 @@
         // -- Init Vertex Arrays and Buffers
         var particleVAOs = [gl.createVertexArray(), gl.createVertexArray()];
 
+        // Transform feedback objects track output buffer state
+        var particleTransformFeedbacks = [gl.createTransformFeedback(), gl.createTransformFeedback()];
+        
         var particleVBOs = new Array(particleVAOs.length);
 
         for (var i = 0; i < particleVAOs.length; ++i) {
             particleVBOs[i] = new Array(NUM_LOCATIONS);
 
+            // Set up input
             gl.bindVertexArray(particleVAOs[i]);
 
             particleVBOs[i][POSITION_LOCATION] = gl.createBuffer();
@@ -185,6 +189,16 @@
             gl.bufferData(gl.ARRAY_BUFFER, particleIDs, gl.STATIC_READ);
             gl.vertexAttribPointer(ID_LOCATION, 1, gl.FLOAT, false, 0, 0);
             gl.enableVertexAttribArray(ID_LOCATION);
+
+            gl.bindBuffer(gl.ARRAY_BUFFER, null);
+            
+            // Set up output
+            gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, particleTransformFeedbacks[i]);
+            gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 0, particleVBOs[i][POSITION_LOCATION]);
+            gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 1, particleVBOs[i][VELOCITY_LOCATION]);
+            gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 2, particleVBOs[i][SPAWNTIME_LOCATION]);
+            gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 3, particleVBOs[i][LIFETIME_LOCATION]);
+
         }
 
         function initProgram() {
@@ -237,13 +251,10 @@
         gl.enable(gl.BLEND);
         gl.blendFunc(gl.SRC_ALPHA, gl.ONE);
 
-        // -- Init TransformFeedback
-        var transformFeedback = gl.createTransformFeedback();
-        gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, transformFeedback);
-
         function render() {
 
             var time = Date.now() - appStartTime;
+            var destinationIdx = (currentSourceIdx + 1) % 2;
 
             // Set the viewport
             gl.viewport(0, 0, canvas.width, canvas.height - 10);
@@ -254,15 +265,18 @@
 
             // Toggle source and destination VBO
             var sourceVAO = particleVAOs[currentSourceIdx];
-            var destinationVBO = particleVBOs[(currentSourceIdx + 1) % 2];
+            var destinationTransformFeedback = particleTransformFeedbacks[destinationIdx];
 
             gl.bindVertexArray(sourceVAO);
+            gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, destinationTransformFeedback);
 
-            // Set transform feedback buffer
-            gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 0, destinationVBO[POSITION_LOCATION]);
-            gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 1, destinationVBO[VELOCITY_LOCATION]);
-            gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 2, destinationVBO[SPAWNTIME_LOCATION]);
-            gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 3, destinationVBO[LIFETIME_LOCATION]);
+            // NOTE: The following four lines shouldn't be necessary, but are required to work in ANGLE
+            // due to a bug in its handling of transform feedback objects.
+            // https://bugs.chromium.org/p/angleproject/issues/detail?id=2051
+            gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 0, particleVBOs[destinationIdx][POSITION_LOCATION]);
+            gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 1, particleVBOs[destinationIdx][VELOCITY_LOCATION]);
+            gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 2, particleVBOs[destinationIdx][SPAWNTIME_LOCATION]);
+            gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 3, particleVBOs[destinationIdx][LIFETIME_LOCATION]);
 
             // Set uniforms
             gl.uniform1f(drawTimeLocation, time);
@@ -282,17 +296,17 @@
 
         // If you have a long-running page, and need to delete WebGL resources, use:
         //
-        // gl.deleteTransformFeedback(transformFeedback);
         // gl.deleteProgram(program);
         // for (var i = 0; i < particleVAOs.length; ++i) {
-        //     gl.deleteVertexArray(i); 
+        //     gl.deleteVertexArray(particleVAOs[i]); 
+        //     gl.deleteTransformFeedback(particleTransformFeedbacks[i]);
         //     for (var j = 0; j < NUM_LOCATIONS; ++j) {
         //         gl.deleteBuffer(particleVBOs[i][j]);
         //     }
         // }
     })();
     </script>
-    <div id="highlightedLines"  style="display: none">#L246-L278</div>
+    <div id="highlightedLines"  style="display: none">#L193-L278</div>
 
 </body>