diff --git a/libs/hwui/FontRenderer.cpp b/libs/hwui/FontRenderer.cpp
index 5595ab0..6074ec8 100644
--- a/libs/hwui/FontRenderer.cpp
+++ b/libs/hwui/FontRenderer.cpp
@@ -327,6 +327,7 @@
     mTextTexture = new unsigned char[mCacheWidth * mCacheHeight];
     mUploadTexture = false;
 
+    glActiveTexture(GL_TEXTURE0);
     glGenTextures(1, &mTextureId);
     glBindTexture(GL_TEXTURE_2D, mTextureId);
     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
diff --git a/libs/hwui/Matrix.cpp b/libs/hwui/Matrix.cpp
index b459202..0c31ba9 100644
--- a/libs/hwui/Matrix.cpp
+++ b/libs/hwui/Matrix.cpp
@@ -152,6 +152,11 @@
     float s = sinf(angle);
 
     const float length = sqrtf(x * x + y * y + z * z);
+    float recipLen = 1.0f / length;
+    x *= recipLen;
+    y *= recipLen;
+    z *= recipLen;
+
     const float nc = 1.0f - c;
     const float xy = x * y;
     const float yz = y * z;
diff --git a/libs/hwui/OpenGLRenderer.cpp b/libs/hwui/OpenGLRenderer.cpp
index 0ed6276..3d9aa26 100644
--- a/libs/hwui/OpenGLRenderer.cpp
+++ b/libs/hwui/OpenGLRenderer.cpp
@@ -62,6 +62,15 @@
 static const GLsizei gMeshStride = sizeof(TextureVertex);
 static const GLsizei gMeshCount = 4;
 
+/**
+ * Structure mapping Skia xfermodes to OpenGL blending factors.
+ */
+struct Blender {
+    SkXfermode::Mode mode;
+    GLenum src;
+    GLenum dst;
+}; // struct Blender
+
 // In this array, the index of each Blender equals the value of the first
 // entry. For instance, gBlends[1] == gBlends[SkXfermode::kSrc_Mode]
 static const Blender gBlends[] = {
@@ -80,9 +89,15 @@
 };
 
 static const GLint gTileModes[] = {
-        GL_CLAMP_TO_EDGE,   // == SkShader::kClamp_TileMode
-        GL_REPEAT,          // == SkShader::kRepeat_Mode
-        GL_MIRRORED_REPEAT  // == SkShader::kMirror_TileMode
+        GL_CLAMP_TO_EDGE,   // SkShader::kClamp_TileMode
+        GL_REPEAT,          // SkShader::kRepeat_Mode
+        GL_MIRRORED_REPEAT  // SkShader::kMirror_TileMode
+};
+
+static const GLenum gTextureUnits[] = {
+        GL_TEXTURE0,        // Bitmap or text
+        GL_TEXTURE1,        // Gradient
+        GL_TEXTURE2         // Bitmap shader
 };
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -119,11 +134,7 @@
         LOGD("  Using default gradient cache size of %.2fMB", DEFAULT_GRADIENT_CACHE_SIZE);
     }
 
-    mDrawColorProgram = new DrawColorProgram;
-    mDrawTextureProgram = new DrawTextureProgram;
-    mDrawTextProgram = new DrawTextProgram;
-    mDrawLinearGradientProgram = new DrawLinearGradientProgram;
-    mCurrentProgram = mDrawTextureProgram;
+    mCurrentProgram = NULL;
 
     mShader = kShaderNone;
     mShaderTileX = GL_CLAMP_TO_EDGE;
@@ -131,20 +142,13 @@
     mShaderMatrix = NULL;
     mShaderBitmap = NULL;
 
-    mLastTexture = 0;
-
     memcpy(mMeshVertices, gMeshVertices, sizeof(gMeshVertices));
 
-    ProgramDescription d;
-    mProgramCache.get(d);
-    d.hasTexture = true;
-    mProgramCache.get(d);
-    d.hasAlpha8Texture = true;
-    d.hasGradient = true;
-    d.hasBitmap = true;
-    d.shadersMode = SkXfermode::kDstOut_Mode;
-    d.colorOp = ProgramDescription::kColorMatrix;
-    mProgramCache.get(d);
+    glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &mMaxTextureUnits);
+    if (mMaxTextureUnits < REQUIRED_TEXTURE_UNITS_COUNT) {
+        LOGW("At least %d texture units are required!", REQUIRED_TEXTURE_UNITS_COUNT);
+    }
+    mLastTexture[0] = mLastTexture[1] = mLastTexture[2] = 0;
 }
 
 OpenGLRenderer::~OpenGLRenderer() {
@@ -468,6 +472,7 @@
     const float u2 = srcRight / width;
     const float v2 = srcBottom / height;
 
+    // TODO: Do this in the shader
     resetDrawTextureTexCoords(u1, v1, u2, v2);
 
     drawTextureRect(dstLeft, dstTop, dstRight, dstBottom, texture, paint);
@@ -532,6 +537,8 @@
         return;
     }
 
+    glActiveTexture(GL_TEXTURE0);
+
     float length;
     switch (paint->getTextAlign()) {
         case SkPaint::kCenter_Align:
@@ -558,22 +565,29 @@
 
     mModelView.loadIdentity();
 
-    useProgram(mDrawTextProgram);
-    mDrawTextProgram->set(mOrthoMatrix, mModelView, mSnapshot->transform);
+    ProgramDescription description;
+    description.hasTexture = true;
+    description.hasAlpha8Texture = true;
+
+    useProgram(mProgramCache.get(description));
+    mCurrentProgram->set(mOrthoMatrix, mModelView, mSnapshot->transform);
 
     chooseBlending(true, mode);
-    bindTexture(mFontRenderer.getTexture(), GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE);
+    bindTexture(mFontRenderer.getTexture(), GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE, 0);
+
+    int texCoordsSlot = mCurrentProgram->getAttrib("texCoords");
+    glEnableVertexAttribArray(texCoordsSlot);
 
     // Always premultiplied
-    glUniform4f(mDrawTextProgram->color, r, g, b, a);
+    glUniform4f(mCurrentProgram->color, r, g, b, a);
 
     // TODO: Implement scale properly
     const Rect& clip = mSnapshot->getLocalClip();
-
     mFontRenderer.setFont(paint, SkTypeface::UniqueID(paint->getTypeface()), paint->getTextSize());
     mFontRenderer.renderText(paint, &clip, text, 0, bytesCount, count, x, y);
 
     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+    glDisableVertexAttribArray(texCoordsSlot);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -599,8 +613,7 @@
 }
 
 void OpenGLRenderer::setupLinearGradientShader(SkShader* shader, float* bounds, uint32_t* colors,
-        float* positions, int count, SkShader::TileMode tileMode, SkMatrix* matrix,
-        bool hasAlpha) {
+        float* positions, int count, SkShader::TileMode tileMode, SkMatrix* matrix, bool hasAlpha) {
     // TODO: We should use a struct to describe each shader
     mShader = OpenGLRenderer::kShaderLinearGradient;
     mShaderKey = shader;
@@ -650,30 +663,31 @@
     mModelView.loadTranslate(left, top, 0.0f);
     mModelView.scale(right - left, bottom - top, 1.0f);
 
-    if (!useProgram(mDrawColorProgram)) {
+    ProgramDescription description;
+    Program* program = mProgramCache.get(description);
+    if (!useProgram(program)) {
         const GLvoid* vertices = &mMeshVertices[0].position[0];
         const GLvoid* texCoords = &mMeshVertices[0].texture[0];
 
-        glVertexAttribPointer(mDrawColorProgram->position, 2, GL_FLOAT, GL_FALSE,
+        glVertexAttribPointer(mCurrentProgram->position, 2, GL_FLOAT, GL_FALSE,
                 gMeshStride, vertices);
-        glVertexAttribPointer(mDrawColorProgram->texCoords, 2, GL_FLOAT, GL_FALSE,
-                gMeshStride, texCoords);
     }
 
     if (!ignoreTransform) {
-        mDrawColorProgram->set(mOrthoMatrix, mModelView, mSnapshot->transform);
+        mCurrentProgram->set(mOrthoMatrix, mModelView, mSnapshot->transform);
     } else {
         mat4 identity;
-        mDrawColorProgram->set(mOrthoMatrix, mModelView, identity);
+        mCurrentProgram->set(mOrthoMatrix, mModelView, identity);
     }
 
-    glUniform4f(mDrawColorProgram->color, r, g, b, a);
+    glUniform4f(mCurrentProgram->color, r, g, b, a);
 
     glDrawArrays(GL_TRIANGLE_STRIP, 0, gMeshCount);
 }
 
 void OpenGLRenderer::drawLinearGradientShader(float left, float top, float right, float bottom,
         float alpha, SkXfermode::Mode mode) {
+    glActiveTexture(GL_TEXTURE1);
     Texture* texture = mGradientCache.get(mShaderKey);
     if (!texture) {
         SkShader::TileMode tileMode = SkShader::kClamp_TileMode;
@@ -690,14 +704,18 @@
                 mShaderPositions, mShaderCount, tileMode);
     }
 
+    ProgramDescription description;
+    description.hasGradient = true;
+
     mModelView.loadTranslate(left, top, 0.0f);
     mModelView.scale(right - left, bottom - top, 1.0f);
 
-    useProgram(mDrawLinearGradientProgram);
-    mDrawLinearGradientProgram->set(mOrthoMatrix, mModelView, mSnapshot->transform);
+    useProgram(mProgramCache.get(description));
+    mCurrentProgram->set(mOrthoMatrix, mModelView, mSnapshot->transform);
 
     chooseBlending(mShaderBlend || alpha < 1.0f, mode);
-    bindTexture(texture->id, mShaderTileX, mShaderTileY);
+    bindTexture(texture->id, mShaderTileX, mShaderTileY, 1);
+    glUniform1i(mCurrentProgram->getUniform("gradientSampler"), 1);
 
     Rect start(mShaderBounds[0], mShaderBounds[1], mShaderBounds[2], mShaderBounds[3]);
     if (mShaderMatrix) {
@@ -713,15 +731,15 @@
     screenSpace.multiply(mModelView);
 
     // Always premultiplied
-    glUniform4f(mDrawLinearGradientProgram->color, alpha, alpha, alpha, alpha);
-    glUniform2f(mDrawLinearGradientProgram->start, start.left, start.top);
-    glUniform2f(mDrawLinearGradientProgram->gradient, gradientX, gradientY);
-    glUniform1f(mDrawLinearGradientProgram->gradientLength,
+    glUniform4f(mCurrentProgram->color, alpha, alpha, alpha, alpha);
+    glUniform2f(mCurrentProgram->getUniform("gradientStart"), start.left, start.top);
+    glUniform2f(mCurrentProgram->getUniform("gradient"), gradientX, gradientY);
+    glUniform1f(mCurrentProgram->getUniform("gradientLength"),
             1.0f / (gradientX * gradientX + gradientY * gradientY));
-    glUniformMatrix4fv(mDrawLinearGradientProgram->screenSpace, 1, GL_FALSE,
+    glUniformMatrix4fv(mCurrentProgram->getUniform("screenSpace"), 1, GL_FALSE,
             &screenSpace.data[0]);
 
-    glVertexAttribPointer(mDrawLinearGradientProgram->position, 2, GL_FLOAT, GL_FALSE,
+    glVertexAttribPointer(mCurrentProgram->position, 2, GL_FLOAT, GL_FALSE,
             gMeshStride, &mMeshVertices[0].position[0]);
 
     glDrawArrays(GL_TRIANGLE_STRIP, 0, gMeshCount);
@@ -729,42 +747,55 @@
 
 void OpenGLRenderer::drawBitmapShader(float left, float top, float right, float bottom,
         float alpha, SkXfermode::Mode mode) {
+    glActiveTexture(GL_TEXTURE2);
     const Texture* texture = mTextureCache.get(mShaderBitmap);
 
     const float width = texture->width;
     const float height = texture->height;
 
-    // This could be done in the vertex shader but we have only 4 vertices
-    float u1 = 0.0f;
-    float v1 = 0.0f;
-    float u2 = right - left;
-    float v2 = bottom - top;
+    mModelView.loadTranslate(left, top, 0.0f);
+    mModelView.scale(right - left, bottom - top, 1.0f);
 
-    // TODO: If the texture is not pow, use a shader to support repeat/mirror
+    mat4 textureTransform;
     if (mShaderMatrix) {
         SkMatrix inverse;
         mShaderMatrix->invert(&inverse);
-        mat4 m(inverse);
-        Rect r(u1, v1, u2, v2);
-        m.mapRect(r);
-
-        u1 = r.left;
-        u2 = r.right;
-        v1 = r.top;
-        v2 = r.bottom;
+        textureTransform.load(inverse);
+        textureTransform.multiply(mModelView);
+    } else {
+        textureTransform.load(mModelView);
     }
 
-    u1 /= width;
-    u2 /= width;
-    v1 /= height;
-    v2 /= height;
+    ProgramDescription description;
+    description.hasBitmap = true;
+    // The driver does not support non-power of two mirrored/repeated
+    // textures, so do it ourselves
+    if (!mExtensions.hasNPot()) {
+        description.isBitmapNpot = true;
+        description.bitmapWrapS = mShaderTileX;
+        description.bitmapWrapT = mShaderTileY;
+    }
 
-    resetDrawTextureTexCoords(u1, v1, u2, v2);
+    useProgram(mProgramCache.get(description));
+    mCurrentProgram->set(mOrthoMatrix, mModelView, mSnapshot->transform);
 
-    drawTextureMesh(left, top, right, bottom, texture->id, alpha, mode, texture->blend,
-            &mMeshVertices[0].position[0], &mMeshVertices[0].texture[0], NULL);
+    chooseBlending(texture->blend || alpha < 1.0f, mode);
 
-    resetDrawTextureTexCoords(0.0f, 0.0f, 1.0f, 1.0f);
+    // Texture
+    bindTexture(texture->id, mShaderTileX, mShaderTileY, 2);
+    glUniform1i(mCurrentProgram->getUniform("bitmapSampler"), 2);
+    glUniformMatrix4fv(mCurrentProgram->getUniform("textureTransform"), 1,
+            GL_FALSE, &textureTransform.data[0]);
+    glUniform2f(mCurrentProgram->getUniform("textureDimension"), 1.0f / width, 1.0f / height);
+
+    // Always premultiplied
+    glUniform4f(mCurrentProgram->color, alpha, alpha, alpha, alpha);
+
+    // Mesh
+    glVertexAttribPointer(mCurrentProgram->position, 2, GL_FLOAT, GL_FALSE,
+            gMeshStride, &mMeshVertices[0].position[0]);
+
+    glDrawArrays(GL_TRIANGLE_STRIP, 0, gMeshCount);
 }
 
 void OpenGLRenderer::drawTextureRect(float left, float top, float right, float bottom,
@@ -786,28 +817,37 @@
 void OpenGLRenderer::drawTextureMesh(float left, float top, float right, float bottom,
         GLuint texture, float alpha, SkXfermode::Mode mode, bool blend,
         GLvoid* vertices, GLvoid* texCoords, GLvoid* indices, GLsizei elementsCount) {
+    ProgramDescription description;
+    description.hasTexture = true;
+
     mModelView.loadTranslate(left, top, 0.0f);
     mModelView.scale(right - left, bottom - top, 1.0f);
 
-    useProgram(mDrawTextureProgram);
-    mDrawTextureProgram->set(mOrthoMatrix, mModelView, mSnapshot->transform);
+    useProgram(mProgramCache.get(description));
+    mCurrentProgram->set(mOrthoMatrix, mModelView, mSnapshot->transform);
 
     chooseBlending(blend || alpha < 1.0f, mode);
-    bindTexture(texture, mShaderTileX, mShaderTileY);
+
+    // Texture
+    bindTexture(texture, mShaderTileX, mShaderTileY, 0);
+    glUniform1i(mCurrentProgram->getUniform("sampler"), 0);
 
     // Always premultiplied
-    glUniform4f(mDrawTextureProgram->color, alpha, alpha, alpha, alpha);
+    glUniform4f(mCurrentProgram->color, alpha, alpha, alpha, alpha);
 
-    glVertexAttribPointer(mDrawTextureProgram->position, 2, GL_FLOAT, GL_FALSE,
+    // Mesh
+    int texCoordsSlot = mCurrentProgram->getAttrib("texCoords");
+    glEnableVertexAttribArray(texCoordsSlot);
+    glVertexAttribPointer(mCurrentProgram->position, 2, GL_FLOAT, GL_FALSE,
             gMeshStride, vertices);
-    glVertexAttribPointer(mDrawTextureProgram->texCoords, 2, GL_FLOAT, GL_FALSE,
-            gMeshStride, texCoords);
+    glVertexAttribPointer(texCoordsSlot, 2, GL_FLOAT, GL_FALSE, gMeshStride, texCoords);
 
     if (!indices) {
         glDrawArrays(GL_TRIANGLE_STRIP, 0, gMeshCount);
     } else {
         glDrawElements(GL_TRIANGLES, elementsCount, GL_UNSIGNED_SHORT, indices);
     }
+    glDisableVertexAttribArray(texCoordsSlot);
 }
 
 void OpenGLRenderer::chooseBlending(bool blend, SkXfermode::Mode mode, bool isPremultiplied) {
@@ -836,9 +876,9 @@
     mBlend = blend;
 }
 
-bool OpenGLRenderer::useProgram(const sp<Program>& program) {
+bool OpenGLRenderer::useProgram(Program* program) {
     if (!program->isInUse()) {
-        mCurrentProgram->remove();
+        if (mCurrentProgram != NULL) mCurrentProgram->remove();
         program->use();
         mCurrentProgram = program;
         return false;
@@ -875,12 +915,12 @@
     }
 }
 
-void OpenGLRenderer::bindTexture(GLuint texture, GLenum wrapS, GLenum wrapT) {
-    if (texture != mLastTexture) {
+void OpenGLRenderer::bindTexture(GLuint texture, GLenum wrapS, GLenum wrapT, GLuint textureUnit) {
+    glActiveTexture(gTextureUnits[textureUnit]);
+    if (texture != mLastTexture[textureUnit]) {
         glBindTexture(GL_TEXTURE_2D, texture);
-        mLastTexture = texture;
+        mLastTexture[textureUnit] = texture;
     }
-    // TODO: Don't set the texture parameters every time
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrapS);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrapT);
 }
diff --git a/libs/hwui/OpenGLRenderer.h b/libs/hwui/OpenGLRenderer.h
index 975be05..5e5c021 100644
--- a/libs/hwui/OpenGLRenderer.h
+++ b/libs/hwui/OpenGLRenderer.h
@@ -47,22 +47,11 @@
 namespace uirenderer {
 
 ///////////////////////////////////////////////////////////////////////////////
-// Support
-///////////////////////////////////////////////////////////////////////////////
-
-/**
- * Structure mapping Skia xfermodes to OpenGL blending factors.
- */
-struct Blender {
-    SkXfermode::Mode mode;
-    GLenum src;
-    GLenum dst;
-}; // struct Blender
-
-///////////////////////////////////////////////////////////////////////////////
 // Renderer
 ///////////////////////////////////////////////////////////////////////////////
 
+#define REQUIRED_TEXTURE_UNITS_COUNT 3
+
 /**
  * OpenGL renderer used to draw accelerated 2D graphics. The API is a
  * simplified version of Skia's Canvas API.
@@ -294,7 +283,7 @@
     /**
      * Binds the specified texture with the specified wrap modes.
      */
-    inline void bindTexture(GLuint texture, GLenum wrapS, GLenum wrapT);
+    inline void bindTexture(GLuint texture, GLenum wrapS, GLenum wrapT, GLuint textureUnit = 0);
 
     /**
      * Enable or disable blending as necessary. This function sets the appropriate
@@ -312,7 +301,7 @@
      *
      * @return true If the specified program was already in use, false otherwise.
      */
-    inline bool useProgram(const sp<Program>& program);
+    inline bool useProgram(Program* program);
 
     // Dimensions of the drawing surface
     int mWidth, mHeight;
@@ -331,17 +320,14 @@
     sp<Snapshot> mSnapshot;
 
     // Shaders
-    sp<Program> mCurrentProgram;
-    sp<DrawColorProgram> mDrawColorProgram;
-    sp<DrawTextureProgram> mDrawTextureProgram;
-    sp<DrawTextProgram> mDrawTextProgram;
-    sp<DrawLinearGradientProgram> mDrawLinearGradientProgram;
+    Program* mCurrentProgram;
 
     // Used to draw textured quads
     TextureVertex mMeshVertices[4];
 
     // Current texture state
-    GLuint mLastTexture;
+    GLuint mLastTexture[REQUIRED_TEXTURE_UNITS_COUNT];
+    GLint mMaxTextureUnits;
 
     // Last known blend state
     bool mBlend;
diff --git a/libs/hwui/Program.cpp b/libs/hwui/Program.cpp
index 86fc154..dbae38e 100644
--- a/libs/hwui/Program.cpp
+++ b/libs/hwui/Program.cpp
@@ -27,16 +27,6 @@
 
 #define SHADER_SOURCE(name, source) const char* name = #source
 
-#include "shaders/drawColor.frag"
-
-#include "shaders/drawTexture.vert"
-#include "shaders/drawTexture.frag"
-
-#include "shaders/drawText.frag"
-
-#include "shaders/drawLinearGradient.vert"
-#include "shaders/drawLinearGradient.frag"
-
 ///////////////////////////////////////////////////////////////////////////////
 // Base program
 ///////////////////////////////////////////////////////////////////////////////
@@ -65,6 +55,10 @@
     }
 
     mUse = false;
+
+    position = addAttrib("position");
+    color = addUniform("color");
+    transform = addUniform("transform");
 }
 
 Program::~Program() {
@@ -73,15 +67,6 @@
     glDeleteProgram(id);
 }
 
-void Program::use() {
-    glUseProgram(id);
-    mUse = true;
-}
-
-void Program::remove() {
-    mUse = false;
-}
-
 int Program::addAttrib(const char* name) {
     int slot = glGetAttribLocation(id, name);
     attributes.add(name, slot);
@@ -89,7 +74,11 @@
 }
 
 int Program::getAttrib(const char* name) {
-    return attributes.valueFor(name);
+    ssize_t index = attributes.indexOfKey(name);
+    if (index >= 0) {
+        return attributes.valueAt(index);
+    }
+    return addAttrib(name);
 }
 
 int Program::addUniform(const char* name) {
@@ -99,7 +88,11 @@
 }
 
 int Program::getUniform(const char* name) {
-    return uniforms.valueFor(name);
+    ssize_t index = uniforms.indexOfKey(name);
+    if (index >= 0) {
+        return uniforms.valueAt(index);
+    }
+    return addUniform(name);
 }
 
 GLuint Program::buildShader(const char* source, GLenum type) {
@@ -121,28 +114,7 @@
     return shader;
 }
 
-///////////////////////////////////////////////////////////////////////////////
-// Draw color
-///////////////////////////////////////////////////////////////////////////////
-
-DrawColorProgram::DrawColorProgram():
-        Program(gDrawTextureVertexShader, gDrawColorFragmentShader) {
-    getAttribsAndUniforms();
-}
-
-DrawColorProgram::DrawColorProgram(const char* vertex, const char* fragment):
-        Program(vertex, fragment) {
-    getAttribsAndUniforms();
-}
-
-void DrawColorProgram::getAttribsAndUniforms() {
-    position = addAttrib("position");
-    texCoords = addAttrib("texCoords");
-    color = addUniform("color");
-    transform = addUniform("transform");
-}
-
-void DrawColorProgram::set(const mat4& projectionMatrix, const mat4& modelViewMatrix,
+void Program::set(const mat4& projectionMatrix, const mat4& modelViewMatrix,
         const mat4& transformMatrix) {
     mat4 t(projectionMatrix);
     t.multiply(transformMatrix);
@@ -151,70 +123,17 @@
     glUniformMatrix4fv(transform, 1, GL_FALSE, &t.data[0]);
 }
 
-void DrawColorProgram::use() {
-    Program::use();
+void Program::use() {
+    glUseProgram(id);
+    mUse = true;
+
     glEnableVertexAttribArray(position);
-    glEnableVertexAttribArray(texCoords);
 }
 
-void DrawColorProgram::remove() {
-    Program::remove();
+void Program::remove() {
+    mUse = false;
+
     glDisableVertexAttribArray(position);
-    glDisableVertexAttribArray(texCoords);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// Draw texture
-///////////////////////////////////////////////////////////////////////////////
-
-DrawTextureProgram::DrawTextureProgram():
-        DrawColorProgram(gDrawTextureVertexShader, gDrawTextureFragmentShader) {
-    sampler = addUniform("sampler");
-}
-
-DrawTextureProgram::DrawTextureProgram(const char* vertex, const char* fragment):
-        DrawColorProgram(vertex, fragment) {
-    sampler = addUniform("sampler");
-}
-
-void DrawTextureProgram::use() {
-    DrawColorProgram::use();
-    glUniform1i(sampler, 0);
-}
-
-void DrawTextureProgram::remove() {
-    DrawColorProgram::remove();
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// Draw text
-///////////////////////////////////////////////////////////////////////////////
-
-DrawTextProgram::DrawTextProgram():
-        DrawTextureProgram(gDrawTextureVertexShader, gDrawTextFragmentShader) {
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// Draw linear gradient
-///////////////////////////////////////////////////////////////////////////////
-
-DrawLinearGradientProgram::DrawLinearGradientProgram():
-        DrawColorProgram(gDrawLinearGradientVertexShader, gDrawLinearGradientFragmentShader) {
-    gradient = addUniform("gradient");
-    gradientLength = addUniform("gradientLength");
-    sampler = addUniform("sampler");
-    start = addUniform("start");
-    screenSpace = addUniform("screenSpace");
-}
-
-void DrawLinearGradientProgram::use() {
-    DrawColorProgram::use();
-    glActiveTexture(GL_TEXTURE0);
-    glUniform1i(sampler, 0);
-}
-
-void DrawLinearGradientProgram::remove() {
-    DrawColorProgram::remove();
 }
 
 }; // namespace uirenderer
diff --git a/libs/hwui/Program.h b/libs/hwui/Program.h
index 2cdd905..6531c74 100644
--- a/libs/hwui/Program.h
+++ b/libs/hwui/Program.h
@@ -21,7 +21,6 @@
 #include <GLES2/gl2ext.h>
 
 #include <utils/KeyedVector.h>
-#include <utils/RefBase.h>
 
 #include "Matrix.h"
 
@@ -32,7 +31,7 @@
  * A program holds a vertex and a fragment shader. It offers several utility
  * methods to query attributes and uniforms.
  */
-class Program: public LightRefBase<Program> {
+class Program {
 public:
     /**
      * Creates a new program with the specified vertex and fragment
@@ -70,6 +69,28 @@
         return mUse;
     }
 
+    /**
+     * Binds the program with the specified projection, modelView and
+     * transform matrices.
+     */
+    void set(const mat4& projectionMatrix, const mat4& modelViewMatrix,
+             const mat4& transformMatrix);
+
+    /**
+     * Name of the position attribute.
+     */
+    int position;
+
+    /**
+     * Name of the color uniform.
+     */
+    int color;
+
+    /**
+     * Name of the transform uniform.
+     */
+    int transform;
+
 protected:
     /**
      * Adds an attribute with the specified name.
@@ -107,146 +128,6 @@
     bool mUse;
 }; // class Program
 
-/**
- * Program used to draw vertices with a simple color. The shaders must
- * specify the following attributes:
- *      vec4 position, position of the vertex
- *      vec4 color, RGBA color of the vertex
- *
- * And the following uniforms:
- *      mat4 projection, the projection matrix
- *      mat4 modelView, the modelView matrix
- *      mat4 transform, an extra transformation matrix
- */
-class DrawColorProgram: public Program {
-public:
-    DrawColorProgram();
-    DrawColorProgram(const char* vertex, const char* fragment);
-
-    /**
-     * Binds the program with the specified projection, modelView and
-     * transform matrices.
-     */
-    void set(const mat4& projectionMatrix, const mat4& modelViewMatrix,
-             const mat4& transformMatrix);
-
-    /**
-     * Binds this program to the GL context.
-     */
-    virtual void use();
-
-    /**
-     * Marks this program as unused. This will not unbind
-     * the program from the GL context.
-     */
-    virtual void remove();
-
-    /**
-     * Name of the position attribute.
-     */
-    int position;
-
-    /**
-     * Name of the texture coordinates attribute.
-     */
-    int texCoords;
-
-    /**
-     * Name of the color uniform.
-     */
-    int color;
-
-    /**
-     * Name of the transform uniform.
-     */
-    int transform;
-
-protected:
-    void getAttribsAndUniforms();
-};
-
-/**
- * Program used to draw textured vertices. In addition to everything that the
- * DrawColorProgram supports, the following two attributes must be specified:
- *      sampler2D sampler, the texture sampler
- *      vec2 texCoords, the texture coordinates of the vertex
- */
-class DrawTextureProgram: public DrawColorProgram {
-public:
-    DrawTextureProgram();
-    DrawTextureProgram(const char* vertex, const char* fragment);
-
-    /**
-     * Binds this program to the GL context.
-     */
-    virtual void use();
-
-    /**
-     * Marks this program as unused. This will not unbind
-     * the program from the GL context.
-     */
-    virtual void remove();
-
-    /**
-     * Name of the texture sampler uniform.
-     */
-    int sampler;
-};
-
-class DrawTextProgram: public DrawTextureProgram {
-public:
-    DrawTextProgram();
-};
-
-/**
- * Program used to draw linear gradients. In addition to everything that the
- * DrawColorProgram supports, the following two attributes must be specified:
- *      vec2 gradient, the vector describing the linear gradient
- *      float gradientLength, the invert of the magnitude of the gradient vector
- *      sampler2D sampler, the texture sampler
- */
-class DrawLinearGradientProgram: public DrawColorProgram {
-public:
-    DrawLinearGradientProgram();
-
-    /**
-     * Binds this program to the GL context.
-     */
-    virtual void use();
-
-    /**
-     * Marks this program as unused. This will not unbind
-     * the program from the GL context.
-     */
-    virtual void remove();
-
-    /**
-     * Name of the matrix used to compute the screen space coordinates
-     * of the vertices.
-     */
-    int screenSpace;
-
-    /**
-     * Name of the linear gradient start point.
-     */
-    int start;
-
-    /**
-     * Name of the linear gradient vector.
-     */
-    int gradient;
-
-    /**
-     * Name of the inverse of linear gradient vector's magnitude.
-     */
-    int gradientLength;
-
-    /**
-     * Name of the texture sampler uniform.
-     */
-    int sampler;
-};
-
 }; // namespace uirenderer
 }; // namespace android
 
diff --git a/libs/hwui/ProgramCache.cpp b/libs/hwui/ProgramCache.cpp
index 5a89eb6..c9e2d2e 100644
--- a/libs/hwui/ProgramCache.cpp
+++ b/libs/hwui/ProgramCache.cpp
@@ -40,6 +40,9 @@
         "uniform vec2 gradient;\n"
         "uniform vec2 gradientStart;\n"
         "uniform mat4 screenSpace;\n";
+const char* gVS_Header_Uniforms_HasBitmap =
+        "uniform mat4 textureTransform;\n"
+        "uniform vec2 textureDimension;\n";
 const char* gVS_Header_Varyings_HasTexture =
         "varying vec2 outTexCoords;\n";
 const char* gVS_Header_Varyings_HasBitmap =
@@ -53,6 +56,9 @@
 const char* gVS_Main_OutGradientIndex =
         "    vec4 location = screenSpace * position;\n"
         "    index = dot(location.xy - gradientStart, gradient) * gradientLength;\n";
+const char* gVS_Main_OutBitmapTexCoords =
+        "    vec4 bitmapCoords = textureTransform * position;\n"
+        "    outBitmapTexCoords = bitmapCoords.xy * textureDimension;\n";
 const char* gVS_Main_Position =
         "    gl_Position = transform * position;\n";
 const char* gVS_Footer =
@@ -97,12 +103,18 @@
         "    vec4 gradientColor = texture2D(gradientSampler, vec2(index, 0.5));\n";
 const char* gFS_Main_FetchBitmap =
         "    vec4 bitmapColor = texture2D(bitmapSampler, outBitmapTexCoords);\n";
+const char* gFS_Main_FetchBitmapNpot =
+        "    vec4 bitmapColor = texture2D(bitmapSampler, wrap(outBitmapTexCoords));\n";
 const char* gFS_Main_BlendShadersBG =
         "    fragColor = blendShaders(bitmapColor, gradientColor)";
 const char* gFS_Main_BlendShadersGB =
         "    fragColor = blendShaders(gradientColor, bitmapColor)";
 const char* gFS_Main_BlendShaders_Modulate =
         " * fragColor.a;\n";
+const char* gFS_Main_GradientShader_Modulate =
+        "    fragColor = gradientColor * fragColor.a;\n";
+const char* gFS_Main_BitmapShader_Modulate =
+        "    fragColor = bitmapColor * fragColor.a;\n";
 const char* gFS_Main_FragColor =
         "    gl_FragColor = fragColor;\n";
 const char* gFS_Main_ApplyColorOp[4] = {
@@ -204,7 +216,7 @@
 String8 ProgramCache::generateVertexShader(const ProgramDescription& description) {
     // Add attributes
     String8 shader(gVS_Header_Attributes);
-    if (description.hasTexture || description.hasBitmap) {
+    if (description.hasTexture) {
         shader.append(gVS_Header_Attributes_TexCoords);
     }
     // Uniforms
@@ -212,6 +224,9 @@
     if (description.hasGradient) {
         shader.append(gVS_Header_Uniforms_HasGradient);
     }
+    if (description.hasBitmap) {
+        shader.append(gVS_Header_Uniforms_HasBitmap);
+    }
     // Varyings
     if (description.hasTexture) {
         shader.append(gVS_Header_Varyings_HasTexture);
@@ -231,6 +246,9 @@
         if (description.hasGradient) {
             shader.append(gVS_Main_OutGradientIndex);
         }
+        if (description.hasBitmap) {
+            shader.append(gVS_Main_OutBitmapTexCoords);
+        }
         // Output transformed position
         shader.append(gVS_Main_Position);
     }
@@ -278,6 +296,9 @@
     if (description.colorOp == ProgramDescription::kColorBlend) {
         generatePorterDuffBlend(shader, "blendColors", description.colorMode);
     }
+    if (description.isBitmapNpot) {
+        generateTextureWrap(shader, description.bitmapWrapS, description.bitmapWrapT);
+    }
 
     // Begin the shader
     shader.append(gFS_Main); {
@@ -295,7 +316,11 @@
             shader.append(gFS_Main_FetchGradient);
         }
         if (description.hasBitmap) {
-            shader.append(gFS_Main_FetchBitmap);
+            if (!description.isBitmapNpot) {
+                shader.append(gFS_Main_FetchBitmap);
+            } else {
+                shader.append(gFS_Main_FetchBitmapNpot);
+            }
         }
         // Case when we have two shaders set
         if (description.hasGradient && description.hasBitmap) {
@@ -305,6 +330,12 @@
                 shader.append(gFS_Main_BlendShadersGB);
             }
             shader.append(gFS_Main_BlendShaders_Modulate);
+        } else {
+            if (description.hasGradient) {
+                shader.append(gFS_Main_GradientShader_Modulate);
+            } else if (description.hasBitmap) {
+                shader.append(gFS_Main_BitmapShader_Modulate);
+            }
         }
         // Apply the color op if needed
         shader.append(gFS_Main_ApplyColorOp[description.colorOp]);
@@ -328,5 +359,37 @@
     shader.append("}\n");
 }
 
+void ProgramCache::generateTextureWrap(String8& shader, GLenum wrapS, GLenum wrapT) {
+    shader.append("\nvec2 wrap(vec2 texCoords) {\n");
+    if (wrapS == GL_MIRRORED_REPEAT) {
+        shader.append("    float xMod2 = mod(texCoords.x, 2.0);\n");
+        shader.append("    if (xMod2 > 1.0) xMod2 = 2.0 - xMod2;\n");
+    }
+    if (wrapT == GL_MIRRORED_REPEAT) {
+        shader.append("    float yMod2 = mod(texCoords.y, 2.0);\n");
+        shader.append("    if (yMod2 > 1.0) yMod2 = 2.0 - yMod2;\n");
+    }
+    shader.append("    return vec2(");
+    switch (wrapS) {
+        case GL_REPEAT:
+            shader.append("mod(texCoords.x, 1.0)");
+            break;
+        case GL_MIRRORED_REPEAT:
+            shader.append("xMod2");
+            break;
+    }
+    shader.append(", ");
+    switch (wrapT) {
+        case GL_REPEAT:
+            shader.append("mod(texCoords.y, 1.0)");
+            break;
+        case GL_MIRRORED_REPEAT:
+            shader.append("yMod2");
+            break;
+    }
+    shader.append(");\n");
+    shader.append("}\n");
+}
+
 }; // namespace uirenderer
 }; // namespace android
diff --git a/libs/hwui/ProgramCache.h b/libs/hwui/ProgramCache.h
index 7f2f5fa..5a6ec33 100644
--- a/libs/hwui/ProgramCache.h
+++ b/libs/hwui/ProgramCache.h
@@ -20,6 +20,8 @@
 #include <utils/KeyedVector.h>
 #include <utils/Log.h>
 
+#include <GLES2/gl2.h>
+
 #include <SkXfermode.h>
 
 #include "Program.h"
@@ -32,7 +34,7 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 // Debug
-#define DEBUG_PROGRAM_CACHE 0
+#define DEBUG_PROGRAM_CACHE 1
 
 // Debug
 #if DEBUG_PROGRAM_CACHE
@@ -49,12 +51,19 @@
 #define PROGRAM_KEY_COLOR_MATRIX 0x20
 #define PROGRAM_KEY_COLOR_LIGHTING 0x40
 #define PROGRAM_KEY_COLOR_BLEND 0x80
+#define PROGRAM_KEY_BITMAP_NPOT 0x100
+
+#define PROGRAM_KEY_BITMAP_WRAPS_MASK 0x600
+#define PROGRAM_KEY_BITMAP_WRAPT_MASK 0x1800
 
 // Support only the 12 Porter-Duff modes for now
 #define PROGRAM_MAX_XFERMODE 0xC
 #define PROGRAM_XFERMODE_SHADER_SHIFT 24
 #define PROGRAM_XFERMODE_COLOR_OP_SHIFT 20
 
+#define PROGRAM_BITMAP_WRAPS_SHIFT 9
+#define PROGRAM_BITMAP_WRAPT_SHIFT 11
+
 ///////////////////////////////////////////////////////////////////////////////
 // Types
 ///////////////////////////////////////////////////////////////////////////////
@@ -80,7 +89,9 @@
 
     ProgramDescription():
         hasTexture(false), hasAlpha8Texture(false),
-        hasBitmap(false), hasGradient(false), shadersMode(SkXfermode::kClear_Mode),
+        hasBitmap(false), isBitmapNpot(false), hasGradient(false),
+        shadersMode(SkXfermode::kClear_Mode), isBitmapFirst(false),
+        bitmapWrapS(GL_CLAMP_TO_EDGE), bitmapWrapT(GL_CLAMP_TO_EDGE),
         colorOp(kColorNone), colorMode(SkXfermode::kClear_Mode) {
     }
 
@@ -90,19 +101,41 @@
 
     // Shaders
     bool hasBitmap;
+    bool isBitmapNpot;
     bool hasGradient;
     SkXfermode::Mode shadersMode;
     bool isBitmapFirst;
+    GLenum bitmapWrapS;
+    GLenum bitmapWrapT;
 
     // Color operations
     int colorOp;
     SkXfermode::Mode colorMode;
 
+    inline uint32_t getEnumForWrap(GLenum wrap) const {
+        switch (wrap) {
+            case GL_CLAMP_TO_EDGE:
+                return 0;
+            case GL_REPEAT:
+                return 1;
+            case GL_MIRRORED_REPEAT:
+                return 2;
+        }
+        return 0;
+    }
+
     programid key() const {
         programid key = 0;
         if (hasTexture) key |= PROGRAM_KEY_TEXTURE;
         if (hasAlpha8Texture) key |= PROGRAM_KEY_A8_TEXTURE;
-        if (hasBitmap) key |= PROGRAM_KEY_BITMAP;
+        if (hasBitmap) {
+            key |= PROGRAM_KEY_BITMAP;
+            if (isBitmapNpot) {
+                key |= PROGRAM_KEY_BITMAP_NPOT;
+                key |= getEnumForWrap(bitmapWrapS) << PROGRAM_BITMAP_WRAPS_SHIFT;
+                key |= getEnumForWrap(bitmapWrapT) << PROGRAM_BITMAP_WRAPT_SHIFT;
+            }
+        }
         if (hasGradient) key |= PROGRAM_KEY_GRADIENT;
         if (isBitmapFirst) key  |= PROGRAM_KEY_BITMAP_FIRST;
         if (hasBitmap && hasGradient) {
@@ -144,6 +177,7 @@
     String8 generateVertexShader(const ProgramDescription& description);
     String8 generateFragmentShader(const ProgramDescription& description);
     void generatePorterDuffBlend(String8& shader, const char* name, SkXfermode::Mode mode);
+    void generateTextureWrap(String8& shader, GLenum wrapS, GLenum wrapT);
 
     KeyedVector<programid, Program*> mCache;
 
diff --git a/libs/hwui/shaders/drawColor.frag b/libs/hwui/shaders/drawColor.frag
deleted file mode 100644
index 1d6cb8b..0000000
--- a/libs/hwui/shaders/drawColor.frag
+++ /dev/null
@@ -1,11 +0,0 @@
-SHADER_SOURCE(gDrawColorFragmentShader,
-
-precision mediump float;
-
-uniform vec4 color;
-
-void main(void) {
-    gl_FragColor = color;
-}
-
-);
diff --git a/libs/hwui/shaders/drawLinearGradient.frag b/libs/hwui/shaders/drawLinearGradient.frag
deleted file mode 100644
index 469c662..0000000
--- a/libs/hwui/shaders/drawLinearGradient.frag
+++ /dev/null
@@ -1,14 +0,0 @@
-SHADER_SOURCE(gDrawLinearGradientFragmentShader,
-
-precision mediump float;
-
-varying float index;
-
-uniform vec4 color;
-uniform sampler2D sampler;
-
-void main(void) {
-    gl_FragColor = texture2D(sampler, vec2(index, 0.5)) * color;
-}
-
-);
diff --git a/libs/hwui/shaders/drawLinearGradient.vert b/libs/hwui/shaders/drawLinearGradient.vert
deleted file mode 100644
index d2f857d..0000000
--- a/libs/hwui/shaders/drawLinearGradient.vert
+++ /dev/null
@@ -1,20 +0,0 @@
-SHADER_SOURCE(gDrawLinearGradientVertexShader,
-
-attribute vec4 position;
-
-uniform mat4 transform;
-uniform float gradientLength;
-uniform vec2 gradient;
-uniform vec2 start;
-uniform mat4 screenSpace;
-
-varying float index;
-
-void main(void) {
-    vec4 location = screenSpace * position;
-    index = dot(location.xy - start, gradient) * gradientLength;
-
-    gl_Position = transform * position;
-}
-
-);
diff --git a/libs/hwui/shaders/drawText.frag b/libs/hwui/shaders/drawText.frag
deleted file mode 100644
index 49532c7..0000000
--- a/libs/hwui/shaders/drawText.frag
+++ /dev/null
@@ -1,14 +0,0 @@
-SHADER_SOURCE(gDrawTextFragmentShader,
-
-precision mediump float;
-
-varying vec2 outTexCoords;
-
-uniform vec4 color;
-uniform sampler2D sampler;
-
-void main(void) {
-    gl_FragColor = color * texture2D(sampler, outTexCoords).a;
-}
-
-);
diff --git a/libs/hwui/shaders/drawTexture.frag b/libs/hwui/shaders/drawTexture.frag
deleted file mode 100644
index 8390d8e..0000000
--- a/libs/hwui/shaders/drawTexture.frag
+++ /dev/null
@@ -1,14 +0,0 @@
-SHADER_SOURCE(gDrawTextureFragmentShader,
-
-precision mediump float;
-
-varying vec2 outTexCoords;
-
-uniform vec4 color;
-uniform sampler2D sampler;
-
-void main(void) {
-    gl_FragColor = texture2D(sampler, outTexCoords) * color;
-}
-
-);
diff --git a/libs/hwui/shaders/drawTexture.vert b/libs/hwui/shaders/drawTexture.vert
deleted file mode 100644
index 240aebf..0000000
--- a/libs/hwui/shaders/drawTexture.vert
+++ /dev/null
@@ -1,15 +0,0 @@
-SHADER_SOURCE(gDrawTextureVertexShader,
-
-attribute vec4 position;
-attribute vec2 texCoords;
-
-uniform mat4 transform;
-
-varying vec2 outTexCoords;
-
-void main(void) {
-    outTexCoords = texCoords;
-    gl_Position = transform * position;
-}
-
-);