diff --git a/libs/hwui/Matrix.cpp b/libs/hwui/Matrix.cpp
index c772f00..e9c7791 100644
--- a/libs/hwui/Matrix.cpp
+++ b/libs/hwui/Matrix.cpp
@@ -97,6 +97,14 @@
     memcpy(v, data, sizeof(data));
 }
 
+float Matrix4::getTranslateX() {
+    return data[12];
+}
+
+float Matrix4::getTranslateY() {
+    return data[13];
+}
+
 void Matrix4::loadTranslate(float x, float y, float z) {
     loadIdentity();
     data[12] = x;
diff --git a/libs/hwui/Matrix.h b/libs/hwui/Matrix.h
index fa9638b..40c80fa 100644
--- a/libs/hwui/Matrix.h
+++ b/libs/hwui/Matrix.h
@@ -90,6 +90,9 @@
 
     void mapRect(Rect& r) const;
 
+    float getTranslateX();
+    float getTranslateY();
+
     void dump() const;
 
 private:
diff --git a/libs/hwui/OpenGLRenderer.cpp b/libs/hwui/OpenGLRenderer.cpp
index 830e0c3..786b927 100644
--- a/libs/hwui/OpenGLRenderer.cpp
+++ b/libs/hwui/OpenGLRenderer.cpp
@@ -27,6 +27,7 @@
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 
+#include <SkCanvas.h>
 #include <SkPaint.h>
 #include <SkXfermode.h>
 
@@ -40,21 +41,31 @@
 // Defines
 ///////////////////////////////////////////////////////////////////////////////
 
-#define V(x, y) { { x, y } }
+#define SV(x, y) { { x, y } }
+#define FV(x, y, u, v) { { x, y }, { u, v } }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Globals
 ///////////////////////////////////////////////////////////////////////////////
 
 const SimpleVertex gDrawColorVertices[] = {
-        V(0.0f, 0.0f),
-        V(1.0f, 0.0f),
-        V(0.0f, 1.0f),
-        V(1.0f, 1.0f)
+        SV(0.0f, 0.0f),
+        SV(1.0f, 0.0f),
+        SV(0.0f, 1.0f),
+        SV(1.0f, 1.0f)
 };
 const GLsizei gDrawColorVertexStride = sizeof(SimpleVertex);
 const GLsizei gDrawColorVertexCount = 4;
 
+const TextureVertex gDrawTextureVertices[] = {
+        FV(0.0f, 0.0f, 0.0f, 1.0f),
+        FV(1.0f, 0.0f, 1.0f, 1.0f),
+        FV(0.0f, 1.0f, 0.0f, 0.0f),
+        FV(1.0f, 1.0f, 1.0f, 0.0f)
+};
+const GLsizei gDrawTextureVertexStride = sizeof(TextureVertex);
+const GLsizei gDrawTextureVertexCount = 4;
+
 ///////////////////////////////////////////////////////////////////////////////
 // Shaders
 ///////////////////////////////////////////////////////////////////////////////
@@ -64,6 +75,9 @@
 #include "shaders/drawColor.vert"
 #include "shaders/drawColor.frag"
 
+#include "shaders/drawTexture.vert"
+#include "shaders/drawTexture.frag"
+
 Program::Program(const char* vertex, const char* fragment) {
     vertexShader = buildShader(vertex, GL_VERTEX_SHADER);
     fragmentShader = buildShader(fragment, GL_FRAGMENT_SHADER);
@@ -139,6 +153,15 @@
 
 DrawColorProgram::DrawColorProgram():
         Program(gDrawColorVertexShader, gDrawColorFragmentShader) {
+    getAttribsAndUniforms();
+}
+
+DrawColorProgram::DrawColorProgram(const char* vertex, const char* fragment):
+        Program(vertex, fragment) {
+    getAttribsAndUniforms();
+}
+
+void DrawColorProgram::getAttribsAndUniforms() {
     position = addAttrib("position");
     color = addAttrib("color");
     projection = addUniform("projection");
@@ -154,6 +177,12 @@
     glUniformMatrix4fv(transform, 1, GL_FALSE, transformMatrix);
 }
 
+DrawTextureProgram::DrawTextureProgram():
+        DrawColorProgram(gDrawTextureVertexShader, gDrawTextureFragmentShader) {
+    texCoords = addAttrib("texCoords");
+    sampler = addUniform("sampler");
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // Support
 ///////////////////////////////////////////////////////////////////////////////
@@ -175,6 +204,7 @@
     LOGD("Create OpenGLRenderer");
 
     mDrawColorShader = new DrawColorProgram;
+    mDrawTextureShader = new DrawTextureProgram;
 }
 
 OpenGLRenderer::~OpenGLRenderer() {
@@ -252,17 +282,90 @@
 
 bool OpenGLRenderer::restoreSnapshot() {
     bool restoreClip = mSnapshot->flags & Snapshot::kFlagClipSet;
+    bool restoreLayer = mSnapshot->flags & Snapshot::kFlagIsLayer;
 
+    sp<Snapshot> current = mSnapshot;
+    sp<Snapshot> previous = mSnapshot->previous;
+
+    if (restoreLayer) {
+        // Unbind current FBO and restore previous one
+        // Most of the time, previous->fbo will be 0 to bind the default buffer
+        glBindFramebuffer(GL_FRAMEBUFFER, previous->fbo);
+
+        const Rect& layer = current->layer;
+        clipRect(layer.left, layer.top, layer.right, layer.bottom);
+        mSnapshot->transform.loadIdentity();
+
+        drawTextureRect(0.0f, 0.0f, mWidth, mHeight, current->texture, current->alpha);
+
+        glDeleteFramebuffers(1, &current->fbo);
+        glDeleteTextures(1, &current->texture);
+    }
+
+    mSnapshot = previous;
     mSaveCount--;
 
-    // Do not merge these two lines!
-    sp<Snapshot> previous = mSnapshot->previous;
-    mSnapshot = previous;
-
     return restoreClip;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
+// Layers
+///////////////////////////////////////////////////////////////////////////////
+
+int OpenGLRenderer::saveLayer(float left, float top, float right, float bottom,
+        const SkPaint* p, int flags) {
+    // TODO Implement
+    return saveSnapshot();
+}
+
+int OpenGLRenderer::saveLayerAlpha(float left, float top, float right, float bottom,
+        int alpha, int flags) {
+    int count = saveSnapshot();
+
+    mSnapshot->flags |= Snapshot::kFlagIsLayer;
+    mSnapshot->alpha = alpha / 255.0f;
+    mSnapshot->layer.set(left, top, right, bottom);
+
+    // Generate the FBO and attach the texture
+    glGenFramebuffers(1, &mSnapshot->fbo);
+    glBindFramebuffer(GL_FRAMEBUFFER, mSnapshot->fbo);
+
+    // Generate the texture in which the FBO will draw
+    glGenTextures(1, &mSnapshot->texture);
+    glBindTexture(GL_TEXTURE_2D, mSnapshot->texture);
+
+    // The FBO will not be scaled, so we can use lower quality filtering
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+
+    // TODO ***** IMPORTANT *****
+    // Creating a texture-backed FBO works only if the texture is the same size
+    // as the original rendering buffer (in this case, mWidth and mHeight.)
+    // This is expensive and wasteful and must be fixed.
+
+    const GLsizei width = mWidth; //right - left;
+    const GLsizei height = mHeight; //bottom - right;
+
+    const GLint format = (flags & SkCanvas::kHasAlphaLayer_SaveFlag) ? GL_RGBA : GL_RGB;
+    glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, NULL);
+    glBindTexture(GL_TEXTURE_2D, 0);
+
+    // Bind texture to FBO
+    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
+            mSnapshot->texture, 0);
+
+    GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
+    if (status != GL_FRAMEBUFFER_COMPLETE) {
+        LOGD("Framebuffer incomplete %d", status);
+
+        glDeleteFramebuffers(1, &mSnapshot->fbo);
+        glDeleteTextures(1, &mSnapshot->texture);
+    }
+
+    return count;
+}
+
+///////////////////////////////////////////////////////////////////////////////
 // Transforms
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -346,10 +449,10 @@
     drawColorRect(clip.left, clip.top, clip.right, clip.bottom, color);
 }
 
-void OpenGLRenderer::drawRect(float left, float top, float right, float bottom, SkPaint* paint) {
+void OpenGLRenderer::drawRect(float left, float top, float right, float bottom, const SkPaint* p) {
     // TODO Support more than  just color
     // TODO: Set the transfer mode
-    drawColorRect(left, top, right, bottom, paint->getColor());
+    drawColorRect(left, top, right, bottom, p->getColor());
 }
 
 void OpenGLRenderer::drawColorRect(float left, float top, float right, float bottom, int color) {
@@ -375,5 +478,43 @@
     glDisableVertexAttribArray(mDrawColorShader->position);
 }
 
+void OpenGLRenderer::drawTextureRect(float left, float top, float right, float bottom,
+        GLuint texture, float alpha) {
+    mModelView.loadTranslate(left, top, 0.0f);
+    mModelView.scale(right - left, bottom - top, 1.0f);
+
+    mDrawTextureShader->use(&mOrthoMatrix[0], &mModelView.data[0], &mSnapshot->transform.data[0]);
+
+    // TODO Correctly set the blend function
+    glEnable(GL_BLEND);
+    glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
+
+    glBindTexture(GL_TEXTURE_2D, texture);
+
+    glActiveTexture(GL_TEXTURE0);
+    glUniform1i(mDrawTextureShader->sampler, 0);
+
+    const GLvoid* p = &gDrawTextureVertices[0].position[0];
+    const GLvoid* t = &gDrawTextureVertices[0].texture[0];
+
+    glEnableVertexAttribArray(mDrawTextureShader->position);
+    glVertexAttribPointer(mDrawTextureShader->position, 2, GL_FLOAT, GL_FALSE,
+            gDrawTextureVertexStride, p);
+
+    glEnableVertexAttribArray(mDrawTextureShader->texCoords);
+    glVertexAttribPointer(mDrawTextureShader->texCoords, 2, GL_FLOAT, GL_FALSE,
+            gDrawTextureVertexStride, t);
+
+    glVertexAttrib4f(mDrawTextureShader->color, 1.0f, 1.0f, 1.0f, alpha);
+
+    glDrawArrays(GL_TRIANGLE_STRIP, 0, gDrawTextureVertexCount);
+
+    glDisableVertexAttribArray(mDrawTextureShader->position);
+    glDisableVertexAttribArray(mDrawTextureShader->texCoords);
+
+    glBindTexture(GL_TEXTURE_2D, 0);
+    glDisable(GL_BLEND);
+}
+
 }; // namespace uirenderer
 }; // namespace android
diff --git a/libs/hwui/OpenGLRenderer.h b/libs/hwui/OpenGLRenderer.h
index 6f6b997..527bf3e 100644
--- a/libs/hwui/OpenGLRenderer.h
+++ b/libs/hwui/OpenGLRenderer.h
@@ -45,12 +45,17 @@
             transform(s->transform),
             clipRect(s->clipRect),
             flags(kFlagDirtyTransform),
-            previous(s) {
+            previous(s),
+            layer(0.0f, 0.0f, 0.0f, 0.0f),
+            texture(0),
+            fbo(0),
+            alpha(255) {
     }
 
     enum Flags {
         kFlagClipSet = 0x1,
         kFlagDirtyTransform = 0x2,
+        kFlagIsLayer = 0x4,
     };
 
     const Rect& getMappedClip();
@@ -67,6 +72,12 @@
     // Previous snapshot in the frames stack
     sp<Snapshot> previous;
 
+    // Layer, only set if kFlagIsLayer is set
+    Rect layer;
+    GLuint texture;
+    GLuint fbo;
+    float alpha;
+
 private:
     // Clipping rectangle mapped with the transform
     Rect mappedClip;
@@ -76,7 +87,10 @@
     float position[2];
 }; // struct SimpleVertex
 
-typedef char* shader;
+struct TextureVertex {
+    float position[2];
+    float texture[2];
+}; // struct TextureVertex
 
 class Program: public LightRefBase<Program> {
 public:
@@ -110,6 +124,7 @@
 class DrawColorProgram: public Program {
 public:
     DrawColorProgram();
+    DrawColorProgram(const char* vertex, const char* fragment);
 
     void use(const GLfloat* projectionMatrix, const GLfloat* modelViewMatrix,
              const GLfloat* transformMatrix);
@@ -120,6 +135,17 @@
     int projection;
     int modelView;
     int transform;
+
+protected:
+    void getAttribsAndUniforms();
+};
+
+class DrawTextureProgram: public DrawColorProgram {
+public:
+    DrawTextureProgram();
+
+    int sampler;
+    int texCoords;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -139,6 +165,9 @@
     void restore();
     void restoreToCount(int saveCount);
 
+    int saveLayer(float left, float top, float right, float bottom, const SkPaint* p, int flags);
+    int saveLayerAlpha(float left, float top, float right, float bottom, int alpha, int flags);
+
     void translate(float dx, float dy);
     void rotate(float degrees);
     void scale(float sx, float sy);
@@ -152,7 +181,7 @@
     bool clipRect(float left, float top, float right, float bottom);
 
     void drawColor(int color, SkXfermode::Mode mode);
-    void drawRect(float left, float top, float right, float bottom, SkPaint* paint);
+    void drawRect(float left, float top, float right, float bottom, const SkPaint* paint);
 
 private:
     int saveSnapshot();
@@ -161,6 +190,8 @@
     void setScissorFromClip();
 
     void drawColorRect(float left, float top, float right, float bottom, int color);
+    void drawTextureRect(float left, float top, float right, float bottom, GLuint texture,
+            float alpha);
 
     // Dimensions of the drawing surface
     int mWidth, mHeight;
@@ -180,6 +211,7 @@
 
     // Shaders
     sp<DrawColorProgram> mDrawColorShader;
+    sp<DrawTextureProgram> mDrawTextureShader;
 }; // class OpenGLRenderer
 
 }; // namespace uirenderer
diff --git a/libs/hwui/shaders/drawColor.frag b/libs/hwui/shaders/drawColor.frag
index f753abb..e84c47b 100644
--- a/libs/hwui/shaders/drawColor.frag
+++ b/libs/hwui/shaders/drawColor.frag
@@ -1,8 +1,6 @@
 SHADER_SOURCE(gDrawColorFragmentShader,
 
-precision mediump float;
-
-varying vec4 outColor;
+varying lowp vec4 outColor;
 
 void main(void) {
     gl_FragColor = outColor;
diff --git a/libs/hwui/shaders/drawTexture.frag b/libs/hwui/shaders/drawTexture.frag
new file mode 100644
index 0000000..5bd420e
--- /dev/null
+++ b/libs/hwui/shaders/drawTexture.frag
@@ -0,0 +1,12 @@
+SHADER_SOURCE(gDrawTextureFragmentShader,
+
+varying lowp vec4 outColor;
+varying mediump vec2 outTexCoords;
+
+uniform sampler2D sampler;
+
+void main(void) {
+    gl_FragColor = texture2D(sampler, outTexCoords) * outColor;
+}
+
+);
diff --git a/libs/hwui/shaders/drawTexture.vert b/libs/hwui/shaders/drawTexture.vert
new file mode 100644
index 0000000..310a812
--- /dev/null
+++ b/libs/hwui/shaders/drawTexture.vert
@@ -0,0 +1,20 @@
+SHADER_SOURCE(gDrawTextureVertexShader,
+
+attribute vec4 position;
+attribute vec2 texCoords;
+attribute vec4 color;
+
+uniform mat4 projection;
+uniform mat4 modelView;
+uniform mat4 transform;
+
+varying vec4 outColor;
+varying vec2 outTexCoords;
+
+void main(void) {
+    outColor = color;
+    outTexCoords = texCoords;
+    gl_Position = projection * transform * modelView * position;
+}
+
+);