Introduce a DrawList to PLS

It's been great being able to draw everything in a single call, but we
are now at a point where we need separate draws for coarse
inner-path-fan tessellations and non-raster-ordered rendering. We will
probably also find separate draws superior to an uber shader for nested
clipping and raster images.

This change (finally) introduces a DrawList, which is capable of
recording all the types of draws we may need. Implementing the DrawList
also required incorporating EXT_base_instance into the GL backend, which
in turn necessitated a nice cleanup of our GL extension wrangling.

Diffs=
28c49dbbd Introduce a DrawList to PLS (#5432)

Co-authored-by: Chris Dalton <99840794+csmartdalton@users.noreply.github.com>
diff --git a/.rive_head b/.rive_head
index 0a13269..6b23799 100644
--- a/.rive_head
+++ b/.rive_head
@@ -1 +1 @@
-80117d7b1c33b93f28d4a84cfa59b3d03115cda7
+28c49dbbdb2b27f792b7376fa1ee34f96dbf1141
diff --git a/bubbles/bubbles.cpp b/bubbles/bubbles.cpp
index 02e28ca..fba6979 100644
--- a/bubbles/bubbles.cpp
+++ b/bubbles/bubbles.cpp
@@ -251,7 +251,7 @@
 
 #ifdef RIVE_DESKTOP_GL
     // Load the OpenGL API using glad.
-    if (!gladLoadGLES2Loader((GLADloadproc)glfwGetProcAddress))
+    if (!gladLoadCustomLoader((GLADloadproc)glfwGetProcAddress))
     {
         fprintf(stderr, "Failed to initialize glad.\n");
         return -1;
diff --git a/glad/glad.c b/glad/glad.c
index da15a44..6e3a0ce 100644
--- a/glad/glad.c
+++ b/glad/glad.c
@@ -1,12 +1,13 @@
 /*
 
-    OpenGL ES loader generated by glad 0.1.34 on Wed Jun  7 19:10:28 2023.
+    OpenGL ES loader generated by glad 0.1.34 on Sat Jun 17 12:25:47 2023.
 
     Language/Generator: C/C++
     Specification: gl
     APIs: gles2=3.1
     Profile: compatibility
     Extensions:
+        GL_EXT_base_instance,
         GL_KHR_debug
     Loader: True
     Local files: True
@@ -14,9 +15,9 @@
     Reproducible: False
 
     Commandline:
-        --profile="compatibility" --api="gles2=3.1" --generator="c" --spec="gl" --local-files --extensions="GL_KHR_debug"
+        --profile="compatibility" --api="gles2=3.1" --generator="c" --spec="gl" --local-files --extensions="GL_EXT_base_instance,GL_KHR_debug"
     Online:
-        https://glad.dav1d.de/#profile=compatibility&language=c&specification=gl&loader=on&api=gles2%3D3.1&extensions=GL_KHR_debug
+        https://glad.dav1d.de/#profile=compatibility&language=c&specification=gl&loader=on&api=gles2%3D3.1&extensions=GL_EXT_base_instance&extensions=GL_KHR_debug
 */
 
 #include <stdio.h>
@@ -440,10 +441,11 @@
 PFNGLVERTEXBINDINGDIVISORPROC glad_glVertexBindingDivisor = NULL;
 PFNGLVIEWPORTPROC glad_glViewport = NULL;
 PFNGLWAITSYNCPROC glad_glWaitSync = NULL;
+int GLAD_GL_EXT_base_instance = 0;
 int GLAD_GL_KHR_debug = 0;
-int GLAD_GL_ANGLE_shader_pixel_local_storage = 0;
-int GLAD_GL_ANGLE_shader_pixel_local_storage_coherent = 0;
-int GLAD_GL_ANGLE_provoking_vertex = 0;
+PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEEXTPROC glad_glDrawArraysInstancedBaseInstanceEXT = NULL;
+PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEEXTPROC glad_glDrawElementsInstancedBaseInstanceEXT = NULL;
+PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEEXTPROC glad_glDrawElementsInstancedBaseVertexBaseInstanceEXT = NULL;
 PFNGLDEBUGMESSAGECONTROLPROC glad_glDebugMessageControl = NULL;
 PFNGLDEBUGMESSAGEINSERTPROC glad_glDebugMessageInsert = NULL;
 PFNGLDEBUGMESSAGECALLBACKPROC glad_glDebugMessageCallback = NULL;
@@ -466,17 +468,6 @@
 PFNGLOBJECTPTRLABELKHRPROC glad_glObjectPtrLabelKHR = NULL;
 PFNGLGETOBJECTPTRLABELKHRPROC glad_glGetObjectPtrLabelKHR = NULL;
 PFNGLGETPOINTERVKHRPROC glad_glGetPointervKHR = NULL;
-PFNGLFRAMEBUFFERMEMORYLESSPIXELLOCALSTORAGEANGLEPROC glad_glFramebufferMemorylessPixelLocalStorageANGLE = NULL;
-PFNGLFRAMEBUFFERTEXTUREPIXELLOCALSTORAGEANGLEPROC glad_glFramebufferTexturePixelLocalStorageANGLE = NULL;
-PFNGLFRAMEBUFFERPIXELLOCALCLEARVALUEFVANGLEPROC glad_glFramebufferPixelLocalClearValuefvANGLE = NULL;
-PFNGLFRAMEBUFFERPIXELLOCALCLEARVALUEIVANGLEPROC glad_glFramebufferPixelLocalClearValueivANGLE = NULL;
-PFNGLFRAMEBUFFERPIXELLOCALCLEARVALUEUIVANGLEPROC glad_glFramebufferPixelLocalClearValueuivANGLE = NULL;
-PFNGLBEGINPIXELLOCALSTORAGEANGLEPROC glad_glBeginPixelLocalStorageANGLE = NULL;
-PFNGLENDPIXELLOCALSTORAGEANGLEPROC glad_glEndPixelLocalStorageANGLE = NULL;
-PFNGLPIXELLOCALSTORAGEBARRIERANGLEPROC glad_glPixelLocalStorageBarrierANGLE = NULL;
-PFNGLGETFRAMEBUFFERPIXELLOCALSTORAGEPARAMETERFVANGLEPROC glad_glGetFramebufferPixelLocalStorageParameterfvANGLE = NULL;
-PFNGLGETFRAMEBUFFERPIXELLOCALSTORAGEPARAMETERIVANGLEPROC glad_glGetFramebufferPixelLocalStorageParameterivANGLE = NULL;
-PFNGLPROVOKINGVERTEXANGLEPROC glad_glProvokingVertexANGLE = NULL;
 static void load_GL_ES_VERSION_2_0(GLADloadproc load) {
 	if(!GLAD_GL_ES_VERSION_2_0) return;
 	glad_glActiveTexture = (PFNGLACTIVETEXTUREPROC)load("glActiveTexture");
@@ -800,6 +791,12 @@
 	glad_glVertexAttribBinding = (PFNGLVERTEXATTRIBBINDINGPROC)load("glVertexAttribBinding");
 	glad_glVertexBindingDivisor = (PFNGLVERTEXBINDINGDIVISORPROC)load("glVertexBindingDivisor");
 }
+static void load_GL_EXT_base_instance(GLADloadproc load) {
+	if(!GLAD_GL_EXT_base_instance) return;
+	glad_glDrawArraysInstancedBaseInstanceEXT = (PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEEXTPROC)load("glDrawArraysInstancedBaseInstanceEXT");
+	glad_glDrawElementsInstancedBaseInstanceEXT = (PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEEXTPROC)load("glDrawElementsInstancedBaseInstanceEXT");
+	glad_glDrawElementsInstancedBaseVertexBaseInstanceEXT = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEEXTPROC)load("glDrawElementsInstancedBaseVertexBaseInstanceEXT");
+}
 static void load_GL_KHR_debug(GLADloadproc load) {
 	if(!GLAD_GL_KHR_debug) return;
 	glad_glDebugMessageControl = (PFNGLDEBUGMESSAGECONTROLPROC)load("glDebugMessageControl");
@@ -825,29 +822,10 @@
 	glad_glGetObjectPtrLabelKHR = (PFNGLGETOBJECTPTRLABELKHRPROC)load("glGetObjectPtrLabelKHR");
 	glad_glGetPointervKHR = (PFNGLGETPOINTERVKHRPROC)load("glGetPointervKHR");
 }
-static void load_GL_ANGLE_shader_pixel_local_storage(GLADloadproc load) {
-	if(!GLAD_GL_ANGLE_shader_pixel_local_storage) return;
-    glad_glFramebufferMemorylessPixelLocalStorageANGLE = (PFNGLFRAMEBUFFERMEMORYLESSPIXELLOCALSTORAGEANGLEPROC)load("glFramebufferMemorylessPixelLocalStorageANGLE");
-    glad_glFramebufferTexturePixelLocalStorageANGLE = (PFNGLFRAMEBUFFERTEXTUREPIXELLOCALSTORAGEANGLEPROC)load("glFramebufferTexturePixelLocalStorageANGLE");
-    glad_glFramebufferPixelLocalClearValuefvANGLE = (PFNGLFRAMEBUFFERPIXELLOCALCLEARVALUEFVANGLEPROC)load("glFramebufferPixelLocalClearValuefvANGLE");
-    glad_glFramebufferPixelLocalClearValueivANGLE = (PFNGLFRAMEBUFFERPIXELLOCALCLEARVALUEIVANGLEPROC)load("glFramebufferPixelLocalClearValueivANGLE");
-    glad_glFramebufferPixelLocalClearValueuivANGLE = (PFNGLFRAMEBUFFERPIXELLOCALCLEARVALUEUIVANGLEPROC)load("glFramebufferPixelLocalClearValueuivANGLE");
-    glad_glBeginPixelLocalStorageANGLE = (PFNGLBEGINPIXELLOCALSTORAGEANGLEPROC)load("glBeginPixelLocalStorageANGLE");
-    glad_glEndPixelLocalStorageANGLE = (PFNGLENDPIXELLOCALSTORAGEANGLEPROC)load("glEndPixelLocalStorageANGLE");
-    glad_glPixelLocalStorageBarrierANGLE = (PFNGLPIXELLOCALSTORAGEBARRIERANGLEPROC)load("glPixelLocalStorageBarrierANGLE");
-    glad_glGetFramebufferPixelLocalStorageParameterfvANGLE = (PFNGLGETFRAMEBUFFERPIXELLOCALSTORAGEPARAMETERFVANGLEPROC)load("glGetFramebufferPixelLocalStorageParameterfvANGLE");
-    glad_glGetFramebufferPixelLocalStorageParameterivANGLE = (PFNGLGETFRAMEBUFFERPIXELLOCALSTORAGEPARAMETERIVANGLEPROC)load("glGetFramebufferPixelLocalStorageParameterivANGLE");
-}
-static void load_GL_ANGLE_provoking_vertex(GLADloadproc load) {
-	if(!GLAD_GL_ANGLE_provoking_vertex) return;
-    glad_glProvokingVertexANGLE = (PFNGLPROVOKINGVERTEXANGLEPROC)load("glProvokingVertexANGLE");
-}
 static int find_extensionsGLES2(void) {
 	if (!get_exts()) return 0;
+	GLAD_GL_EXT_base_instance = has_ext("GL_EXT_base_instance");
 	GLAD_GL_KHR_debug = has_ext("GL_KHR_debug");
-	GLAD_GL_ANGLE_shader_pixel_local_storage = has_ext("GL_ANGLE_shader_pixel_local_storage");
-	GLAD_GL_ANGLE_shader_pixel_local_storage_coherent = has_ext("GL_ANGLE_shader_pixel_local_storage_coherent");
-	GLAD_GL_ANGLE_provoking_vertex = has_ext("GL_ANGLE_provoking_vertex");
 	free_exts();
 	return 1;
 }
@@ -908,8 +886,7 @@
 	load_GL_ES_VERSION_3_1(load);
 
 	if (!find_extensionsGLES2()) return 0;
+	load_GL_EXT_base_instance(load);
 	load_GL_KHR_debug(load);
-    load_GL_ANGLE_shader_pixel_local_storage(load);
-    load_GL_ANGLE_provoking_vertex(load);
 	return GLVersion.major != 0 || GLVersion.minor != 0;
 }
diff --git a/glad/glad.h b/glad/glad.h
index c22bd6c..9f41324 100644
--- a/glad/glad.h
+++ b/glad/glad.h
@@ -1,12 +1,13 @@
 /*
 
-    OpenGL ES loader generated by glad 0.1.34 on Wed Jun  7 19:10:28 2023.
+    OpenGL ES loader generated by glad 0.1.34 on Sat Jun 17 12:25:47 2023.
 
     Language/Generator: C/C++
     Specification: gl
     APIs: gles2=3.1
     Profile: compatibility
     Extensions:
+        GL_EXT_base_instance,
         GL_KHR_debug
     Loader: True
     Local files: True
@@ -14,9 +15,9 @@
     Reproducible: False
 
     Commandline:
-        --profile="compatibility" --api="gles2=3.1" --generator="c" --spec="gl" --local-files --extensions="GL_KHR_debug"
+        --profile="compatibility" --api="gles2=3.1" --generator="c" --spec="gl" --local-files --extensions="GL_EXT_base_instance,GL_KHR_debug"
     Online:
-        https://glad.dav1d.de/#profile=compatibility&language=c&specification=gl&loader=on&api=gles2%3D3.1&extensions=GL_KHR_debug
+        https://glad.dav1d.de/#profile=compatibility&language=c&specification=gl&loader=on&api=gles2%3D3.1&extensions=GL_EXT_base_instance&extensions=GL_KHR_debug
 */
 
 
@@ -1965,6 +1966,19 @@
 #define GL_STACK_OVERFLOW_KHR 0x0503
 #define GL_STACK_UNDERFLOW_KHR 0x0504
 #define GL_DISPLAY_LIST 0x82E7
+#ifndef GL_EXT_base_instance
+#define GL_EXT_base_instance 1
+GLAPI int GLAD_GL_EXT_base_instance;
+typedef void (APIENTRYP PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEEXTPROC)(GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance);
+GLAPI PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEEXTPROC glad_glDrawArraysInstancedBaseInstanceEXT;
+#define glDrawArraysInstancedBaseInstanceEXT glad_glDrawArraysInstancedBaseInstanceEXT
+typedef void (APIENTRYP PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEEXTPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLuint baseinstance);
+GLAPI PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEEXTPROC glad_glDrawElementsInstancedBaseInstanceEXT;
+#define glDrawElementsInstancedBaseInstanceEXT glad_glDrawElementsInstancedBaseInstanceEXT
+typedef void (APIENTRYP PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEEXTPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance);
+GLAPI PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEEXTPROC glad_glDrawElementsInstancedBaseVertexBaseInstanceEXT;
+#define glDrawElementsInstancedBaseVertexBaseInstanceEXT glad_glDrawElementsInstancedBaseVertexBaseInstanceEXT
+#endif
 #ifndef GL_KHR_debug
 #define GL_KHR_debug 1
 GLAPI int GLAD_GL_KHR_debug;
@@ -2036,68 +2050,6 @@
 #define glGetPointervKHR glad_glGetPointervKHR
 #endif
 
-// Manual additions for extensions not supported in the glad tool.
-#ifndef GL_ANGLE_shader_pixel_local_storage
-#define GL_ANGLE_shader_pixel_local_storage 1
-#define GL_MAX_PIXEL_LOCAL_STORAGE_PLANES_ANGLE 0x96E0
-#define GL_MAX_COLOR_ATTACHMENTS_WITH_ACTIVE_PIXEL_LOCAL_STORAGE_ANGLE 0x96E1
-#define GL_MAX_COMBINED_DRAW_BUFFERS_AND_PIXEL_LOCAL_STORAGE_PLANES_ANGLE 0x96E2
-#define GL_PIXEL_LOCAL_STORAGE_ACTIVE_PLANES_ANGLE 0x96E3
-#define GL_LOAD_OP_ZERO_ANGLE 0x96E4
-#define GL_LOAD_OP_CLEAR_ANGLE 0x96E5
-#define GL_LOAD_OP_LOAD_ANGLE 0x96E6
-#define GL_STORE_OP_STORE_ANGLE 0x96E7
-#define GL_PIXEL_LOCAL_FORMAT_ANGLE 0x96E8
-#define GL_PIXEL_LOCAL_TEXTURE_NAME_ANGLE 0x96E9
-#define GL_PIXEL_LOCAL_TEXTURE_LEVEL_ANGLE 0x96EA
-#define GL_PIXEL_LOCAL_TEXTURE_LAYER_ANGLE 0x96EB
-#define GL_PIXEL_LOCAL_CLEAR_VALUE_FLOAT_ANGLE 0x96EC
-#define GL_PIXEL_LOCAL_CLEAR_VALUE_INT_ANGLE 0x96ED
-#define GL_PIXEL_LOCAL_CLEAR_VALUE_UNSIGNED_INT_ANGLE 0x96EE
-GLAPI int GLAD_GL_ANGLE_shader_pixel_local_storage;
-GLAPI int GLAD_GL_ANGLE_shader_pixel_local_storage_coherent;
-typedef void (APIENTRYP PFNGLFRAMEBUFFERMEMORYLESSPIXELLOCALSTORAGEANGLEPROC) (GLint plane, GLenum internalformat);
-GLAPI PFNGLFRAMEBUFFERMEMORYLESSPIXELLOCALSTORAGEANGLEPROC glad_glFramebufferMemorylessPixelLocalStorageANGLE;
-#define glFramebufferMemorylessPixelLocalStorageANGLE glad_glFramebufferMemorylessPixelLocalStorageANGLE
-typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTUREPIXELLOCALSTORAGEANGLEPROC) (GLint plane, GLuint backingtexture, GLint level, GLint layer);
-GLAPI PFNGLFRAMEBUFFERTEXTUREPIXELLOCALSTORAGEANGLEPROC glad_glFramebufferTexturePixelLocalStorageANGLE;
-#define glFramebufferTexturePixelLocalStorageANGLE glad_glFramebufferTexturePixelLocalStorageANGLE
-typedef void (APIENTRYP PFNGLFRAMEBUFFERPIXELLOCALCLEARVALUEFVANGLEPROC) (GLint plane, const GLfloat value[4]);
-GLAPI PFNGLFRAMEBUFFERPIXELLOCALCLEARVALUEFVANGLEPROC glad_glFramebufferPixelLocalClearValuefvANGLE;
-#define glFramebufferPixelLocalClearValuefvANGLE glad_glFramebufferPixelLocalClearValuefvANGLE
-typedef void (APIENTRYP PFNGLFRAMEBUFFERPIXELLOCALCLEARVALUEIVANGLEPROC) (GLint plane, const GLint value[4]);
-GLAPI PFNGLFRAMEBUFFERPIXELLOCALCLEARVALUEIVANGLEPROC glad_glFramebufferPixelLocalClearValueivANGLE;
-#define glFramebufferPixelLocalClearValueivANGLE glad_glFramebufferPixelLocalClearValueivANGLE
-typedef void (APIENTRYP PFNGLFRAMEBUFFERPIXELLOCALCLEARVALUEUIVANGLEPROC) (GLint plane, const GLuint value[4]);
-GLAPI PFNGLFRAMEBUFFERPIXELLOCALCLEARVALUEUIVANGLEPROC glad_glFramebufferPixelLocalClearValueuivANGLE;
-#define glFramebufferPixelLocalClearValueuivANGLE glad_glFramebufferPixelLocalClearValueuivANGLE
-typedef void (APIENTRYP PFNGLBEGINPIXELLOCALSTORAGEANGLEPROC) (GLsizei n, const GLenum loadops[]);
-GLAPI PFNGLBEGINPIXELLOCALSTORAGEANGLEPROC glad_glBeginPixelLocalStorageANGLE;
-#define glBeginPixelLocalStorageANGLE glad_glBeginPixelLocalStorageANGLE
-typedef void (APIENTRYP PFNGLENDPIXELLOCALSTORAGEANGLEPROC) (GLsizei n, const GLenum storeops[]);
-GLAPI PFNGLENDPIXELLOCALSTORAGEANGLEPROC glad_glEndPixelLocalStorageANGLE;
-#define glEndPixelLocalStorageANGLE glad_glEndPixelLocalStorageANGLE
-typedef void (APIENTRYP PFNGLPIXELLOCALSTORAGEBARRIERANGLEPROC) ();
-GLAPI PFNGLPIXELLOCALSTORAGEBARRIERANGLEPROC glad_glPixelLocalStorageBarrierANGLE;
-#define glPixelLocalStorageBarrierANGLE glad_glPixelLocalStorageBarrierANGLE
-typedef void (APIENTRYP PFNGLGETFRAMEBUFFERPIXELLOCALSTORAGEPARAMETERFVANGLEPROC) (GLint plane, GLenum pname, GLfloat* params);
-GLAPI PFNGLGETFRAMEBUFFERPIXELLOCALSTORAGEPARAMETERFVANGLEPROC glad_glGetFramebufferPixelLocalStorageParameterfvANGLE;
-#define glGetFramebufferPixelLocalStorageParameterfvANGLE glad_glGetFramebufferPixelLocalStorageParameterfvANGLE
-typedef void (APIENTRYP PFNGLGETFRAMEBUFFERPIXELLOCALSTORAGEPARAMETERIVANGLEPROC) (GLint plane, GLenum pname, GLint* params);
-GLAPI PFNGLGETFRAMEBUFFERPIXELLOCALSTORAGEPARAMETERIVANGLEPROC glad_glGetFramebufferPixelLocalStorageParameterivANGLE;
-#define glGetFramebufferPixelLocalStorageParameterivANGLE glad_glGetFramebufferPixelLocalStorageParameterivANGLE
-#endif
-#ifndef GL_ANGLE_provoking_vertex
-#define GL_ANGLE_provoking_vertex 1
-#define GL_FIRST_VERTEX_CONVENTION_ANGLE 0x8E4D
-#define GL_LAST_VERTEX_CONVENTION_ANGLE 0x8E4E
-#define GL_PROVOKING_VERTEX_ANGLE 0x8E4F
-GLAPI int GLAD_GL_ANGLE_provoking_vertex;
-typedef void (APIENTRYP PFNGLPROVOKINGVERTEXANGLEPROC) (GLenum provokeMode);
-GLAPI PFNGLPROVOKINGVERTEXANGLEPROC glad_glProvokingVertexANGLE;
-#define glProvokingVertexANGLE glad_glProvokingVertexANGLE
-#endif
-
 #ifdef __cplusplus
 }
 #endif
diff --git a/glad/glad_custom.c b/glad/glad_custom.c
new file mode 100644
index 0000000..0e42ec5
--- /dev/null
+++ b/glad/glad_custom.c
@@ -0,0 +1,99 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "glad_custom.h"
+
+int GLAD_GL_version_es = 1;
+int GLAD_GL_version_major = 1;
+int GLAD_GL_version_minor = 0;
+
+static void load_Desktop_GL(GLADloadproc load) {
+    if (GLAD_GL_version_es) return;
+
+    GLAD_GL_ANGLE_polygon_mode = 1;
+    glad_glPolygonModeANGLE = (PFNGLPOLYGONMODEANGLEPROC)load("glPolygonMode");
+
+    if (GLAD_IS_GL_VERSION_AT_LEAST(4, 2)) {
+        GLAD_GL_EXT_base_instance = 1;
+        glad_glDrawArraysInstancedBaseInstanceEXT = (PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEEXTPROC)load("glDrawArraysInstancedBaseInstance");
+        glad_glDrawElementsInstancedBaseInstanceEXT = (PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEEXTPROC)load("glDrawElementsInstancedBaseInstance");
+        glad_glDrawElementsInstancedBaseVertexBaseInstanceEXT = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEEXTPROC)load("glDrawElementsInstancedBaseVertexBaseInstance");
+    }
+}
+
+PFNGLFRAMEBUFFERMEMORYLESSPIXELLOCALSTORAGEANGLEPROC glad_glFramebufferMemorylessPixelLocalStorageANGLE = NULL;
+PFNGLFRAMEBUFFERTEXTUREPIXELLOCALSTORAGEANGLEPROC glad_glFramebufferTexturePixelLocalStorageANGLE = NULL;
+PFNGLFRAMEBUFFERPIXELLOCALCLEARVALUEFVANGLEPROC glad_glFramebufferPixelLocalClearValuefvANGLE = NULL;
+PFNGLFRAMEBUFFERPIXELLOCALCLEARVALUEIVANGLEPROC glad_glFramebufferPixelLocalClearValueivANGLE = NULL;
+PFNGLFRAMEBUFFERPIXELLOCALCLEARVALUEUIVANGLEPROC glad_glFramebufferPixelLocalClearValueuivANGLE = NULL;
+PFNGLBEGINPIXELLOCALSTORAGEANGLEPROC glad_glBeginPixelLocalStorageANGLE = NULL;
+PFNGLENDPIXELLOCALSTORAGEANGLEPROC glad_glEndPixelLocalStorageANGLE = NULL;
+PFNGLPIXELLOCALSTORAGEBARRIERANGLEPROC glad_glPixelLocalStorageBarrierANGLE = NULL;
+PFNGLGETFRAMEBUFFERPIXELLOCALSTORAGEPARAMETERFVANGLEPROC glad_glGetFramebufferPixelLocalStorageParameterfvANGLE = NULL;
+PFNGLGETFRAMEBUFFERPIXELLOCALSTORAGEPARAMETERIVANGLEPROC glad_glGetFramebufferPixelLocalStorageParameterivANGLE = NULL;
+PFNGLPOLYGONMODEANGLEPROC glad_glPolygonModeANGLE = NULL;
+PFNGLPROVOKINGVERTEXANGLEPROC glad_glProvokingVertexANGLE = NULL;
+int GLAD_GL_ANGLE_shader_pixel_local_storage = 0;
+int GLAD_GL_ANGLE_shader_pixel_local_storage_coherent = 0;
+int GLAD_GL_ANGLE_polygon_mode = 0;
+int GLAD_GL_ANGLE_provoking_vertex = 0;
+static void load_GL_ANGLE_shader_pixel_local_storage(GLADloadproc load) {
+    if(!GLAD_GL_ANGLE_shader_pixel_local_storage) return;
+    glad_glFramebufferMemorylessPixelLocalStorageANGLE = (PFNGLFRAMEBUFFERMEMORYLESSPIXELLOCALSTORAGEANGLEPROC)load("glFramebufferMemorylessPixelLocalStorageANGLE");
+    glad_glFramebufferTexturePixelLocalStorageANGLE = (PFNGLFRAMEBUFFERTEXTUREPIXELLOCALSTORAGEANGLEPROC)load("glFramebufferTexturePixelLocalStorageANGLE");
+    glad_glFramebufferPixelLocalClearValuefvANGLE = (PFNGLFRAMEBUFFERPIXELLOCALCLEARVALUEFVANGLEPROC)load("glFramebufferPixelLocalClearValuefvANGLE");
+    glad_glFramebufferPixelLocalClearValueivANGLE = (PFNGLFRAMEBUFFERPIXELLOCALCLEARVALUEIVANGLEPROC)load("glFramebufferPixelLocalClearValueivANGLE");
+    glad_glFramebufferPixelLocalClearValueuivANGLE = (PFNGLFRAMEBUFFERPIXELLOCALCLEARVALUEUIVANGLEPROC)load("glFramebufferPixelLocalClearValueuivANGLE");
+    glad_glBeginPixelLocalStorageANGLE = (PFNGLBEGINPIXELLOCALSTORAGEANGLEPROC)load("glBeginPixelLocalStorageANGLE");
+    glad_glEndPixelLocalStorageANGLE = (PFNGLENDPIXELLOCALSTORAGEANGLEPROC)load("glEndPixelLocalStorageANGLE");
+    glad_glPixelLocalStorageBarrierANGLE = (PFNGLPIXELLOCALSTORAGEBARRIERANGLEPROC)load("glPixelLocalStorageBarrierANGLE");
+    glad_glGetFramebufferPixelLocalStorageParameterfvANGLE = (PFNGLGETFRAMEBUFFERPIXELLOCALSTORAGEPARAMETERFVANGLEPROC)load("glGetFramebufferPixelLocalStorageParameterfvANGLE");
+    glad_glGetFramebufferPixelLocalStorageParameterivANGLE = (PFNGLGETFRAMEBUFFERPIXELLOCALSTORAGEPARAMETERIVANGLEPROC)load("glGetFramebufferPixelLocalStorageParameterivANGLE");
+}
+static void load_GL_ANGLE_polygon_mode(GLADloadproc load) {
+    if(!GLAD_GL_ANGLE_polygon_mode) return;
+    glad_glPolygonModeANGLE = (PFNGLPOLYGONMODEANGLEPROC)load("glPolygonModeANGLE");
+}
+static void load_GL_ANGLE_provoking_vertex(GLADloadproc load) {
+    if(!GLAD_GL_ANGLE_provoking_vertex) return;
+    glad_glProvokingVertexANGLE = (PFNGLPROVOKINGVERTEXANGLEPROC)load("glProvokingVertexANGLE");
+}
+int gladLoadCustomLoader(GLADloadproc load) {
+    int ret = gladLoadGLES2Loader(load);
+
+    const char* version = (const char*)glGetString(GL_VERSION);
+    GLAD_GL_version_es = strstr(version, "OpenGL ES") != NULL;
+#ifdef _MSC_VER
+    sscanf_s(version, "%d.%d", &GLAD_GL_version_major, &GLAD_GL_version_minor);
+#else
+    sscanf(version, "%d.%d", &GLAD_GL_version_major, &GLAD_GL_version_minor);
+#endif
+
+    GLint extensionCount;
+    glGetIntegerv(GL_NUM_EXTENSIONS, &extensionCount);
+    for (int i = 0; i < extensionCount; ++i)
+    {
+        const char* ext = (const char*)glGetStringi(GL_EXTENSIONS, i);
+        if (strcmp(ext, "GL_ANGLE_shader_pixel_local_storage") == 0)
+        {
+            GLAD_GL_ANGLE_shader_pixel_local_storage = 1;
+        }
+        else if (strcmp(ext, "GL_ANGLE_shader_pixel_local_storage_coherent") == 0)
+        {
+            GLAD_GL_ANGLE_shader_pixel_local_storage_coherent = 1;
+        }
+        else if (strcmp(ext, "GL_ANGLE_polygon_mode") == 0)
+        {
+            GLAD_GL_ANGLE_polygon_mode = 1;
+        }
+        else if (strcmp(ext, "GL_ANGLE_provoking_vertex") == 0)
+        {
+            GLAD_GL_ANGLE_provoking_vertex = 1;
+        }
+    }
+    load_GL_ANGLE_shader_pixel_local_storage(load);
+    load_GL_ANGLE_polygon_mode(load);
+    load_GL_ANGLE_provoking_vertex(load);
+    load_Desktop_GL(load);
+    return ret;
+}
diff --git a/glad/glad_custom.h b/glad/glad_custom.h
new file mode 100644
index 0000000..8bd7698
--- /dev/null
+++ b/glad/glad_custom.h
@@ -0,0 +1,95 @@
+#pragma once
+
+#include "glad.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int gladLoadCustomLoader(GLADloadproc);
+
+GLAPI int GLAD_GL_version_es;
+GLAPI int GLAD_GL_version_major;
+GLAPI int GLAD_GL_version_minor;
+
+#define GLAD_IS_GL_VERSION_AT_LEAST(MAJOR, MINOR) \
+    ((GLAD_GL_version_major << 16) | GLAD_GL_version_minor) >= (((MAJOR) << 16) | (MINOR))
+
+// Manual additions for extensions not supported in the glad tool.
+#ifndef GL_ANGLE_shader_pixel_local_storage
+#define GL_ANGLE_shader_pixel_local_storage 1
+#define GL_MAX_PIXEL_LOCAL_STORAGE_PLANES_ANGLE 0x96E0
+#define GL_MAX_COLOR_ATTACHMENTS_WITH_ACTIVE_PIXEL_LOCAL_STORAGE_ANGLE 0x96E1
+#define GL_MAX_COMBINED_DRAW_BUFFERS_AND_PIXEL_LOCAL_STORAGE_PLANES_ANGLE 0x96E2
+#define GL_PIXEL_LOCAL_STORAGE_ACTIVE_PLANES_ANGLE 0x96E3
+#define GL_LOAD_OP_ZERO_ANGLE 0x96E4
+#define GL_LOAD_OP_CLEAR_ANGLE 0x96E5
+#define GL_LOAD_OP_LOAD_ANGLE 0x96E6
+#define GL_STORE_OP_STORE_ANGLE 0x96E7
+#define GL_PIXEL_LOCAL_FORMAT_ANGLE 0x96E8
+#define GL_PIXEL_LOCAL_TEXTURE_NAME_ANGLE 0x96E9
+#define GL_PIXEL_LOCAL_TEXTURE_LEVEL_ANGLE 0x96EA
+#define GL_PIXEL_LOCAL_TEXTURE_LAYER_ANGLE 0x96EB
+#define GL_PIXEL_LOCAL_CLEAR_VALUE_FLOAT_ANGLE 0x96EC
+#define GL_PIXEL_LOCAL_CLEAR_VALUE_INT_ANGLE 0x96ED
+#define GL_PIXEL_LOCAL_CLEAR_VALUE_UNSIGNED_INT_ANGLE 0x96EE
+GLAPI int GLAD_GL_ANGLE_shader_pixel_local_storage;
+GLAPI int GLAD_GL_ANGLE_shader_pixel_local_storage_coherent;
+typedef void (APIENTRYP PFNGLFRAMEBUFFERMEMORYLESSPIXELLOCALSTORAGEANGLEPROC) (GLint plane, GLenum internalformat);
+GLAPI PFNGLFRAMEBUFFERMEMORYLESSPIXELLOCALSTORAGEANGLEPROC glad_glFramebufferMemorylessPixelLocalStorageANGLE;
+#define glFramebufferMemorylessPixelLocalStorageANGLE glad_glFramebufferMemorylessPixelLocalStorageANGLE
+typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTUREPIXELLOCALSTORAGEANGLEPROC) (GLint plane, GLuint backingtexture, GLint level, GLint layer);
+GLAPI PFNGLFRAMEBUFFERTEXTUREPIXELLOCALSTORAGEANGLEPROC glad_glFramebufferTexturePixelLocalStorageANGLE;
+#define glFramebufferTexturePixelLocalStorageANGLE glad_glFramebufferTexturePixelLocalStorageANGLE
+typedef void (APIENTRYP PFNGLFRAMEBUFFERPIXELLOCALCLEARVALUEFVANGLEPROC) (GLint plane, const GLfloat value[4]);
+GLAPI PFNGLFRAMEBUFFERPIXELLOCALCLEARVALUEFVANGLEPROC glad_glFramebufferPixelLocalClearValuefvANGLE;
+#define glFramebufferPixelLocalClearValuefvANGLE glad_glFramebufferPixelLocalClearValuefvANGLE
+typedef void (APIENTRYP PFNGLFRAMEBUFFERPIXELLOCALCLEARVALUEIVANGLEPROC) (GLint plane, const GLint value[4]);
+GLAPI PFNGLFRAMEBUFFERPIXELLOCALCLEARVALUEIVANGLEPROC glad_glFramebufferPixelLocalClearValueivANGLE;
+#define glFramebufferPixelLocalClearValueivANGLE glad_glFramebufferPixelLocalClearValueivANGLE
+typedef void (APIENTRYP PFNGLFRAMEBUFFERPIXELLOCALCLEARVALUEUIVANGLEPROC) (GLint plane, const GLuint value[4]);
+GLAPI PFNGLFRAMEBUFFERPIXELLOCALCLEARVALUEUIVANGLEPROC glad_glFramebufferPixelLocalClearValueuivANGLE;
+#define glFramebufferPixelLocalClearValueuivANGLE glad_glFramebufferPixelLocalClearValueuivANGLE
+typedef void (APIENTRYP PFNGLBEGINPIXELLOCALSTORAGEANGLEPROC) (GLsizei n, const GLenum loadops[]);
+GLAPI PFNGLBEGINPIXELLOCALSTORAGEANGLEPROC glad_glBeginPixelLocalStorageANGLE;
+#define glBeginPixelLocalStorageANGLE glad_glBeginPixelLocalStorageANGLE
+typedef void (APIENTRYP PFNGLENDPIXELLOCALSTORAGEANGLEPROC) (GLsizei n, const GLenum storeops[]);
+GLAPI PFNGLENDPIXELLOCALSTORAGEANGLEPROC glad_glEndPixelLocalStorageANGLE;
+#define glEndPixelLocalStorageANGLE glad_glEndPixelLocalStorageANGLE
+typedef void (APIENTRYP PFNGLPIXELLOCALSTORAGEBARRIERANGLEPROC) ();
+GLAPI PFNGLPIXELLOCALSTORAGEBARRIERANGLEPROC glad_glPixelLocalStorageBarrierANGLE;
+#define glPixelLocalStorageBarrierANGLE glad_glPixelLocalStorageBarrierANGLE
+typedef void (APIENTRYP PFNGLGETFRAMEBUFFERPIXELLOCALSTORAGEPARAMETERFVANGLEPROC) (GLint plane, GLenum pname, GLfloat* params);
+GLAPI PFNGLGETFRAMEBUFFERPIXELLOCALSTORAGEPARAMETERFVANGLEPROC glad_glGetFramebufferPixelLocalStorageParameterfvANGLE;
+#define glGetFramebufferPixelLocalStorageParameterfvANGLE glad_glGetFramebufferPixelLocalStorageParameterfvANGLE
+typedef void (APIENTRYP PFNGLGETFRAMEBUFFERPIXELLOCALSTORAGEPARAMETERIVANGLEPROC) (GLint plane, GLenum pname, GLint* params);
+GLAPI PFNGLGETFRAMEBUFFERPIXELLOCALSTORAGEPARAMETERIVANGLEPROC glad_glGetFramebufferPixelLocalStorageParameterivANGLE;
+#define glGetFramebufferPixelLocalStorageParameterivANGLE glad_glGetFramebufferPixelLocalStorageParameterivANGLE
+#endif /* GL_ANGLE_shader_pixel_local_storage */
+
+#ifndef GL_ANGLE_polygon_mode
+#define GL_ANGLE_polygon_mode 1
+#define GL_POLYGON_MODE_ANGLE 0x0B40
+#define GL_POLYGON_OFFSET_LINE_ANGLE 0x2A02
+#define GL_LINE_ANGLE 0x1B01
+#define GL_FILL_ANGLE 0x1B02
+GLAPI int GLAD_GL_ANGLE_polygon_mode;
+typedef void (APIENTRYP PFNGLPOLYGONMODEANGLEPROC) (GLenum face, GLenum mode);
+GLAPI PFNGLPOLYGONMODEANGLEPROC glad_glPolygonModeANGLE;
+#define glPolygonModeANGLE glad_glPolygonModeANGLE
+#endif /* GL_ANGLE_polygon_mode */
+
+#ifndef GL_ANGLE_provoking_vertex
+#define GL_ANGLE_provoking_vertex 1
+#define GL_FIRST_VERTEX_CONVENTION_ANGLE 0x8E4D
+#define GL_LAST_VERTEX_CONVENTION_ANGLE 0x8E4E
+#define GL_PROVOKING_VERTEX_ANGLE 0x8E4F
+GLAPI int GLAD_GL_ANGLE_provoking_vertex;
+typedef void (APIENTRYP PFNGLPROVOKINGVERTEXANGLEPROC) (GLenum provokeMode);
+GLAPI PFNGLPROVOKINGVERTEXANGLEPROC glad_glProvokingVertexANGLE;
+#define glProvokingVertexANGLE glad_glProvokingVertexANGLE
+#endif  /* GL_ANGLE_provoking_vertex */
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/include/rive/pls/buffer_ring.hpp b/include/rive/pls/buffer_ring.hpp
index dbd6516..6593014 100644
--- a/include/rive/pls/buffer_ring.hpp
+++ b/include/rive/pls/buffer_ring.hpp
@@ -178,6 +178,8 @@
         return m_impl ? kBufferRingSize * m_impl->capacity() * m_impl->itemSizeInBytes() : 0;
     }
 
+    size_t capacity() const { return m_impl->capacity(); }
+
     // Maps the next buffer in the ring, if one is not already mapped.
     RIVE_ALWAYS_INLINE void ensureMapped()
     {
diff --git a/include/rive/pls/gl/gles3.hpp b/include/rive/pls/gl/gles3.hpp
index 9a8863e..011c357 100644
--- a/include/rive/pls/gl/gles3.hpp
+++ b/include/rive/pls/gl/gles3.hpp
@@ -4,8 +4,23 @@
 
 #pragma once
 
+struct GLExtensions
+{
+    bool ANGLE_shader_pixel_local_storage = false;
+    bool ANGLE_shader_pixel_local_storage_coherent = false;
+    bool ANGLE_polygon_mode = false;
+    bool ANGLE_provoking_vertex = false;
+    bool ARM_shader_framebuffer_fetch = false;
+    bool ARB_fragment_shader_interlock = false;
+    bool EXT_base_instance = false;
+    bool INTEL_fragment_shader_ordering = false;
+    bool EXT_shader_framebuffer_fetch = false;
+    bool EXT_shader_pixel_local_storage = false;
+    bool QCOM_shader_framebuffer_fetch_noncoherent = false;
+};
+
 #ifdef RIVE_DESKTOP_GL
-#include "glad.h"
+#include "glad_custom.h"
 #define GL_APIENTRY GLAPIENTRY
 #define GL_MAX_PIXEL_LOCAL_STORAGE_PLANES_WEBGL GL_MAX_PIXEL_LOCAL_STORAGE_PLANES_ANGLE
 #define GL_MAX_COLOR_ATTACHMENTS_WITH_ACTIVE_PIXEL_LOCAL_STORAGE_WEBGL                             \
@@ -41,6 +56,13 @@
 #include <GLES3/gl3.h>
 #include <GLES3/gl3ext.h>
 #include <GLES2/gl2ext.h>
+
+// Android doesn't load extension functions for us.
+void loadGLESExtensions(const GLExtensions&);
+extern PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEEXTPROC glDrawArraysInstancedBaseInstanceEXT;
+extern PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEEXTPROC glDrawElementsInstancedBaseInstanceEXT;
+extern PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEEXTPROC
+    glDrawElementsInstancedBaseVertexBaseInstanceEXT;
 #endif
 
 #ifdef RIVE_IOS
diff --git a/include/rive/pls/gl/pls_render_context_gl.hpp b/include/rive/pls/gl/pls_render_context_gl.hpp
index f91b627..02c0158 100644
--- a/include/rive/pls/gl/pls_render_context_gl.hpp
+++ b/include/rive/pls/gl/pls_render_context_gl.hpp
@@ -58,14 +58,11 @@
         virtual void activatePixelLocalStorage(PLSRenderContextGL*,
                                                const PLSRenderTargetGL*,
                                                LoadAction,
-                                               const ShaderFeatures&,
-                                               const DrawProgram&) = 0;
-        virtual void deactivatePixelLocalStorage(const ShaderFeatures&) = 0;
+                                               bool needsClipBuffer) = 0;
+        virtual void deactivatePixelLocalStorage() = 0;
 
         virtual const char* shaderDefineName() const = 0;
 
-        virtual const char* shaderVersionOverrideString() const { return nullptr; }
-
         virtual ~PLSImpl() {}
     };
 
@@ -90,28 +87,17 @@
         ~DrawProgram();
 
         GLuint id() const { return m_id; }
+        GLint baseInstancePolyfillLocation() const { return m_baseInstancePolyfillLocation; }
 
     private:
         GLuint m_id;
+        GLint m_baseInstancePolyfillLocation = -1;
     };
 
     class DrawShader;
 
-    struct Extensions
-    {
-        bool ANGLE_shader_pixel_local_storage = false;
-        bool ANGLE_shader_pixel_local_storage_coherent = false;
-        bool ANGLE_provoking_vertex = false;
-        bool ARM_shader_framebuffer_fetch = false;
-        bool ARB_fragment_shader_interlock = false;
-        bool INTEL_fragment_shader_ordering = false;
-        bool EXT_shader_framebuffer_fetch = false;
-        bool EXT_shader_pixel_local_storage = false;
-        bool QCOM_shader_framebuffer_fetch_noncoherent = false;
-    } m_extensions;
-
     PLSRenderContextGL(const PlatformFeatures&,
-                       const Extensions& extensions,
+                       const GLExtensions& extensions,
                        std::unique_ptr<PLSImpl>);
 
     const PLSRenderTargetGL* renderTarget() const
@@ -134,16 +120,19 @@
 
     void allocateTessellationTexture(size_t height) override;
 
-    void bindDrawProgram(const DrawProgram&);
-
     void onFlush(FlushType,
                  LoadAction,
                  size_t gradSpanCount,
                  size_t gradSpansHeight,
                  size_t tessVertexSpanCount,
                  size_t tessDataHeight,
-                 size_t wedgeInstanceCount,
-                 const ShaderFeatures&) override;
+                 bool needsClipBuffer) override;
+
+    GLExtensions m_extensions;
+
+    constexpr static size_t kShaderVersionStringBuffSize = sizeof("#version 300 es\n") + 1;
+    char m_shaderVersionString[kShaderVersionStringBuffSize];
+    bool m_supportsBaseInstanceInShader = false;
 
     std::unique_ptr<PLSImpl> m_plsImpl;
 
diff --git a/include/rive/pls/metal/pls_render_context_metal.h b/include/rive/pls/metal/pls_render_context_metal.h
index dda24cc..17846a8 100644
--- a/include/rive/pls/metal/pls_render_context_metal.h
+++ b/include/rive/pls/metal/pls_render_context_metal.h
@@ -58,8 +58,7 @@
                  size_t gradSpansHeight,
                  size_t tessVertexSpanCount,
                  size_t tessDataHeight,
-                 size_t wedgeInstanceCount,
-                 const ShaderFeatures&) override;
+                 bool needsClipBuffer) override;
 
     const id<MTLDevice> m_gpu;
     const id<MTLCommandQueue> m_queue;
diff --git a/include/rive/pls/pls_render_context.hpp b/include/rive/pls/pls_render_context.hpp
index 2e58ec4..58b1ae8 100644
--- a/include/rive/pls/pls_render_context.hpp
+++ b/include/rive/pls/pls_render_context.hpp
@@ -9,6 +9,7 @@
 #include "rive/pls/buffer_ring.hpp"
 #include "rive/pls/pls.hpp"
 #include "rive/pls/pls_render_target.hpp"
+#include "rive/pls/trivial_block_allocator.hpp"
 #include "rive/shapes/paint/color.hpp"
 #include <functional>
 #include <unordered_map>
@@ -311,12 +312,36 @@
                          size_t gradSpansHeight,
                          size_t tessVertexSpanCount,
                          size_t tessDataHeight,
-                         size_t tessVertexCount,
-                         const ShaderFeatures&) = 0;
+                         bool needsClipBuffer) = 0;
 
     const PlatformFeatures m_platformFeatures;
     const size_t m_maxPathID;
 
+    enum class DrawType
+    {
+        pathWedges, // Standard paths and/or strokes.
+    };
+
+    // Linked list of draws to be issued by the subclass during onFlush().
+    struct DrawList
+    {
+        DrawList(DrawType drawType_, size_t baseVertex_) :
+            drawType(drawType_), baseVertex(baseVertex_)
+        {}
+        const DrawType drawType;
+        const size_t baseVertex;
+        size_t vertexCount = 0; // Calculated during PLSRenderContext::flush().
+        ShaderFeatures shaderFeatures;
+        DrawList* next = nullptr;
+    };
+
+    DrawList* m_drawList = nullptr;
+    DrawList* m_lastDraw = nullptr;
+    size_t m_drawListCount = 0;
+
+    constexpr static size_t kPerFlushAllocatorInitialBlockSize = 1024 * 1024; // 1 MiB.
+    TrivialBlockAllocator m_perFlushAllocator{kPerFlushAllocatorInitialBlockSize};
+
 private:
     static BlendTier BlendTierForBlendMode(PLSBlendMode);
 
@@ -324,6 +349,10 @@
     // upload or draw that fills it with the given gradient's color ramp.
     [[nodiscard]] bool pushGradient(const PLSGradient*, PaintData*);
 
+    // Either appends a draw to m_drawList or merges into m_lastDraw.
+    // The caller is responsible for updating the returned ShaderFeatures to reflect its use case.
+    [[nodiscard]] ShaderFeatures* pushDraw(DrawType, size_t baseVertex);
+
     // Capacities of all our GPU resource allocations.
     struct GPUResourceLimits
     {
@@ -456,8 +485,5 @@
     // the entire gradient texture width.
     std::unordered_map<GradientContentKey, uint32_t, DeepHashGradient>
         m_complexGradients; // [colors[0..n], stops[0..n]] -> rowIdx
-
-    // Combined set of "uber shader" features used by all currently-pushed paths.
-    ShaderFeatures m_shaderFeatures;
 };
 } // namespace rive::pls
diff --git a/include/rive/pls/trivial_block_allocator.hpp b/include/rive/pls/trivial_block_allocator.hpp
index 60fad54..4716502 100644
--- a/include/rive/pls/trivial_block_allocator.hpp
+++ b/include/rive/pls/trivial_block_allocator.hpp
@@ -14,7 +14,20 @@
 class TrivialBlockAllocator
 {
 public:
-    TrivialBlockAllocator(size_t initialBlockSize) : m_initialBlockSize(initialBlockSize) {}
+    TrivialBlockAllocator(size_t initialBlockSize) : m_initialBlockSize(initialBlockSize)
+    {
+        m_blocks.push_back(std::unique_ptr<char[]>(new char[m_initialBlockSize]));
+        reset();
+    }
+
+    void reset()
+    {
+        m_fibMinus2 = 0;
+        m_fibMinus1 = 1;
+        m_blocks.resize(1);
+        m_currentBlockSize = m_initialBlockSize;
+        m_currentBlockUsage = 0;
+    }
 
     void* alloc(size_t allocSize)
     {
@@ -56,11 +69,11 @@
     const size_t m_initialBlockSize;
 
     // Grow block sizes using a fibonacci function.
-    size_t m_fibMinus2 = 0;
-    size_t m_fibMinus1 = 1;
+    size_t m_fibMinus2;
+    size_t m_fibMinus1;
 
     std::vector<std::unique_ptr<char[]>> m_blocks;
-    size_t m_currentBlockSize = 0;
-    size_t m_currentBlockUsage = 0;
+    size_t m_currentBlockSize;
+    size_t m_currentBlockUsage;
 };
 } // namespace rive
diff --git a/out/premake5_pls_renderer.lua b/out/premake5_pls_renderer.lua
index 38db01a..d96670f 100644
--- a/out/premake5_pls_renderer.lua
+++ b/out/premake5_pls_renderer.lua
@@ -18,7 +18,7 @@
 filter "system:windows or macosx or linux"
 do
     -- Define RIVE_DESKTOP_GL outside of a project so that it also gets defined for consumers. It is
-    -- the responsibility of consumers to call gladLoadGLES2Loader() when RIVE_DESKTOP_GL is
+    -- the responsibility of consumers to call gladLoadCustomLoader() when RIVE_DESKTOP_GL is
     -- defined.
     defines {"RIVE_DESKTOP_GL"}
 end
@@ -129,14 +129,16 @@
     do
         files {"../renderer/gl/pls_impl_webgl.cpp", -- Emulate WebGL with ANGLE.
                "../renderer/gl/pls_impl_rw_texture.cpp",
-               "../glad/glad.c"}  -- GL loader library for ANGLE.
+               "../glad/glad.c",
+               "../glad/glad_custom.c"}  -- GL loader library for ANGLE.
     end
 
     filter "system:android"
     do
         targetdir "android_%{cfg.buildcfg}"
         objdir "obj/android_%{cfg.buildcfg}"
-        files {"../renderer/gl/pls_impl_ext_native.cpp",
+        files {"../renderer/gl/load_gles_extensions.cpp",
+               "../renderer/gl/pls_impl_ext_native.cpp",
                "../renderer/gl/pls_impl_framebuffer_fetch.cpp"}
     end
 
diff --git a/path_fiddle/fiddle_context_gl.cpp b/path_fiddle/fiddle_context_gl.cpp
index cc2ee8a..69e3789 100644
--- a/path_fiddle/fiddle_context_gl.cpp
+++ b/path_fiddle/fiddle_context_gl.cpp
@@ -48,7 +48,7 @@
     {
 #ifdef RIVE_DESKTOP_GL
         // Load the OpenGL API using glad.
-        if (!gladLoadGLES2Loader((GLADloadproc)glfwGetProcAddress))
+        if (!gladLoadCustomLoader((GLADloadproc)glfwGetProcAddress))
         {
             fprintf(stderr, "Failed to initialize glad.\n");
             exit(-1);
diff --git a/path_fiddle/path_fiddle.cpp b/path_fiddle/path_fiddle.cpp
index 35a629d..4131c1c 100644
--- a/path_fiddle/path_fiddle.cpp
+++ b/path_fiddle/path_fiddle.cpp
@@ -340,9 +340,6 @@
     else
     {
         glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_API);
-        glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
-        glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 5);
-        glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
     }
     g_window = glfwCreateWindow(1600, 1600, "Rive Renderer", nullptr, nullptr);
     if (!g_window)
diff --git a/renderer/gl/load_gles_extensions.cpp b/renderer/gl/load_gles_extensions.cpp
new file mode 100644
index 0000000..eb64777
--- /dev/null
+++ b/renderer/gl/load_gles_extensions.cpp
@@ -0,0 +1,30 @@
+/*
+ * Copyright 2023 Rive
+ */
+
+#include "rive/pls/gl/gles3.hpp"
+
+#include <EGL/egl.h>
+
+PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEEXTPROC glDrawArraysInstancedBaseInstanceEXT = nullptr;
+PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEEXTPROC glDrawElementsInstancedBaseInstanceEXT = nullptr;
+PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEEXTPROC
+glDrawElementsInstancedBaseVertexBaseInstanceEXT = nullptr;
+
+void loadGLESExtensions(const GLExtensions& extensions)
+{
+    static GLExtensions loadedExtensions{};
+    if (extensions.EXT_base_instance && !loadedExtensions.EXT_base_instance)
+    {
+        glDrawArraysInstancedBaseInstanceEXT =
+            (PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEEXTPROC)eglGetProcAddress(
+                "glDrawArraysInstancedBaseInstanceEXT");
+        glDrawElementsInstancedBaseInstanceEXT =
+            (PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEEXTPROC)eglGetProcAddress(
+                "glDrawElementsInstancedBaseInstanceEXT");
+        glDrawElementsInstancedBaseVertexBaseInstanceEXT =
+            (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEEXTPROC)eglGetProcAddress(
+                "glDrawElementsInstancedBaseVertexBaseInstanceEXT");
+        loadedExtensions.EXT_base_instance = true;
+    }
+}
diff --git a/renderer/gl/pls_impl_ext_native.cpp b/renderer/gl/pls_impl_ext_native.cpp
index fa49cad..61ecc52 100644
--- a/renderer/gl/pls_impl_ext_native.cpp
+++ b/renderer/gl/pls_impl_ext_native.cpp
@@ -21,8 +21,7 @@
 constexpr static uint32_t kLoadColor = 2;
 constexpr static uint32_t kStoreColor = 4;
 constexpr static uint32_t kClearCoverage = 8;
-constexpr static uint32_t kDeclareClip = 16;
-constexpr static uint32_t kClearClip = 32;
+constexpr static uint32_t kClearClip = 16;
 }; // namespace loadstoreops
 
 namespace rive::pls
@@ -53,10 +52,6 @@
         {
             defines.push_back(GLSL_CLEAR_COVERAGE);
         }
-        if (ops & loadstoreops::kDeclareClip)
-        {
-            defines.push_back(GLSL_DECLARE_CLIP);
-        }
         if (ops & loadstoreops::kClearClip)
         {
             defines.push_back(GLSL_CLEAR_CLIP);
@@ -133,8 +128,7 @@
     void activatePixelLocalStorage(PLSRenderContextGL* context,
                                    const PLSRenderTargetGL* renderTarget,
                                    LoadAction loadAction,
-                                   const ShaderFeatures& shaderFeatures,
-                                   const DrawProgram& drawProgram) override
+                                   bool needsClipBuffer) override
     {
         assert(context->m_extensions.EXT_shader_pixel_local_storage);
         assert(context->m_extensions.EXT_shader_framebuffer_fetch ||
@@ -154,9 +148,9 @@
         {
             ops |= loadstoreops::kLoadColor;
         }
-        if (shaderFeatures.programFeatures.enablePathClipping)
+        if (needsClipBuffer)
         {
-            ops |= loadstoreops::kDeclareClip | loadstoreops::kClearClip;
+            ops |= loadstoreops::kClearClip;
         }
         if ((ops & loadstoreops::kClearColor) && simd::all(simd::load4f(clearColor4f) == 0))
         {
@@ -175,19 +169,13 @@
             glBindVertexArray(m_plsLoadStoreVAO);
             glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
         }
-
-        context->bindDrawProgram(drawProgram);
     }
 
-    void deactivatePixelLocalStorage(const ShaderFeatures& shaderFeatures) override
+    void deactivatePixelLocalStorage() override
     {
         // Issue a fullscreen draw that transfers the color information in pixel local storage to
         // the main framebuffer.
         uint32_t ops = loadstoreops::kStoreColor;
-        if (shaderFeatures.programFeatures.enablePathClipping)
-        {
-            ops |= loadstoreops::kDeclareClip;
-        }
         const PLSLoadStoreProgram& plsProgram =
             m_plsLoadStorePrograms.try_emplace(ops, ops, m_plsLoadStoreVertexShader).first->second;
         plsProgram.bind(nullptr);
diff --git a/renderer/gl/pls_impl_framebuffer_fetch.cpp b/renderer/gl/pls_impl_framebuffer_fetch.cpp
index 22fedaf..7314887 100644
--- a/renderer/gl/pls_impl_framebuffer_fetch.cpp
+++ b/renderer/gl/pls_impl_framebuffer_fetch.cpp
@@ -47,24 +47,22 @@
     void activatePixelLocalStorage(PLSRenderContextGL* context,
                                    const PLSRenderTargetGL* renderTarget,
                                    LoadAction loadAction,
-                                   const ShaderFeatures& shaderFeatures,
-                                   const DrawProgram& drawProgram) override
+                                   bool needsClipBuffer) override
     {
         assert(context->m_extensions.EXT_shader_framebuffer_fetch);
 
         glBindFramebuffer(GL_FRAMEBUFFER, renderTarget->drawFramebufferID());
 
         // Enable multiple render targets, with a draw buffer for each PLS plane.
-        GLsizei numDrawBuffers = shaderFeatures.programFeatures.enablePathClipping ? 4 : 3;
-        glDrawBuffers(numDrawBuffers, kPLSDrawBuffers);
+        glDrawBuffers(4, kPLSDrawBuffers);
 
         // Instruct the driver not to load existing PLS plane contents into tiled memory, with the
         // exception of the color buffer after an intermediate flush.
         static_assert(kFramebufferPlaneIdx == 0);
-        glInvalidateFramebuffer(
-            GL_FRAMEBUFFER,
-            loadAction == LoadAction::clear ? numDrawBuffers : numDrawBuffers - 1,
-            loadAction == LoadAction::clear ? kPLSDrawBuffers : kPLSDrawBuffers + 1);
+        glInvalidateFramebuffer(GL_FRAMEBUFFER,
+                                loadAction == LoadAction::clear ? 4 : 3,
+                                loadAction == LoadAction::clear ? kPLSDrawBuffers
+                                                                : kPLSDrawBuffers + 1);
 
         // Clear the PLS planes.
         constexpr static uint32_t kZero[4]{};
@@ -75,21 +73,18 @@
             glClearBufferfv(GL_COLOR, kFramebufferPlaneIdx, clearColor4f);
         }
         glClearBufferuiv(GL_COLOR, kCoveragePlaneIdx, kZero);
-        if (shaderFeatures.programFeatures.enablePathClipping)
+        if (needsClipBuffer)
         {
             glClearBufferuiv(GL_COLOR, kClipPlaneIdx, kZero);
         }
-
-        context->bindDrawProgram(drawProgram);
     }
 
-    void deactivatePixelLocalStorage(const ShaderFeatures& shaderFeatures) override
+    void deactivatePixelLocalStorage() override
     {
         // Instruct the driver not to flush PLS contents from tiled memory, with the exception of
         // the color buffer.
         static_assert(kFramebufferPlaneIdx == 0);
-        GLsizei numDrawBuffers = shaderFeatures.programFeatures.enablePathClipping ? 4 : 3;
-        glInvalidateFramebuffer(GL_FRAMEBUFFER, numDrawBuffers - 1, kPLSDrawBuffers + 1);
+        glInvalidateFramebuffer(GL_FRAMEBUFFER, 3, kPLSDrawBuffers + 1);
 
         // Don't restore glDrawBuffers. The client can assume we've changed it, if we have a wrapped
         // render target.
diff --git a/renderer/gl/pls_impl_rw_texture.cpp b/renderer/gl/pls_impl_rw_texture.cpp
index 2ded55f..b386ac0 100644
--- a/renderer/gl/pls_impl_rw_texture.cpp
+++ b/renderer/gl/pls_impl_rw_texture.cpp
@@ -42,8 +42,7 @@
     void activatePixelLocalStorage(PLSRenderContextGL* context,
                                    const PLSRenderTargetGL* renderTarget,
                                    LoadAction loadAction,
-                                   const ShaderFeatures& shaderFeatures,
-                                   const DrawProgram& drawProgram) override
+                                   bool needsClipBuffer) override
     {
         // Clear the necessary textures.
         constexpr static GLuint kZero[4]{};
@@ -55,7 +54,7 @@
             glClearBufferfv(GL_COLOR, kFramebufferPlaneIdx, clearColor4f);
         }
         glClearBufferuiv(GL_COLOR, kCoveragePlaneIdx, kZero);
-        if (shaderFeatures.programFeatures.enablePathClipping)
+        if (needsClipBuffer)
         {
             glClearBufferuiv(GL_COLOR, kClipPlaneIdx, kZero);
         }
@@ -82,7 +81,7 @@
                            0,
                            GL_READ_WRITE,
                            GL_RGBA8);
-        if (shaderFeatures.programFeatures.enablePathClipping)
+        if (needsClipBuffer)
         {
             glBindImageTexture(kClipPlaneIdx,
                                renderTarget->m_clipTextureID,
@@ -94,21 +93,12 @@
         }
 
         glBindFramebuffer(GL_FRAMEBUFFER, renderTarget->drawFramebufferID());
-        context->bindDrawProgram(drawProgram);
         glMemoryBarrier(GL_SHADER_IMAGE_ACCESS_BARRIER_BIT);
     }
 
-    void deactivatePixelLocalStorage(const ShaderFeatures& shaderFeatures) override
-    {
-        glMemoryBarrier(GL_ALL_BARRIER_BITS);
-    }
+    void deactivatePixelLocalStorage() override { glMemoryBarrier(GL_ALL_BARRIER_BITS); }
 
     const char* shaderDefineName() const override { return GLSL_PLS_IMPL_RW_TEXTURE; }
-
-    const char* shaderVersionOverrideString() const override
-    {
-        return "#version 420\n"; // imageLoad/Store() appear in GLSL 420.
-    }
 };
 
 std::unique_ptr<PLSRenderContextGL::PLSImpl> PLSRenderContextGL::MakePLSImplRWTexture()
diff --git a/renderer/gl/pls_impl_webgl.cpp b/renderer/gl/pls_impl_webgl.cpp
index 2ad9c49..d76f26a 100644
--- a/renderer/gl/pls_impl_webgl.cpp
+++ b/renderer/gl/pls_impl_webgl.cpp
@@ -56,16 +56,10 @@
     void activatePixelLocalStorage(PLSRenderContextGL* context,
                                    const PLSRenderTargetGL* renderTarget,
                                    LoadAction loadAction,
-                                   const ShaderFeatures& shaderFeatures,
-                                   const DrawProgram& drawProgram) override
+                                   bool needsClipBuffer) override
     {
         glBindFramebuffer(GL_FRAMEBUFFER, renderTarget->drawFramebufferID());
 
-        // Bind these before activating pixel local storage, so they don't count against our GL call
-        // count in Chrome while pixel local storage is active, reducing our chances of the render
-        // pass being interrupted.
-        context->bindDrawProgram(drawProgram);
-
         if (loadAction == LoadAction::clear)
         {
             float clearColor4f[4];
@@ -77,20 +71,18 @@
                                                                       : GL_LOAD_OP_LOAD_WEBGL),
                              GL_LOAD_OP_ZERO_WEBGL,
                              GL_DONT_CARE,
-                             GL_LOAD_OP_ZERO_WEBGL};
+                             (GLenum)(needsClipBuffer ? GL_LOAD_OP_ZERO_WEBGL : GL_DONT_CARE)};
 
-        glBeginPixelLocalStorageWEBGL(shaderFeatures.programFeatures.enablePathClipping ? 4 : 3,
-                                      loadOps);
+        glBeginPixelLocalStorageWEBGL(4, loadOps);
     }
 
-    void deactivatePixelLocalStorage(const ShaderFeatures& shaderFeatures) override
+    void deactivatePixelLocalStorage() override
     {
         constexpr static GLenum kStoreOps[4] = {GL_STORE_OP_STORE_WEBGL,
                                                 GL_DONT_CARE,
                                                 GL_DONT_CARE,
                                                 GL_DONT_CARE};
-        glEndPixelLocalStorageWEBGL(shaderFeatures.programFeatures.enablePathClipping ? 4 : 3,
-                                    kStoreOps);
+        glEndPixelLocalStorageWEBGL(4, kStoreOps);
     }
 
     const char* shaderDefineName() const override { return GLSL_PLS_IMPL_WEBGL; }
diff --git a/renderer/gl/pls_render_context_gl.cpp b/renderer/gl/pls_render_context_gl.cpp
index fbe1aeb..a9308a3 100644
--- a/renderer/gl/pls_render_context_gl.cpp
+++ b/renderer/gl/pls_render_context_gl.cpp
@@ -16,13 +16,6 @@
 #include "../out/obj/generated/math.glsl.hpp"
 #include "../out/obj/generated/tessellate.glsl.hpp"
 
-// ES doesn't have wireframe support. Use a hacked ANGLE driver that repurposes glPolygonOffset as a
-// back door to turn on wireframe in the backend.
-#define glPolygonMode(face, mode) glPolygonOffset(float(face), float(mode))
-#define GL_POINT 0x1B00
-#define GL_LINE 0x1B01
-#define GL_FILL 0x1B02
-
 // Offset all texture indices by 1 so we, and others who share our GL context, can use GL_TEXTURE0
 // as a scratch texture index.
 constexpr static int kGLTexIdxOffset = 1;
@@ -40,14 +33,35 @@
 #endif
 
 PLSRenderContextGL::PLSRenderContextGL(const PlatformFeatures& platformFeatures,
-                                       const Extensions& extensions,
+                                       const GLExtensions& extensions,
                                        std::unique_ptr<PLSImpl> plsImpl) :
     PLSRenderContext(platformFeatures), m_extensions(extensions), m_plsImpl(std::move(plsImpl))
 
 {
+    m_shaderVersionString[kShaderVersionStringBuffSize - 1] = '\0';
+    strncpy(m_shaderVersionString, "#version 300 es\n", kShaderVersionStringBuffSize - 1);
+#ifdef RIVE_DESKTOP_GL
+    if (!GLAD_GL_version_es && GLAD_IS_GL_VERSION_AT_LEAST(4, 0))
+    {
+        snprintf(m_shaderVersionString,
+                 kShaderVersionStringBuffSize,
+                 "#version %d%d0\n",
+                 GLAD_GL_version_major,
+                 GLAD_GL_version_minor);
+        m_supportsBaseInstanceInShader = GLAD_IS_GL_VERSION_AT_LEAST(4, 6);
+    }
+#endif
+    assert(!m_supportsBaseInstanceInShader || m_extensions.EXT_base_instance);
+
     m_colorRampProgram = glCreateProgram();
-    glutils::CompileAndAttachShader(m_colorRampProgram, GL_VERTEX_SHADER, glsl::color_ramp);
-    glutils::CompileAndAttachShader(m_colorRampProgram, GL_FRAGMENT_SHADER, glsl::color_ramp);
+    glutils::CompileAndAttachShader(m_colorRampProgram,
+                                    GL_VERTEX_SHADER,
+                                    glsl::color_ramp,
+                                    m_shaderVersionString);
+    glutils::CompileAndAttachShader(m_colorRampProgram,
+                                    GL_FRAGMENT_SHADER,
+                                    glsl::color_ramp,
+                                    m_shaderVersionString);
     glutils::LinkProgram(m_colorRampProgram);
     glUniformBlockBinding(m_colorRampProgram,
                           glGetUniformBlockIndex(m_colorRampProgram, GLSL_Uniforms),
@@ -67,13 +81,15 @@
                                     nullptr,
                                     0,
                                     tessellateSources,
-                                    2);
+                                    2,
+                                    m_shaderVersionString);
     glutils::CompileAndAttachShader(m_tessellateProgram,
                                     GL_FRAGMENT_SHADER,
                                     nullptr,
                                     0,
                                     tessellateSources,
-                                    2);
+                                    2,
+                                    m_shaderVersionString);
     glutils::LinkProgram(m_tessellateProgram);
     glUniformBlockBinding(m_tessellateProgram,
                           glGetUniformBlockIndex(m_tessellateProgram, GLSL_Uniforms),
@@ -201,16 +217,13 @@
     DrawShader(const DrawShader&) = delete;
     DrawShader& operator=(const DrawShader&) = delete;
 
-    DrawShader(GLenum shaderType,
-               const ShaderFeatures& shaderFeatures,
-               const PlatformFeatures& platformFeatures,
-               const PLSImpl* plsImpl)
+    DrawShader(PLSRenderContextGL* context, GLenum shaderType, const ShaderFeatures& shaderFeatures)
     {
         auto sourceType =
             shaderType == GL_VERTEX_SHADER ? SourceType::vertexOnly : SourceType::wholeProgram;
 
         std::vector<const char*> defines;
-        defines.push_back(plsImpl->shaderDefineName());
+        defines.push_back(context->m_plsImpl->shaderDefineName());
         uint64_t shaderFeatureDefines = shaderFeatures.getPreprocessorDefines(sourceType);
         if (shaderFeatureDefines & ShaderFeatures::PreprocessorDefines::ENABLE_ADVANCED_BLEND)
         {
@@ -228,6 +241,10 @@
         {
             defines.push_back(GLSL_ENABLE_HSL_BLEND_MODES);
         }
+        if (shaderType == GL_VERTEX_SHADER && !context->m_supportsBaseInstanceInShader)
+        {
+            defines.push_back(GLSL_BASE_INSTANCE_POLYFILL);
+        }
 
         std::vector<const char*> sources;
         sources.push_back(glsl::math);
@@ -238,7 +255,7 @@
                 sources.push_back(glsl::advanced_blend);
             }
         }
-        if (platformFeatures.avoidFlatVaryings)
+        if (context->m_platformFeatures.avoidFlatVaryings)
         {
             sources.push_back("#define " GLSL_OPTIONALLY_FLAT "\n");
         }
@@ -252,7 +269,7 @@
                                       defines.size(),
                                       sources.data(),
                                       sources.size(),
-                                      plsImpl->shaderVersionOverrideString());
+                                      context->m_shaderVersionString);
     }
 
     ~DrawShader() { glDeleteShader(m_id); }
@@ -271,20 +288,14 @@
     // Not every vertex shader is unique. Cache them by just the vertex features and reuse when
     // possible.
     uint64_t vertexShaderKey = shaderFeatures.getPreprocessorDefines(SourceType::vertexOnly);
-    const DrawShader& vertexShader = context->m_vertexShaders
-                                         .try_emplace(vertexShaderKey,
-                                                      GL_VERTEX_SHADER,
-                                                      shaderFeatures,
-                                                      context->m_platformFeatures,
-                                                      context->m_plsImpl.get())
-                                         .first->second;
+    const DrawShader& vertexShader =
+        context->m_vertexShaders
+            .try_emplace(vertexShaderKey, context, GL_VERTEX_SHADER, shaderFeatures)
+            .first->second;
     glAttachShader(m_id, vertexShader.id());
 
     // Every fragment shader is unique.
-    DrawShader fragmentShader(GL_FRAGMENT_SHADER,
-                              shaderFeatures,
-                              context->m_platformFeatures,
-                              context->m_plsImpl.get());
+    DrawShader fragmentShader(context, GL_FRAGMENT_SHADER, shaderFeatures);
     glAttachShader(m_id, fragmentShader.id());
 
     glutils::LinkProgram(m_id);
@@ -297,6 +308,10 @@
     glUniform1i(glGetUniformLocation(m_id, GLSL_contourTexture),
                 kGLTexIdxOffset + kContourTextureIdx);
     glUniform1i(glGetUniformLocation(m_id, GLSL_gradTexture), kGLTexIdxOffset + kGradTextureIdx);
+    if (!context->m_supportsBaseInstanceInShader)
+    {
+        m_baseInstancePolyfillLocation = glGetUniformLocation(m_id, GLSL_baseInstancePolyfill);
+    }
 }
 
 PLSRenderContextGL::DrawProgram::~DrawProgram() { glDeleteProgram(m_id); }
@@ -311,21 +326,13 @@
     return static_cast<const TexelBufferGL*>(texelBufferRing)->submittedTextureID();
 }
 
-void PLSRenderContextGL::bindDrawProgram(const DrawProgram& drawProgram)
-{
-    glBindVertexArray(m_drawVAO);
-    glBindBufferBase(GL_UNIFORM_BUFFER, 0, gl_buffer_id(drawUniforms()));
-    glUseProgram(drawProgram.id());
-}
-
 void PLSRenderContextGL::onFlush(FlushType flushType,
                                  LoadAction loadAction,
                                  size_t gradSpanCount,
                                  size_t gradSpansHeight,
                                  size_t tessVertexSpanCount,
                                  size_t tessDataHeight,
-                                 size_t wedgeInstanceCount,
-                                 const ShaderFeatures& shaderFeatures)
+                                 bool needsClipBuffer)
 {
     // Render the complex color ramps to the gradient texture.
     if (gradSpanCount > 0)
@@ -371,48 +378,84 @@
         glDrawArraysInstanced(GL_TRIANGLE_STRIP, 0, 4, tessVertexSpanCount);
     }
 
+    // Compile the draw programs before activating pixel local storage.
+    // (ANGLE_shader_pixel_local_storage doesn't allow shader compilation while active.)
+    size_t drawIdx = 0;
+    auto drawPrograms = reinterpret_cast<const DrawProgram**>(
+        m_perFlushAllocator.alloc(sizeof(void*) * m_drawListCount));
+    for (DrawList* draw = m_drawList; draw; draw = draw->next, ++drawIdx)
+    {
+        // Compile the draw program before activating pixel local storage.
+        // Cache specific compilations of draw.glsl by ShaderFeatures.
+        const ShaderFeatures& shaderFeatures = draw->shaderFeatures;
+        uint64_t fragmentShaderKey =
+            shaderFeatures.getPreprocessorDefines(SourceType::wholeProgram);
+        drawPrograms[drawIdx] =
+            &m_drawPrograms.try_emplace(fragmentShaderKey, this, shaderFeatures).first->second;
+    }
+    assert(drawIdx == m_drawListCount);
+
     glViewport(0, 0, renderTarget()->width(), renderTarget()->height());
 
-    // Compile the draw program before activating pixel local storage.
-    // Cache specific compilations of draw.glsl by ShaderFeatures.
-    uint64_t fragmentShaderKey = shaderFeatures.getPreprocessorDefines(SourceType::wholeProgram);
-    const DrawProgram& drawProgram =
-        m_drawPrograms.try_emplace(fragmentShaderKey, this, shaderFeatures).first->second;
-
-    if (frameDescriptor().wireframe)
+#ifdef RIVE_DESKTOP_GL
+    if (m_extensions.ANGLE_polygon_mode && frameDescriptor().wireframe)
     {
-        glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
+        glPolygonModeANGLE(GL_FRONT_AND_BACK, GL_LINE_ANGLE);
         glLineWidth(2);
     }
+#endif
 
-    m_plsImpl->activatePixelLocalStorage(this,
-                                         renderTarget(),
-                                         loadAction,
-                                         shaderFeatures,
-                                         drawProgram);
+    m_plsImpl->activatePixelLocalStorage(this, renderTarget(), loadAction, needsClipBuffer);
 
-    if (wedgeInstanceCount > 0)
+    // Issue all the draws.
+    glBindVertexArray(m_drawVAO);
+    glBindBufferBase(GL_UNIFORM_BUFFER, 0, gl_buffer_id(drawUniforms()));
+    drawIdx = 0;
+    for (DrawList* draw = m_drawList; draw; draw = draw->next, ++drawIdx)
     {
         // Draw wedges connecting all tessellated vertices.
-        glDrawElementsInstanced(GL_TRIANGLES,
-                                kOuterStrokeWedgeIndexCount,
-                                GL_UNSIGNED_SHORT,
-                                nullptr,
-                                wedgeInstanceCount);
+        const DrawProgram* drawProgram = drawPrograms[drawIdx];
+        glUseProgram(drawProgram->id());
+        size_t wedgeInstanceCount = draw->vertexCount / kWedgeSize;
+        assert(wedgeInstanceCount > 0);
+        assert(wedgeInstanceCount * kWedgeSize == draw->vertexCount);
+        size_t wedgeBaseInstance = draw->baseVertex / kWedgeSize;
+        assert(wedgeBaseInstance * kWedgeSize == draw->baseVertex);
+        if (m_supportsBaseInstanceInShader)
+        {
+            glDrawElementsInstancedBaseInstanceEXT(GL_TRIANGLES,
+                                                   kOuterStrokeWedgeIndexCount,
+                                                   GL_UNSIGNED_SHORT,
+                                                   nullptr,
+                                                   wedgeInstanceCount,
+                                                   wedgeBaseInstance);
+        }
+        else
+        {
+            glUniform1i(drawProgram->baseInstancePolyfillLocation(), wedgeBaseInstance);
+            glDrawElementsInstanced(GL_TRIANGLES,
+                                    kOuterStrokeWedgeIndexCount,
+                                    GL_UNSIGNED_SHORT,
+                                    nullptr,
+                                    wedgeInstanceCount);
+        }
     }
+    assert(drawIdx == m_drawListCount);
 
-    m_plsImpl->deactivatePixelLocalStorage(shaderFeatures);
+    m_plsImpl->deactivatePixelLocalStorage();
 
-    if (frameDescriptor().wireframe)
+#ifdef RIVE_DESKTOP_GL
+    if (m_extensions.ANGLE_polygon_mode && frameDescriptor().wireframe)
     {
-        glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+        glPolygonModeANGLE(GL_FRONT_AND_BACK, GL_FILL_ANGLE);
     }
+#endif
 }
 
 std::unique_ptr<PLSRenderContextGL> PLSRenderContextGL::Make()
 {
-    Extensions extensions;
-    int extensionCount;
+    GLExtensions extensions;
+    GLint extensionCount;
     glGetIntegerv(GL_NUM_EXTENSIONS, &extensionCount);
     for (int i = 0; i < extensionCount; ++i)
     {
@@ -429,6 +472,10 @@
         {
             extensions.ANGLE_provoking_vertex = true;
         }
+        else if (strcmp(ext, "GL_ANGLE_polygon_mode") == 0)
+        {
+            extensions.ANGLE_polygon_mode = true;
+        }
         else if (strcmp(ext, "GL_ARM_shader_framebuffer_fetch") == 0)
         {
             extensions.ARM_shader_framebuffer_fetch = true;
@@ -437,6 +484,10 @@
         {
             extensions.ARB_fragment_shader_interlock = true;
         }
+        else if (strcmp(ext, "GL_EXT_base_instance") == 0)
+        {
+            extensions.EXT_base_instance = true;
+        }
         else if (strcmp(ext, "GL_INTEL_fragment_shader_ordering") == 0)
         {
             extensions.INTEL_fragment_shader_ordering = true;
@@ -454,6 +505,17 @@
             extensions.QCOM_shader_framebuffer_fetch_noncoherent = true;
         }
     }
+#ifdef RIVE_DESKTOP_GL
+    // We implement some ES extensions with core Desktop GL in glad_custom.c.
+    if (GLAD_GL_ANGLE_polygon_mode)
+    {
+        extensions.ANGLE_polygon_mode = true;
+    }
+    if (GLAD_GL_EXT_base_instance)
+    {
+        extensions.EXT_base_instance = true;
+    }
+#endif
 
     PlatformFeatures platformFeatures;
     GLenum rendererToken = GL_RENDERER;
@@ -474,6 +536,7 @@
     }
 
 #ifdef RIVE_GLES
+    loadGLESExtensions(extensions); // Android doesn't load extension functions for us.
     if (extensions.EXT_shader_pixel_local_storage &&
         (extensions.ARM_shader_framebuffer_fetch || extensions.EXT_shader_framebuffer_fetch))
     {
diff --git a/renderer/metal/pls_render_context_metal.mm b/renderer/metal/pls_render_context_metal.mm
index 6855622..19666bf 100644
--- a/renderer/metal/pls_render_context_metal.mm
+++ b/renderer/metal/pls_render_context_metal.mm
@@ -290,8 +290,7 @@
                                     size_t gradSpansHeight,
                                     size_t tessVertexSpanCount,
                                     size_t tessDataHeight,
-                                    size_t wedgeInstanceCount,
-                                    const ShaderFeatures& shaderFeatures)
+                                    bool needsClipBuffer)
 {
     auto* renderTarget =
         static_cast<const PLSRenderTargetMetal*>(frameDescriptor().renderTarget.get());
@@ -394,38 +393,48 @@
     pass.colorAttachments[3].storeAction = MTLStoreActionDontCare;
 
     id<MTLRenderCommandEncoder> encoder = [commandBuffer renderCommandEncoderWithDescriptor:pass];
-    if (wedgeInstanceCount > 0)
+    [encoder setViewport:(MTLViewport){0.f,
+                                       0.f,
+                                       static_cast<float>(renderTarget->width()),
+                                       static_cast<float>(renderTarget->height()),
+                                       0.0,
+                                       1.0}];
+    [encoder setVertexBuffer:mtl_buffer(drawUniforms()) offset:0 atIndex:0];
+    [encoder setVertexBuffer:m_pathWedgeVertexBuffer offset:0 atIndex:1];
+    [encoder setVertexTexture:m_tessVertexTexture atIndex:kTessVertexTextureIdx];
+    [encoder setVertexTexture:mtl_texture(pathBufferRing()) atIndex:kPathTextureIdx];
+    [encoder setVertexTexture:mtl_texture(contourBufferRing()) atIndex:kContourTextureIdx];
+    [encoder setFragmentTexture:mtl_texture(gradTexelBufferRing()) atIndex:kGradTextureIdx];
+    if (frameDescriptor().wireframe)
+    {
+        [encoder setTriangleFillMode:MTLTriangleFillModeLines];
+    }
+
+    size_t drawIdx = 0;
+    for (DrawList* draw = m_drawList; draw; draw = draw->next, ++drawIdx)
     {
         // Cache specific compilations of draw.glsl by ShaderFeatures.
         // TODO: Reuse vertex shader compilations where possible.
         // TODO: Precompile these shaders and only ship bytecode.
-        uint64_t shaderKey = shaderFeatures.getPreprocessorDefines(SourceType::wholeProgram);
+        uint64_t shaderKey = draw->shaderFeatures.getPreprocessorDefines(SourceType::wholeProgram);
         const DrawPipeline& drawPipeline =
-            m_drawPipelines.try_emplace(shaderKey, this, shaderFeatures).first->second;
+            m_drawPipelines.try_emplace(shaderKey, this, draw->shaderFeatures).first->second;
 
-        [encoder setViewport:(MTLViewport){0.f,
-                                           0.f,
-                                           static_cast<float>(renderTarget->width()),
-                                           static_cast<float>(renderTarget->height()),
-                                           0.0,
-                                           1.0}];
+        size_t wedgeInstanceCount = draw->vertexCount / kWedgeSize;
+        assert(wedgeInstanceCount > 0);
+        assert(wedgeInstanceCount * kWedgeSize == draw->vertexCount);
+        size_t wedgeBaseInstance = draw->baseVertex / kWedgeSize;
+        assert(wedgeBaseInstance * kWedgeSize == draw->baseVertex);
+
         [encoder setRenderPipelineState:drawPipeline.pipelineState(renderTarget->pixelFormat())];
-        [encoder setVertexBuffer:mtl_buffer(drawUniforms()) offset:0 atIndex:0];
-        [encoder setVertexBuffer:m_pathWedgeVertexBuffer offset:0 atIndex:1];
-        [encoder setVertexTexture:m_tessVertexTexture atIndex:kTessVertexTextureIdx];
-        [encoder setVertexTexture:mtl_texture(pathBufferRing()) atIndex:kPathTextureIdx];
-        [encoder setVertexTexture:mtl_texture(contourBufferRing()) atIndex:kContourTextureIdx];
-        [encoder setFragmentTexture:mtl_texture(gradTexelBufferRing()) atIndex:kGradTextureIdx];
-        if (frameDescriptor().wireframe)
-        {
-            [encoder setTriangleFillMode:MTLTriangleFillModeLines];
-        }
         [encoder drawIndexedPrimitives:MTLPrimitiveTypeTriangle
                             indexCount:kOuterStrokeWedgeIndexCount
                              indexType:MTLIndexTypeUInt16
                            indexBuffer:m_pathWedgeIndexBuffer
                      indexBufferOffset:0
-                         instanceCount:wedgeInstanceCount];
+                         instanceCount:wedgeInstanceCount
+                            baseVertex:0
+                          baseInstance:wedgeBaseInstance];
     }
     [encoder endEncoding];
 
diff --git a/renderer/pls_render_context.cpp b/renderer/pls_render_context.cpp
index 373ddd5..7c26b09 100644
--- a/renderer/pls_render_context.cpp
+++ b/renderer/pls_render_context.cpp
@@ -10,14 +10,14 @@
 
 #include <string_view>
 
+namespace rive::pls
+{
 // Overallocate GPU resources by 25% of current usage, in order to create padding for increase.
 constexpr static double kGPUResourcePadding = 1.25;
 
 // When we exceed the capacity of a GPU resource mid-flush, double it immediately.
 constexpr static double kGPUResourceIntermediateGrowthFactor = 2;
 
-namespace rive::pls
-{
 uint64_t PLSRenderContext::ShaderFeatures::getPreprocessorDefines(SourceType sourceType) const
 {
     uint64_t defines = 0;
@@ -626,19 +626,20 @@
     assert(0 < m_currentPathID && m_currentPathID <= m_maxPathID);
     assert(m_currentPathID == m_pathBuffer.bytesWritten() / sizeof(PathData));
 
+    ShaderFeatures* shaderFeatures = pushDraw(DrawType::pathWedges, m_tessVertexCount);
     if (blendMode > PLSBlendMode::srcOver)
     {
         assert(paintType != PaintType::clipReplace);
-        m_shaderFeatures.programFeatures.blendTier =
-            std::max(m_shaderFeatures.programFeatures.blendTier, BlendTierForBlendMode(blendMode));
+        shaderFeatures->programFeatures.blendTier =
+            std::max(shaderFeatures->programFeatures.blendTier, BlendTierForBlendMode(blendMode));
     }
     if (clipID != 0)
     {
-        m_shaderFeatures.programFeatures.enablePathClipping = true;
+        shaderFeatures->programFeatures.enablePathClipping = true;
     }
     if (fillRule == FillRule::evenOdd)
     {
-        m_shaderFeatures.fragmentFeatures.enableEvenOdd = true;
+        shaderFeatures->fragmentFeatures.enableEvenOdd = true;
     }
 }
 
@@ -732,6 +733,29 @@
     assert(m_tessVertexCount <= m_currentResourceLimits.maxTessellationVertices);
 }
 
+PLSRenderContext::ShaderFeatures* PLSRenderContext::pushDraw(DrawType drawType, size_t baseVertex)
+{
+    if (m_lastDraw && m_lastDraw->drawType == drawType)
+    {
+        // Merge with the previous draw.
+    }
+    else
+    {
+        DrawList* nextDraw = m_perFlushAllocator.make<DrawList>(drawType, baseVertex);
+        if (!m_lastDraw)
+        {
+            m_drawList = nextDraw;
+        }
+        else
+        {
+            m_lastDraw->next = nextDraw;
+        }
+        m_lastDraw = nextDraw;
+        ++m_drawListCount;
+    }
+    return &m_lastDraw->shaderFeatures;
+}
+
 template <typename T> bool bits_equal(const T* a, const T* b)
 {
     return memcmp(a, b, sizeof(T)) == 0;
@@ -763,12 +787,37 @@
     // Determine how much to draw.
     size_t gradSpanCount = m_gradSpanBuffer.bytesWritten() / sizeof(GradientSpan);
     size_t tessVertexSpanCount = m_tessSpanBuffer.bytesWritten() / sizeof(TessVertexSpan);
-    size_t tessDataHeight = (m_tessVertexCount + kTessTextureWidth - 1) / kTessTextureWidth;
-    // Don't draw the empty "end-of-contour" marker's vertices.
-    size_t tessVertexCountToDraw = std::max<size_t>(m_tessVertexCount, 2) - 2;
-    // PLSRenderer should have padded the vertex count of each contour to a multiple of kWedgeSize.
-    assert(tessVertexCountToDraw % kWedgeSize == 0);
-    size_t wedgeInstanceCount = tessVertexCountToDraw / kWedgeSize;
+    size_t tessDataHeight = resource_texture_height(kTessTextureWidth, m_tessVertexCount);
+
+    // Write out our DrawList to the GPU DrawParameters buffer and calculate the vertex count for
+    // each draw.
+    bool needsClipBuffer = false;
+    RIVE_DEBUG_CODE(size_t drawIdx = 0;)
+    DrawList* lastPathWedgeDraw = nullptr;
+    for (DrawList* draw = m_drawList; draw; draw = draw->next)
+    {
+        switch (draw->drawType)
+        {
+            case DrawType::pathWedges:
+                if (lastPathWedgeDraw)
+                {
+                    lastPathWedgeDraw->vertexCount =
+                        draw->baseVertex - lastPathWedgeDraw->baseVertex;
+                }
+                lastPathWedgeDraw = draw;
+                break;
+        }
+        needsClipBuffer =
+            needsClipBuffer || draw->shaderFeatures.programFeatures.enablePathClipping;
+        RIVE_DEBUG_CODE(++drawIdx;)
+    }
+    if (lastPathWedgeDraw)
+    {
+        // Don't draw the empty "end-of-contour" marker's vertices.
+        size_t endVertexToDraw = std::max<size_t>(m_tessVertexCount, 2) - 2;
+        lastPathWedgeDraw->vertexCount = endVertexToDraw - lastPathWedgeDraw->baseVertex;
+    }
+    assert(drawIdx == m_drawListCount);
 
     // Upload all non-empty buffers before flushing.
     m_pathBuffer.submit();
@@ -819,8 +868,7 @@
             m_complexGradients.size(),
             tessVertexSpanCount,
             tessDataHeight,
-            wedgeInstanceCount,
-            m_shaderFeatures);
+            needsClipBuffer);
 
     m_currentFrameResourceUsage.maxPathID += m_currentPathID;
     m_currentFrameResourceUsage.maxContourID += m_currentContourID;
@@ -832,22 +880,6 @@
     static_assert(sizeof(m_currentFrameResourceUsage) ==
                   sizeof(size_t) * 7); // Make sure we got every field.
 
-    m_lastGeneratedClipID = 0;
-    m_clipContentID = 0;
-
-    m_currentPathID = 0;
-    m_currentContourID = 0;
-    m_currentContourIDWithFlags = 0;
-
-    m_simpleGradients.clear();
-    m_complexGradients.clear();
-
-    m_tessVertexCount = 0;
-
-    m_shaderFeatures = ShaderFeatures();
-
-    m_isFirstFlushOfFrame = false;
-
     if (flushType == FlushType::intermediate)
     {
         // Intermediate flushes in a single frame are BAD. If the current frame's accumulative usage
@@ -862,5 +894,23 @@
         m_currentFrameResourceUsage = GPUResourceLimits{};
         RIVE_DEBUG_CODE(m_didBeginFrame = false;)
     }
+
+    m_lastGeneratedClipID = 0;
+    m_clipContentID = 0;
+
+    m_currentPathID = 0;
+    m_currentContourID = 0;
+    m_currentContourIDWithFlags = 0;
+
+    m_simpleGradients.clear();
+    m_complexGradients.clear();
+
+    m_tessVertexCount = 0;
+
+    m_isFirstFlushOfFrame = false;
+
+    m_drawList = m_lastDraw = nullptr;
+    m_drawListCount = 0;
+    m_perFlushAllocator.reset();
 }
 } // namespace rive::pls
diff --git a/renderer/shaders/draw.glsl b/renderer/shaders/draw.glsl
index 65d6f2d..b296ab0 100644
--- a/renderer/shaders/draw.glsl
+++ b/renderer/shaders/draw.glsl
@@ -62,6 +62,11 @@
 uint pad2;
 UNIFORM_BLOCK_END(uniforms)
 
+// Only used by GL platforms that don't support EXT_base_instance.
+#ifdef @BASE_INSTANCE_POLYFILL
+uniform int @baseInstancePolyfill;
+#endif
+
 VERTEX_TEXTURE_BLOCK_BEGIN(VertexTextures)
 TEXTURE_RGBA32UI(0) @tessVertexTexture;
 TEXTURE_RGBA32UI(1) @pathTexture;
@@ -92,6 +97,7 @@
     varyings,
     uint GLSL_VERTEX_ID [[vertex_id]],
     uint GLSL_INSTANCE_ID [[instance_id]],
+    uint GLSL_BASE_INSTANCE [[base_instance]],
     constant @Uniforms& uniforms [[buffer(0)]],
     constant Attrs* attrs [[buffer(1)]],
     VertexTextures textures
@@ -107,7 +113,13 @@
     int vertexType = floatBitsToInt(wedgeVertexData.w) & 3;
 
     // Fetch the tessellation vertex we belong to.
-    int vertexIdx = GLSL_INSTANCE_ID * wedgeSize + localVertexID;
+    int wedgeIdx = GLSL_INSTANCE_ID;
+#ifdef @BASE_INSTANCE_POLYFILL
+    wedgeIdx += @baseInstancePolyfill;
+#else
+    wedgeIdx += GLSL_BASE_INSTANCE;
+#endif
+    int vertexIdx = wedgeIdx * wedgeSize + localVertexID;
     int2 tessVertexTexelCoord = tessTexelCoord(vertexIdx);
     uint4 tessVertexData = TEXEL_FETCH(textures, @tessVertexTexture, tessVertexTexelCoord, 0);
     uint contourIDWithFlags = tessVertexData.w;
@@ -370,9 +382,7 @@
 PLS_DECL4F(0) framebuffer;
 PLS_DECL2F(1) coverageCountBuffer;
 PLS_DECL4F(2) originalDstColorBuffer;
-#ifdef @ENABLE_PATH_CLIPPING
 PLS_DECL2F(3) clipBuffer;
-#endif
 PLS_BLOCK_END
 
 PLS_MAIN(
@@ -463,8 +473,8 @@
             half2 clipData = PLS_LOAD2F(clipBuffer);
             coverage = FLD(varyings, clipID) == clipData.r ? min(coverage, clipData.g) : .0;
         }
-        PLS_PRESERVE_VALUE(clipBuffer);
 #endif
+        PLS_PRESERVE_VALUE(clipBuffer);
 
         // Blend with the framebuffer color.
         color.a *= coverage;
diff --git a/renderer/shaders/glsl.glsl b/renderer/shaders/glsl.glsl
index 7c37e07..a1f05d3 100644
--- a/renderer/shaders/glsl.glsl
+++ b/renderer/shaders/glsl.glsl
@@ -55,6 +55,7 @@
 #define GLSL_POSITION gl_Position
 #define GLSL_VERTEX_ID gl_VertexID
 #define GLSL_INSTANCE_ID gl_InstanceID
+#define GLSL_BASE_INSTANCE gl_BaseInstance
 
 #define UNIFORM_BLOCK_BEGIN(N)                                                                     \
     layout(std140) uniform N                                                                       \
diff --git a/renderer/shaders/pls_load_store_ext.glsl b/renderer/shaders/pls_load_store_ext.glsl
index 816febc..f2ffa15 100644
--- a/renderer/shaders/pls_load_store_ext.glsl
+++ b/renderer/shaders/pls_load_store_ext.glsl
@@ -25,9 +25,7 @@
     layout(rgba8) mediump vec4 framebuffer;
     layout(r32ui) highp uint coverageCountBuffer;
     layout(rgba8) mediump vec4 originalDstColorBuffer;
-#ifdef @DECLARE_CLIP
     layout(r32ui) highp uint clipBuffer;
-#endif
 };
 
 #ifdef @CLEAR_COLOR