diff --git a/gpu/include/GrGLDefines.h b/gpu/include/GrGLDefines.h
index 73c2a71..dcacb77 100644
--- a/gpu/include/GrGLDefines.h
+++ b/gpu/include/GrGLDefines.h
@@ -299,6 +299,7 @@
 /* Shaders */
 #define GR_GL_FRAGMENT_SHADER                  0x8B30
 #define GR_GL_VERTEX_SHADER                    0x8B31
+#define GR_GL_GEOMETRY_SHADER                  0x8DD9
 #define GR_GL_MAX_VERTEX_ATTRIBS               0x8869
 #define GR_GL_MAX_VERTEX_UNIFORM_VECTORS       0x8DFB
 #define GR_GL_MAX_VARYING_VECTORS              0x8DFC
diff --git a/gpu/include/GrGLInterface.h b/gpu/include/GrGLInterface.h
index 2687956..8271dcb 100644
--- a/gpu/include/GrGLInterface.h
+++ b/gpu/include/GrGLInterface.h
@@ -25,16 +25,22 @@
  */
 
 typedef uint32_t GrGLVersion;
+typedef uint32_t GrGLSLVersion;
 
-#define GR_GL_VER(major, minor) (((int)(major) << 16) | ((int)(minor)))
+#define GR_GL_VER(major, minor) ((static_cast<int>(major) << 16) | \
+                                 static_cast<int>(minor))
+#define GR_GLSL_VER(major, minor) ((static_cast<int>(major) << 16) | \
+                                   static_cast<int>(minor))
 
 // these variants assume caller already has a string from glGetString()
 GrGLVersion GrGLGetVersionFromString(const char* versionString);
+GrGLSLVersion GrGLGetGLSLVersionFromString(const char* versionString);
 bool GrGLHasExtensionFromString(const char* ext, const char* extensionString);
 
 // these variants call glGetString()
 bool GrGLGetString(const GrGLInterface*, const char* ext);
 GrGLVersion GrGLGetVersion(const GrGLInterface*);
+GrGLSLVersion GrGLGetGLSLVersion(const GrGLInterface*);
 
 ////////////////////////////////////////////////////////////////////////////////
 
diff --git a/gpu/src/GrDrawTarget.cpp b/gpu/src/GrDrawTarget.cpp
index 51e6fdd..79b3da8 100644
--- a/gpu/src/GrDrawTarget.cpp
+++ b/gpu/src/GrDrawTarget.cpp
@@ -1076,6 +1076,7 @@
     GrPrintf("HW AA Lines Support         : %s\n", gNY[fHWAALineSupport]);
     GrPrintf("Shader Support              : %s\n", gNY[fShaderSupport]);
     GrPrintf("Shader Derivative Support   : %s\n", gNY[fShaderDerivativeSupport]);
+    GrPrintf("Geometry Shader Support     : %s\n", gNY[fGeometryShaderSupport]);
     GrPrintf("FSAA Support                : %s\n", gNY[fFSAASupport]);
     GrPrintf("Dual Source Blending Support: %s\n", gNY[fDualSourceBlendingSupport]);
     GrPrintf("Buffer Lock Support         : %s\n", gNY[fBufferLockSupport]);
diff --git a/gpu/src/GrDrawTarget.h b/gpu/src/GrDrawTarget.h
index 81d0b2b..a1667e4 100644
--- a/gpu/src/GrDrawTarget.h
+++ b/gpu/src/GrDrawTarget.h
@@ -49,6 +49,7 @@
         bool fHWAALineSupport           : 1;
         bool fShaderSupport             : 1;
         bool fShaderDerivativeSupport   : 1;
+        bool fGeometryShaderSupport     : 1;
         bool fFSAASupport               : 1;
         bool fDualSourceBlendingSupport : 1;
         bool fBufferLockSupport         : 1;
diff --git a/gpu/src/GrGLInterface.cpp b/gpu/src/GrGLInterface.cpp
index 0b433d1..70dd019 100644
--- a/gpu/src/GrGLInterface.cpp
+++ b/gpu/src/GrGLInterface.cpp
@@ -20,7 +20,11 @@
 #endif
 
 GrGLVersion GrGLGetVersionFromString(const char* versionString) {
-    GrAssert(versionString);
+    if (NULL == versionString) {
+        GrAssert(!"NULL GL version string.");
+        return 0;
+    }
+
     int major, minor;
 
     int n = sscanf(versionString, "%d.%d", &major, &minor);
@@ -43,6 +47,26 @@
     return 0;
 }
 
+GrGLSLVersion GrGLGetGLSLVersionFromString(const char* versionString) {
+    if (NULL == versionString) {
+        GrAssert(!"NULL GLSL version string.");
+        return 0;
+    }
+
+    int major, minor;
+
+    int n = sscanf(versionString, "%d.%d", &major, &minor);
+    if (2 == n) {
+        return GR_GLSL_VER(major, minor);
+    }
+    
+    n = sscanf(versionString, "OpenGL ES GLSL ES %d.%d", &major, &minor);
+    if (2 == n) {
+        return GR_GLSL_VER(major, minor);
+    }
+    return 0;
+}
+
 bool GrGLHasExtensionFromString(const char* ext, const char* extensionString) {
     int extLength = strlen(ext);
 
@@ -72,6 +96,12 @@
     return GrGLGetVersionFromString((const char*) v);
 }
 
+GrGLSLVersion GrGLGetGLSLVersion(const GrGLInterface* gl) {
+    const GrGLubyte* v;
+    GR_GL_CALL_RET(gl, v, GetString(GR_GL_SHADING_LANGUAGE_VERSION));
+    return GrGLGetGLSLVersionFromString((const char*) v);
+}
+
 GrGLInterface::GrGLInterface() {
     fBindingsExported = (GrGLBinding)0;
     fNPOTRenderTargetSupport = kProbe_GrGLCapability;
diff --git a/gpu/src/GrGLProgram.cpp b/gpu/src/GrGLProgram.cpp
index 015be61..cbe2f42 100644
--- a/gpu/src/GrGLProgram.cpp
+++ b/gpu/src/GrGLProgram.cpp
@@ -47,18 +47,29 @@
     ShaderCodeSegments() 
     : fVSUnis(gVarsPerBlock)
     , fVSAttrs(gVarsPerBlock)
-    , fVaryings(gVarsPerBlock)
+    , fVSOutputs(gVarsPerBlock)
+    , fGSInputs(gVarsPerBlock)
+    , fGSOutputs(gVarsPerBlock)
+    , fFSInputs(gVarsPerBlock)
     , fFSUnis(gVarsPerBlock)
-    , fFSOutputs(gMaxFSOutputs) {}
+    , fFSOutputs(gMaxFSOutputs)
+    , fUsesGS(false) {}
     GrStringBuilder fHeader; // VS+FS, GLSL version, etc
     VarArray        fVSUnis;
     VarArray        fVSAttrs;
-    VarArray        fVaryings;
+    VarArray        fVSOutputs;
+    VarArray        fGSInputs;
+    VarArray        fGSOutputs;
+    VarArray        fFSInputs;
+    GrStringBuilder fGSHeader; // layout qualifiers specific to GS
     VarArray        fFSUnis;
     VarArray        fFSOutputs;
     GrStringBuilder fFSFunctions;
     GrStringBuilder fVSCode;
+    GrStringBuilder fGSCode;
     GrStringBuilder fFSCode;
+
+    bool            fUsesGS;
 };
 
 
@@ -148,21 +159,11 @@
     s->appendS32(stage);
 }
 
-inline void stage_varying_name(int stage, GrStringBuilder* s) {
-    *s = "vStage";
-    s->appendS32(stage);
-}
-
 inline void radial2_param_name(int stage, GrStringBuilder* s) {
     *s = "uRadial2Params";
     s->appendS32(stage);
 }
 
-inline void radial2_varying_name(int stage, GrStringBuilder* s) {
-    *s = "vB";
-    s->appendS32(stage);
-}
-
 inline void convolve_param_names(int stage, GrStringBuilder* k, GrStringBuilder* i) {
     *k = "uKernel";
     k->appendS32(stage);
@@ -372,12 +373,65 @@
         case GrGLProgram::k130_GLSLVersion:
             GrAssert(!gl->supportsES());
             return "#version 130\n";
+        case GrGLProgram::k150_GLSLVersion:
+            GrAssert(!gl->supportsES());
+            return "#version 150\n";
         default:
             GrCrash("Unknown GL version.");
             return ""; // suppress warning
     }
 }
 
+// Adds a var that is computed in the VS and read in FS.
+// If there is a GS it will just pass it through.
+void append_varying(GrGLShaderVar::Type type,
+                    const char* name,
+                    ShaderCodeSegments* segments,
+                    const char** vsOutName = NULL,
+                    const char** fsInName = NULL) {
+    segments->fVSOutputs.push_back();
+    segments->fVSOutputs.back().setType(type);
+    segments->fVSOutputs.back().accessName()->printf("v%s", name);
+    if (vsOutName) {
+        *vsOutName = segments->fVSOutputs.back().getName().c_str();
+    }
+    // input to FS comes either from VS or GS
+    const GrStringBuilder* fsName;
+    if (segments->fUsesGS) {
+        // if we have a GS take each varying in as an array
+        // and output as non-array.
+        segments->fGSInputs.push_back();
+        segments->fGSInputs.back().setType(type);
+        segments->fGSInputs.back().setUnsizedArray();
+        *segments->fGSInputs.back().accessName() =
+            segments->fVSOutputs.back().getName();
+        segments->fGSOutputs.push_back();
+        segments->fGSOutputs.back().setType(type);
+        segments->fGSOutputs.back().accessName()->printf("g%s", name);
+        fsName = segments->fGSOutputs.back().accessName();
+    } else {
+        fsName = segments->fVSOutputs.back().accessName();
+    }
+    segments->fFSInputs.push_back();
+    segments->fFSInputs.back().setType(type);
+    segments->fFSInputs.back().setName(*fsName);
+    if (fsInName) {
+        *fsInName = fsName->c_str();
+    }
+}
+
+// version of above that adds a stage number to the
+// the var name (for uniqueness)
+void append_varying(GrGLShaderVar::Type type,
+                    const char* name,
+                    int stageNum,
+                    ShaderCodeSegments* segments,
+                    const char** vsOutName = NULL,
+                    const char** fsInName = NULL) {
+    GrStringBuilder nameWithStage(name);
+    nameWithStage.appendS32(stageNum);
+    append_varying(type, nameWithStage.c_str(), segments, vsOutName, fsInName);
+}
 }
 
 void GrGLProgram::genEdgeCoverage(const GrGLInterface* gl,
@@ -435,20 +489,21 @@
         }
         *coverageVar = "edgeAlpha";
     } else  if (layout & GrDrawTarget::kEdge_VertexLayoutBit) {
-        segments->fVaryings.push_back().set(GrGLShaderVar::kVec4f_Type, "vEdge");
+        const char *vsName, *fsName;
+        append_varying(GrGLShaderVar::kVec4f_Type, "Edge", segments, &vsName, &fsName);
         segments->fVSAttrs.push_back().set(GrGLShaderVar::kVec4f_Type, EDGE_ATTR_NAME);
-        segments->fVSCode.append("\tvEdge = " EDGE_ATTR_NAME ";\n");
+        segments->fVSCode.appendf("\t%s = " EDGE_ATTR_NAME ";\n", vsName);
         if (GrDrawTarget::kHairLine_EdgeType == fProgramDesc.fVertexEdgeType) {
-            segments->fFSCode.append("\tfloat edgeAlpha = abs(dot(vec3(gl_FragCoord.xy,1), vEdge.xyz));\n");
+            segments->fFSCode.appendf("\tfloat edgeAlpha = abs(dot(vec3(gl_FragCoord.xy,1), %s.xyz));\n", fsName);
         } else {
             GrAssert(GrDrawTarget::kHairQuad_EdgeType == fProgramDesc.fVertexEdgeType);
             // for now we know we're not in perspective, so we could compute this
             // per-quadratic rather than per pixel
-            segments->fFSCode.append("\tvec2 duvdx = dFdx(vEdge.xy);\n");
-            segments->fFSCode.append("\tvec2 duvdy = dFdy(vEdge.xy);\n");
-            segments->fFSCode.append("\tfloat dfdx = 2.0*vEdge.x*duvdx.x - duvdx.y;\n");
-            segments->fFSCode.append("\tfloat dfdy = 2.0*vEdge.x*duvdy.x - duvdy.y;\n");
-            segments->fFSCode.append("\tfloat edgeAlpha = (vEdge.x*vEdge.x - vEdge.y);\n");
+            segments->fFSCode.appendf("\tvec2 duvdx = dFdx(%s.xy);\n", fsName);
+            segments->fFSCode.appendf("\tvec2 duvdy = dFdy(%s.xy);\n", fsName);
+            segments->fFSCode.appendf("\tfloat dfdx = 2.0*%s.x*duvdx.x - duvdx.y;\n", fsName);
+            segments->fFSCode.appendf("\tfloat dfdy = 2.0*%s.x*duvdy.x - duvdy.y;\n", fsName);
+            segments->fFSCode.appendf("\tfloat edgeAlpha = (%s.x*%s.x - %s.y);\n", fsName, fsName, fsName);
             segments->fFSCode.append("\tedgeAlpha = sqrt(edgeAlpha*edgeAlpha / (dfdx*dfdx + dfdy*dfdy));\n");
             if (gl->supportsES()) {
                 segments->fHeader.printf("#extension GL_OES_standard_derivatives: enable\n");
@@ -472,7 +527,8 @@
             *name = "gl_FragColor";
             return false;
             break;
-        case GrGLProgram::k130_GLSLVersion:
+        case GrGLProgram::k130_GLSLVersion: // fallthru
+        case GrGLProgram::k150_GLSLVersion:
             *name = declared_color_output_name();
             fsOutputs->push_back().set(GrGLShaderVar::kVec4f_Type,
                                        declared_color_output_name());
@@ -486,6 +542,35 @@
 
 }
 
+void GrGLProgram::genGeometryShader(const GrGLInterface* gl,
+                                    GLSLVersion glslVersion,
+                                    ShaderCodeSegments* segments) const {
+#if GR_GL_EXPERIMENTAL_GS
+    if (fProgramDesc.fExperimentalGS) {
+        GrAssert(glslVersion >= k150_GLSLVersion);
+        segments->fGSHeader.append("layout(triangles) in;\n"
+                                   "layout(triangle_strip, max_vertices = 6) out;\n");
+        segments->fGSCode.append("void main() {\n"
+                                 "\tfor (int i = 0; i < 3; ++i) {\n"
+                                  "\t\tgl_Position = gl_in[i].gl_Position;\n");
+        if (this->fProgramDesc.fEmitsPointSize) {
+            segments->fGSCode.append("\t\tgl_PointSize = 1.0;\n");
+        }
+        GrAssert(segments->fGSInputs.count() == segments->fGSOutputs.count());
+        int count = segments->fGSInputs.count();
+        for (int i = 0; i < count; ++i) {
+            segments->fGSCode.appendf("\t\t%s = %s[i];\n",
+                                      segments->fGSOutputs[i].getName().c_str(),
+                                      segments->fGSInputs[i].getName().c_str());
+        }
+        segments->fGSCode.append("\t\tEmitVertex();\n"
+                                 "\t}\n"
+                                 "\tEndPrimitive();\n"
+                                 "}\n");
+    }
+#endif
+}
+
 bool GrGLProgram::genProgram(const GrGLInterface* gl,
                              GLSLVersion glslVersion,
                              GrGLProgram::CachedData* programData) const {
@@ -495,6 +580,10 @@
 
     programData->fUniLocations.reset();
 
+#if GR_GL_EXPERIMENTAL_GS
+    segments.fUsesGS = fProgramDesc.fExperimentalGS;
+#endif
+
     SkXfermode::Coeff colorCoeff, uniformCoeff;
     // The rest of transfer mode color filters have not been implemented
     if (fProgramDesc.fColorFilterXfermode < SkXfermode::kCoeffModesCnt) {
@@ -541,14 +630,14 @@
 
     if (needComputedColor) {
         switch (fProgramDesc.fColorType) {
-            case ProgramDesc::kAttribute_ColorType:
+            case ProgramDesc::kAttribute_ColorType: {
                 segments.fVSAttrs.push_back().set(GrGLShaderVar::kVec4f_Type,
                                                   COL_ATTR_NAME);
-                segments.fVaryings.push_back().set(GrGLShaderVar::kVec4f_Type,
-                                                   "vColor");
-                segments.fVSCode.append("\tvColor = " COL_ATTR_NAME ";\n");
-                inColor = "vColor";
-                break;
+                const char *vsName, *fsName;
+                append_varying(GrGLShaderVar::kVec4f_Type, "Color", &segments, &vsName, &fsName);
+                segments.fVSCode.appendf("\t%s = " COL_ATTR_NAME ";\n", vsName);
+                inColor = fsName;
+                } break;
             case ProgramDesc::kUniform_ColorType:
                 segments.fFSUnis.push_back().set(GrGLShaderVar::kVec4f_Type,
                                                  COL_UNI_NAME);
@@ -561,7 +650,8 @@
         }
     }
 
-    if (fProgramDesc.fEmitsPointSize){
+    // we output point size in the GS if present
+    if (fProgramDesc.fEmitsPointSize && !segments.fUsesGS){
         segments.fVSCode.append("\tgl_PointSize = 1.0;\n");
     }
 
@@ -738,9 +828,15 @@
     segments.fFSCode.append("}\n");
 
     ///////////////////////////////////////////////////////////////////////////
+    // insert GS
+#if GR_DEBUG
+    this->genGeometryShader(gl, glslVersion, &segments);
+#endif
+
+    ///////////////////////////////////////////////////////////////////////////
     // compile and setup attribs and unis
 
-    if (!CompileFSAndVS(gl, glslVersion, segments, programData)) {
+    if (!CompileShaders(gl, glslVersion, segments, programData)) {
         return false;
     }
 
@@ -758,22 +854,22 @@
 
 namespace {
 
-void expand_decls(const VarArray& unis,
-                  const GrGLInterface* gl,
-                  const char* prefix,
-                  GrStringBuilder* string) {
-    const int count = unis.count();
+inline void expand_decls(const VarArray& vars,
+                         const GrGLInterface* gl,
+                         const char* prefix,
+                         GrStringBuilder* string) {
+    const int count = vars.count();
     for (int i = 0; i < count; ++i) {
         string->append(prefix);
         string->append(" ");
-        unis[i].appendDecl(gl, string);
+        vars[i].appendDecl(gl, string);
         string->append(";\n");
     }
 }
 
-void print_shader(int stringCnt,
-                  const char** strings,
-                  int* stringLengths) {
+inline void print_shader(int stringCnt,
+                         const char** strings,
+                         int* stringLengths) {
     for (int i = 0; i < stringCnt; ++i) {
         if (NULL == stringLengths || stringLengths[i] < 0) {
             GrPrintf(strings[i]);
@@ -782,126 +878,124 @@
         }
     }
 }
+
+typedef SkTArray<const char*, true>         StrArray;
+#define PREALLOC_STR_ARRAY(N) SkSTArray<(N), const char*, true>
+
+typedef SkTArray<int, true>                 LengthArray;
+#define PREALLOC_LENGTH_ARRAY(N) SkSTArray<(N), int, true>
+
+// these shouldn't relocate
+typedef GrTAllocator<GrStringBuilder>       TempArray;
+#define PREALLOC_TEMP_ARRAY(N) GrSTAllocator<(N), GrStringBuilder>
+
+inline void append_string(const GrStringBuilder& str,
+                          StrArray* strings,
+                          LengthArray* lengths) {
+    int length = (int) str.size();
+    if (length) {
+        strings->push_back(str.c_str());
+        lengths->push_back(length);
+    }
+    GrAssert(strings->count() == lengths->count());
 }
 
-bool GrGLProgram::CompileFSAndVS(const GrGLInterface* gl,
+inline void append_decls(const VarArray& vars,
+                         const GrGLInterface* gl,
+                         const char* prefix,
+                         StrArray* strings,
+                         LengthArray* lengths,
+                         TempArray* temp) {
+    expand_decls(vars, gl, prefix, &temp->push_back());
+    append_string(temp->back(), strings, lengths);
+}
+
+}
+
+bool GrGLProgram::CompileShaders(const GrGLInterface* gl,
                                  GLSLVersion glslVersion,
                                  const ShaderCodeSegments& segments,
                                  CachedData* programData) {
+    enum { kPreAllocStringCnt = 8 };
 
-    static const int MAX_STRINGS = 6;
-    const char* strings[MAX_STRINGS];
-    int lengths[MAX_STRINGS];
-    int stringCnt = 0;
-    GrStringBuilder attrs;
-    GrStringBuilder varyings;
+    PREALLOC_STR_ARRAY(kPreAllocStringCnt)    strs;
+    PREALLOC_LENGTH_ARRAY(kPreAllocStringCnt) lengths;
+    PREALLOC_TEMP_ARRAY(kPreAllocStringCnt)   temps;
+
     GrStringBuilder unis;
-    GrStringBuilder fsOutputs;
+    GrStringBuilder inputs;
+    GrStringBuilder outputs;
 
     static const char* gVaryingPrefixes[2][2] = {{"varying", "varying"},
                                                  {"out", "in"}};
-    const char** varyingPrefixes = glslVersion == k120_GLSLVersion ?
+    const char** varyingPrefixes = k120_GLSLVersion == glslVersion ?
                                                     gVaryingPrefixes[0] :
                                                     gVaryingPrefixes[1];
-    const char* attributePrefix = glslVersion == k120_GLSLVersion ?
+    const char* attributePrefix = k120_GLSLVersion == glslVersion ?
                                                     "attribute" :
                                                     "in";
 
-    if (segments.fHeader.size()) {
-        strings[stringCnt] = segments.fHeader.c_str();
-        lengths[stringCnt] = segments.fHeader.size();
-        ++stringCnt;
-    }
-    expand_decls(segments.fVSUnis, gl, "uniform", &unis);
-    if (unis.size()) {
-        strings[stringCnt] = unis.c_str();
-        lengths[stringCnt] = unis.size();
-        ++stringCnt;
-    }
-    expand_decls(segments.fVSAttrs, gl, attributePrefix, &attrs);
-    if (attrs.size()) {
-        strings[stringCnt] = attrs.c_str();
-        lengths[stringCnt] = attrs.size();
-        ++stringCnt;
-    }
-    expand_decls(segments.fVaryings, gl, varyingPrefixes[0], &varyings);
-    if (varyings.size()) {
-        strings[stringCnt] = varyings.c_str();
-        lengths[stringCnt] = varyings.size();
-        ++stringCnt;
-    }
-
-    GrAssert(segments.fVSCode.size());
-    strings[stringCnt] = segments.fVSCode.c_str();
-    lengths[stringCnt] = segments.fVSCode.size();
-    ++stringCnt;
+    append_string(segments.fHeader, &strs, &lengths);
+    append_decls(segments.fVSUnis, gl, "uniform", &strs, &lengths, &temps);
+    append_decls(segments.fVSAttrs, gl, attributePrefix, &strs, &lengths, &temps);
+    append_decls(segments.fVSOutputs, gl, varyingPrefixes[0], &strs, &lengths, &temps);
+    append_string(segments.fVSCode, &strs, &lengths);
 
 #if PRINT_SHADERS
-    print_shader(stringCnt, strings, lengths);
+    print_shader(strs.count(), &strs[0], &lengths[0]);
     GrPrintf("\n");
 #endif
 
-    GrAssert(stringCnt <= MAX_STRINGS);
-    programData->fVShaderID = CompileShader(gl, GR_GL_VERTEX_SHADER,
-                                            stringCnt, strings, lengths);
+    programData->fVShaderID =
+        CompileShader(gl, GR_GL_VERTEX_SHADER, strs.count(),
+                      &strs[0], &lengths[0]);
 
     if (!programData->fVShaderID) {
         return false;
     }
-
-    stringCnt = 0;
-
-    if (segments.fHeader.size()) {
-        strings[stringCnt] = segments.fHeader.c_str();
-        lengths[stringCnt] = segments.fHeader.size();
-        ++stringCnt;
-    }
-    if (strlen(GrShaderPrecision(gl)) > 1) {
-        strings[stringCnt] = GrShaderPrecision(gl);
-        lengths[stringCnt] = strlen(GrShaderPrecision(gl));
-        ++stringCnt;
-    }
-    unis.reset();
-    expand_decls(segments.fFSUnis, gl, "uniform", &unis);
-    if (unis.size()) {
-        strings[stringCnt] = unis.c_str();
-        lengths[stringCnt] = unis.size();
-        ++stringCnt;
-    }
-    varyings.reset();
-    expand_decls(segments.fVaryings, gl, varyingPrefixes[1], &varyings);
-    if (varyings.size()) {
-        strings[stringCnt] = varyings.c_str();
-        lengths[stringCnt] = varyings.size();
-        ++stringCnt;
-    }
-    expand_decls(segments.fFSOutputs, gl, "out", &fsOutputs);
-    if (fsOutputs.size()) {
-        // We shouldn't have declared outputs on 1.2
-        GrAssert(k120_GLSLVersion != glslVersion);
-        strings[stringCnt] = fsOutputs.c_str();
-        lengths[stringCnt] = fsOutputs.size();
-        ++stringCnt;
-    }
-    if (segments.fFSFunctions.size()) {
-        strings[stringCnt] = segments.fFSFunctions.c_str();
-        lengths[stringCnt] = segments.fFSFunctions.size();
-        ++stringCnt;
+    if (segments.fUsesGS) {
+        strs.reset();
+        lengths.reset();
+        temps.reset();
+        append_string(segments.fHeader, &strs, &lengths);
+        append_string(segments.fGSHeader, &strs, &lengths);
+        append_decls(segments.fGSInputs, gl, "in", &strs, &lengths, &temps);
+        append_decls(segments.fGSOutputs, gl, "out", &strs, &lengths, &temps);
+        append_string(segments.fGSCode, &strs, &lengths);
+#if PRINT_SHADERS
+        print_shader(strs.count(), &strs[0], &lengths[0]);
+        GrPrintf("\n");
+#endif
+        programData->fGShaderID =
+            CompileShader(gl, GR_GL_GEOMETRY_SHADER, strs.count(),
+                          &strs[0], &lengths[0]);
+    } else {
+        programData->fGShaderID = 0;
     }
 
-    GrAssert(segments.fFSCode.size());
-    strings[stringCnt] = segments.fFSCode.c_str();
-    lengths[stringCnt] = segments.fFSCode.size();
-    ++stringCnt;
+    strs.reset();
+    lengths.reset();
+    temps.reset();
+
+    append_string(segments.fHeader, &strs, &lengths);
+    GrStringBuilder precisionStr(GrShaderPrecision(gl));
+    append_string(precisionStr, &strs, &lengths);
+    append_decls(segments.fFSUnis, gl, "uniform", &strs, &lengths, &temps);
+    append_decls(segments.fFSInputs, gl, varyingPrefixes[1], &strs, &lengths, &temps);
+    // We shouldn't have declared outputs on 1.2
+    GrAssert(k120_GLSLVersion != glslVersion || segments.fFSOutputs.empty());
+    append_decls(segments.fFSOutputs, gl, "out", &strs, &lengths, &temps);
+    append_string(segments.fFSFunctions, &strs, &lengths);
+    append_string(segments.fFSCode, &strs, &lengths);
 
 #if PRINT_SHADERS
-    print_shader(stringCnt, strings, lengths);
+    print_shader(strs.count(), &strs[0], &lengths[0]);
     GrPrintf("\n");
 #endif
 
-    GrAssert(stringCnt <= MAX_STRINGS);
-    programData->fFShaderID = CompileShader(gl, GR_GL_FRAGMENT_SHADER,
-                                            stringCnt, strings, lengths);
+    programData->fFShaderID =
+        CompileShader(gl, GR_GL_FRAGMENT_SHADER, strs.count(),
+                      &strs[0], &lengths[0]);
 
     if (!programData->fFShaderID) {
         return false;
@@ -962,6 +1056,9 @@
     const GrGLint& progID = programData->fProgramID;
 
     GR_GL_CALL(gl, AttachShader(progID, programData->fVShaderID));
+    if (programData->fGShaderID) {
+        GR_GL_CALL(gl, AttachShader(progID, programData->fGShaderID));
+    }
     GR_GL_CALL(gl, AttachShader(progID, programData->fFShaderID));
 
     if (bindColorOut) {
@@ -1194,24 +1291,27 @@
         texelSizeName = segments->fFSUnis.back().getName().c_str();
     }
 
-    const char* varyingName;
-    GrGLShaderVar* varying = &segments->fVaryings.push_back();
-    stage_varying_name(stageNum, varying->accessName());
-    varying->setType(float_vector_type(varyingDims));
-    varyingName = varying->getName().c_str();
+    const char *varyingVSName, *varyingFSName;
+    append_varying(float_vector_type(varyingDims),
+                    "Stage",
+                   stageNum,
+                   segments,
+                   &varyingVSName,
+                   &varyingFSName);
 
     if (!matName) {
         GrAssert(varyingDims == coordDims);
-        segments->fVSCode.appendf("\t%s = %s;\n", varyingName, vsInCoord);
+        segments->fVSCode.appendf("\t%s = %s;\n", varyingVSName, vsInCoord);
     } else {
         // varying = texMatrix * texCoord
         segments->fVSCode.appendf("\t%s = (%s * vec3(%s, 1))%s;\n",
-                                  varyingName, matName, vsInCoord,
+                                  varyingVSName, matName, vsInCoord,
                                   vector_all_coords(varyingDims));
     }
 
     const char* radial2ParamsName = NULL;
-    const char* radial2VaryingName = NULL;
+    const char *radial2VaryingVSName = NULL;
+    const char *radial2VaryingFSName = NULL;
 
     if (StageDesc::kRadial2Gradient_CoordMapping == desc.fCoordMapping ||
         StageDesc::kRadial2GradientDegenerate_CoordMapping == desc.fCoordMapping) {
@@ -1229,18 +1329,18 @@
         // part of the quadratic as a varying.
         if (varyingDims == coordDims) {
             GrAssert(2 == coordDims);
-
-            GrGLShaderVar* radial2Varying = &segments->fVaryings.push_back();
-            radial2Varying->setType(GrGLShaderVar::kFloat_Type);
-            radial2_varying_name(stageNum, radial2Varying->accessName());
-            radial2VaryingName = radial2Varying->getName().c_str();
+            append_varying(GrGLShaderVar::kFloat_Type,
+                           "Radial2BCoeff",
+                           stageNum,
+                           segments,
+                           &radial2VaryingVSName,
+                           &radial2VaryingFSName);
 
             // r2Var = 2 * (r2Parm[2] * varCoord.x - r2Param[3])
             const char* r2ParamName = radial2FSParams->getName().c_str();
-            const char* r2VarName = radial2Varying->getName().c_str();
             segments->fVSCode.appendf("\t%s = 2.0 *(%s[2] * %s.x - %s[3]);\n",
-                                      r2VarName, r2ParamName, varyingName,
-                                      r2ParamName);
+                                      radial2VaryingVSName, r2ParamName,
+                                      varyingVSName, r2ParamName);
         }
     }
 
@@ -1267,7 +1367,7 @@
         locations->fImageIncrementUni = kUseUniform;
         float scale = (desc.fKernelWidth - 1) * 0.5f;
         segments->fVSCode.appendf("\t%s -= vec2(%g, %g) * %s;\n",
-                                  varyingName, scale, scale,
+                                  varyingVSName, scale, scale,
                                   imageIncrementName);
     }
 
@@ -1278,7 +1378,7 @@
     if (desc.fOptFlags & (StageDesc::kIdentityMatrix_OptFlagBit |
                           StageDesc::kNoPerspective_OptFlagBit)) {
         GrAssert(varyingDims == coordDims);
-        fsCoordName = varyingName;
+        fsCoordName = varyingFSName;
     } else {
         // if we have to do some special op on the varyings to get
         // our final tex coords then when in perspective we have to
@@ -1286,16 +1386,16 @@
         if  (StageDesc::kIdentity_CoordMapping == desc.fCoordMapping &&
              StageDesc::kSingle_FetchMode == desc.fFetchMode) {
             texFunc.append("Proj");
-            fsCoordName = varyingName;
+            fsCoordName = varyingFSName;
         } else {
             fsCoordName = "inCoord";
             fsCoordName.appendS32(stageNum);
             segments->fFSCode.appendf("\t%s %s = %s%s / %s%s;\n",
                                 GrGLShaderVar::TypeString(float_vector_type(coordDims)),
                                 fsCoordName.c_str(),
-                                varyingName,
+                                varyingFSName,
                                 vector_nonhomog_coords(varyingDims),
-                                varyingName,
+                                varyingFSName,
                                 vector_homog_coord(varyingDims));
         }
     }
@@ -1327,7 +1427,7 @@
         // otherwise compute it
         GrStringBuilder bVar;
         if (coordDims == varyingDims) {
-            bVar = radial2VaryingName;
+            bVar = radial2VaryingFSName;
             GrAssert(2 == varyingDims);
         } else {
             GrAssert(3 == varyingDims);
@@ -1370,7 +1470,7 @@
         // otherwise compute it
         GrStringBuilder bVar;
         if (coordDims == varyingDims) {
-            bVar = radial2VaryingName;
+            bVar = radial2VaryingFSName;
             GrAssert(2 == varyingDims);
         } else {
             GrAssert(3 == varyingDims);
diff --git a/gpu/src/GrGLProgram.h b/gpu/src/GrGLProgram.h
index 6b07f30..c186ba1 100644
--- a/gpu/src/GrGLProgram.h
+++ b/gpu/src/GrGLProgram.h
@@ -20,6 +20,10 @@
 
 struct ShaderCodeSegments;
 
+// optionally compile the experimental GS code. Set to GR_DEBUG
+// so that debug build bots will execute the code.
+#define GR_GL_EXPERIMENTAL_GS GR_DEBUG
+
 /**
  * This class manages a GPU program and records per-program information.
  * We can specify the attribute locations so that they are constant
@@ -32,8 +36,9 @@
 class GrGLProgram {
 public:
     enum GLSLVersion {
-        k120_GLSLVersion, // Desktop GLSL 1.2 and ES2 shading lang
-        k130_GLSLVersion  // Desktop GLSL 1.3
+        k120_GLSLVersion, // Desktop GLSL 1.20 and ES2 shading lang
+        k130_GLSLVersion, // Desktop GLSL 1.30
+        k150_GLSLVersion  // Dekstop GLSL 1.50
     };
 
     class CachedData;
@@ -155,6 +160,12 @@
 
         StageDesc fStages[GrDrawTarget::kNumStages];
 
+        // To enable experimental geometry shader code (not for use in
+        // production)
+#if GR_GL_EXPERIMENTAL_GS
+        bool fExperimentalGS;
+#endif
+
         uint8_t fColorType;  // casts to enum ColorType
         uint8_t fDualSrcOutput;  // casts to enum DualSrcOutput
         int8_t fFirstCoverageStage;
@@ -167,6 +178,7 @@
         uint8_t fPadTo32bLengthMultiple [1];
 
     } fProgramDesc;
+    GR_STATIC_ASSERT(!(sizeof(ProgramDesc) % 4));
 
     const ProgramDesc& getDesc() { return fProgramDesc; }
 
@@ -231,6 +243,7 @@
 
         // IDs
         GrGLuint    fVShaderID;
+        GrGLuint    fGShaderID;
         GrGLuint    fFShaderID;
         GrGLuint    fProgramID;
         // shader uniform locations (-1 if shader doesn't use them)
@@ -283,6 +296,10 @@
                       ShaderCodeSegments* segments,
                       StageUniLocations* locations) const;
 
+    void genGeometryShader(const GrGLInterface* gl,
+                           GLSLVersion glslVersion,
+                           ShaderCodeSegments* segments) const;
+
     // generates code to compute coverage based on edge AA.
     void genEdgeCoverage(const GrGLInterface* gl,
                          GrVertexLayout layout,
@@ -290,7 +307,7 @@
                          GrStringBuilder* coverageVar,
                          ShaderCodeSegments* segments) const;
 
-    static bool CompileFSAndVS(const GrGLInterface* gl,
+    static bool CompileShaders(const GrGLInterface* gl,
                                GLSLVersion glslVersion,
                                const ShaderCodeSegments& segments, 
                                CachedData* programData);
diff --git a/gpu/src/GrGpuGLShaders.cpp b/gpu/src/GrGpuGLShaders.cpp
index 05f6652..4f39965 100644
--- a/gpu/src/GrGpuGLShaders.cpp
+++ b/gpu/src/GrGpuGLShaders.cpp
@@ -130,6 +130,9 @@
 void GrGpuGLShaders::DeleteProgram(const GrGLInterface* gl,
                                    CachedData* programData) {
     GR_GL_CALL(gl, DeleteShader(programData->fVShaderID));
+    if (programData->fGShaderID) {
+        GR_GL_CALL(gl, DeleteShader(programData->fGShaderID));
+    }
     GR_GL_CALL(gl, DeleteShader(programData->fFShaderID));
     GR_GL_CALL(gl, DeleteProgram(programData->fProgramID));
     GR_DEBUGCODE(memset(programData, 0, sizeof(*programData));)
@@ -141,14 +144,22 @@
 
 namespace {
 
-GrGLProgram::GLSLVersion get_glsl_version(GrGLBinding binding, GrGLVersion glVersion) {
+GrGLProgram::GLSLVersion get_glsl_version(GrGLBinding binding,
+                                          const GrGLInterface* gl) {
+    GrGLSLVersion ver = GrGLGetGLSLVersion(gl);
     switch (binding) {
         case kDesktop_GrGLBinding:
-            // TODO: proper check of the glsl version string
-            return (glVersion >= GR_GL_VER(3,0)) ? 
-                                                GrGLProgram::k130_GLSLVersion :
-                                                GrGLProgram::k120_GLSLVersion;
+            GrAssert(ver >= GR_GLSL_VER(1,20));
+            if (ver >= GR_GLSL_VER(1,50)) {
+                return GrGLProgram::k150_GLSLVersion;
+            } else if (ver >= GR_GLSL_VER(1,30)) {
+                return GrGLProgram::k130_GLSLVersion;
+            } else {
+                return GrGLProgram::k120_GLSLVersion;
+            }
         case kES2_GrGLBinding:
+            // version 1.00 of ES GLSL based on ver 1.20 of desktop GLSL
+            GrAssert(ver >= GR_GL_VER(1,00));
             return GrGLProgram::k120_GLSLVersion;
         default:
             GrCrash("Attempting to get GLSL version in unknown or fixed-"
@@ -167,7 +178,7 @@
 bool GrGpuGLShaders::programUnitTest() {
 
     GrGLProgram::GLSLVersion glslVersion = 
-            get_glsl_version(this->glBinding(), this->glVersion());
+            get_glsl_version(this->glBinding(), this->glInterface());
     static const int STAGE_OPTS[] = {
         0,
         StageDesc::kNoPerspective_OptFlagBit,
@@ -208,6 +219,10 @@
         idx = (int)(random.nextF() * (kNumStages+1));
         pdesc.fFirstCoverageStage = idx;
 
+#if GR_GL_EXPERIMENTAL_GS
+        pdesc.fExperimentalGS = random.nextF() > .5f;
+#endif
+
         bool edgeAA = random.nextF() > .5f;
         if (edgeAA) {
             bool vertexEdgeAA = random.nextF() > .5f;
@@ -290,21 +305,26 @@
 GrGpuGLShaders::GrGpuGLShaders(const GrGLInterface* gl)
     : GrGpuGL(gl, get_binding_in_use(gl)) {
 
+    GrGLProgram::GLSLVersion glslVersion =
+        get_glsl_version(this->glBinding(), gl);
+
+    // Enable supported shader-releated caps
     fCaps.fShaderSupport = true;
     if (kDesktop_GrGLBinding == this->glBinding()) {
         fCaps.fDualSourceBlendingSupport =
                             this->glVersion() >= GR_GL_VER(3,3) ||
                             this->hasExtension("GL_ARB_blend_func_extended");
         fCaps.fShaderDerivativeSupport = true;
+        // we don't support GL_ARB_geometry_shader4, just GL 3.2+ GS
+        fCaps.fGeometryShaderSupport = 
+                                this->glVersion() >= GR_GL_VER(3,2) &&
+                                glslVersion >= GrGLProgram::k150_GLSLVersion;
     } else {
-        fCaps.fDualSourceBlendingSupport = false;
         fCaps.fShaderDerivativeSupport =
                             this->hasExtension("GL_OES_standard_derivatives");
     }
 
     fProgramData = NULL;
-    GrGLProgram::GLSLVersion glslVersion =
-        get_glsl_version(this->glBinding(), this->glVersion());
     fProgramCache = new ProgramCache(gl, glslVersion);
 
 #if 0
@@ -923,6 +943,14 @@
     }
 
     desc.fDualSrcOutput = ProgramDesc::kNone_DualSrcOutput;
+
+    // currently the experimental GS will only work with triangle prims
+    // (and it doesn't do anything other than pass through values from
+    // the VS to the FS anyway).
+#if 0 && GR_GL_EXPERIMENTAL_GS
+    desc.fExperimentalGS = this->getCaps().fGeometryShaderSupport;
+#endif
+
     // use canonical value when coverage/color distinction won't affect
     // generated code to prevent duplicate programs.
     desc.fFirstCoverageStage = kNumStages;