diff --git a/dlls/wined3d/directx.c b/dlls/wined3d/directx.c
index ccfcf4b..8d75045 100644
--- a/dlls/wined3d/directx.c
+++ b/dlls/wined3d/directx.c
@@ -105,6 +105,7 @@
     {"GL_ARB_geometry_shader4",             ARB_GEOMETRY_SHADER4          },
     {"GL_ARB_half_float_pixel",             ARB_HALF_FLOAT_PIXEL          },
     {"GL_ARB_half_float_vertex",            ARB_HALF_FLOAT_VERTEX         },
+    {"GL_ARB_instanced_arrays",             ARB_INSTANCED_ARRAYS,         },
     {"GL_ARB_map_buffer_alignment",         ARB_MAP_BUFFER_ALIGNMENT      },
     {"GL_ARB_map_buffer_range",             ARB_MAP_BUFFER_RANGE          },
     {"GL_ARB_multisample",                  ARB_MULTISAMPLE               }, /* needs GLX_ARB_MULTISAMPLE as well */
diff --git a/dlls/wined3d/drawprim.c b/dlls/wined3d/drawprim.c
index 9443877..61f3f8b 100644
--- a/dlls/wined3d/drawprim.c
+++ b/dlls/wined3d/drawprim.c
@@ -676,6 +676,9 @@
         struct wined3d_stream_info stridedlcl;
         UINT idx_size = 0;
 
+        if (device->instance_count)
+            instance_count = device->instance_count;
+
         if (indexed)
         {
             if (!state->user_stream)
@@ -753,11 +756,11 @@
                         glPrimType, idx_data, idx_size, start_idx);
             }
         }
-        else if (device->instance_count)
+        else if (!gl_info->supported[ARB_INSTANCED_ARRAYS] && instance_count)
         {
             /* Instancing emulation with mixing immediate mode and arrays */
             drawStridedInstanced(gl_info, state, stream_info, index_count, glPrimType,
-                    idx_data, idx_size, start_idx, base_vertex_index, device->instance_count);
+                    idx_data, idx_size, start_idx, base_vertex_index, instance_count);
         }
         else
         {
diff --git a/dlls/wined3d/state.c b/dlls/wined3d/state.c
index 6f0c4f2..d0445c9 100644
--- a/dlls/wined3d/state.c
+++ b/dlls/wined3d/state.c
@@ -4101,6 +4101,8 @@
 
     GL_EXTCALL(glDisableVertexAttribArrayARB(i));
     checkGLcall("glDisableVertexAttribArrayARB(reg)");
+    if (gl_info->supported[ARB_INSTANCED_ARRAYS])
+        GL_EXTCALL(glVertexAttribDivisorARB(i, 0));
 
     context->numbered_array_mask &= ~(1 << i);
 }
@@ -4143,13 +4145,25 @@
 
         stream = &state->streams[stream_info->elements[i].stream_idx];
 
-        /* Do not load instance data. It will be specified using glTexCoord by drawprim */
         if (stream->flags & WINED3DSTREAMSOURCE_INSTANCEDATA)
         {
             if (!device->instance_count)
                 device->instance_count = state->streams[0].frequency ? state->streams[0].frequency : 1;
-            if (context->numbered_array_mask & (1 << i)) unload_numbered_array(context, i);
-            continue;
+
+            if (!gl_info->supported[ARB_INSTANCED_ARRAYS])
+            {
+                /* Unload instanced arrays, they will be loaded using
+                 * immediate mode instead. */
+                if (context->numbered_array_mask & (1 << i))
+                    unload_numbered_array(context, i);
+                continue;
+            }
+
+            GL_EXTCALL(glVertexAttribDivisorARB(i, 1));
+        }
+        else if (gl_info->supported[ARB_INSTANCED_ARRAYS])
+        {
+            GL_EXTCALL(glVertexAttribDivisorARB(i, 0));
         }
 
         TRACE_(d3d_shader)("Loading array %u [VBO=%u]\n", i, stream_info->elements[i].data.buffer_object);
diff --git a/dlls/wined3d/wined3d_gl.h b/dlls/wined3d/wined3d_gl.h
index fc0a68c..06b5274 100644
--- a/dlls/wined3d/wined3d_gl.h
+++ b/dlls/wined3d/wined3d_gl.h
@@ -57,6 +57,7 @@
     ARB_GEOMETRY_SHADER4,
     ARB_HALF_FLOAT_PIXEL,
     ARB_HALF_FLOAT_VERTEX,
+    ARB_INSTANCED_ARRAYS,
     ARB_MAP_BUFFER_ALIGNMENT,
     ARB_MAP_BUFFER_RANGE,
     ARB_MULTISAMPLE,
@@ -214,6 +215,8 @@
     USE_GL_FUNC(glFramebufferTextureFaceARB) \
     USE_GL_FUNC(glFramebufferTextureLayerARB) \
     USE_GL_FUNC(glProgramParameteriARB) \
+    /* GL_ARB_instanced_arrays */ \
+    USE_GL_FUNC(glVertexAttribDivisorARB) \
     /* GL_ARB_map_buffer_range */ \
     USE_GL_FUNC(glFlushMappedBufferRange) \
     USE_GL_FUNC(glMapBufferRange) \
