angle.patch

diff --git a/build_tools/sdk.py b/build_tools/sdk.py
index 87bf940697..2dd297998c 100644
--- a/build_tools/sdk.py
+++ b/build_tools/sdk.py
@@ -83,9 +83,9 @@ ANDROID_64_NDK_API_VERSION='21' # Android 5.0
 # Win32
 
 # The version we have prepackaged
-VERSION_WINDOWS_SDK="10.0.28000.0"
-VISUAL_STUDIO_VERSION="2026"
-VERSION_WINDOWS_MSVC="14.51.36231"
+VERSION_WINDOWS_SDK=os.environ.get('VERSION_WINDOWS_SDK', "10.0.28000.0")
+VISUAL_STUDIO_VERSION=os.environ.get('VISUAL_STUDIO_VERSION', "2026")
+VERSION_WINDOWS_MSVC=os.environ.get('VERSION_WINDOWS_MSVC', "14.51.36231")
 PACKAGES_WIN32_TOOLCHAIN=f"Microsoft-Visual-Studio-{VISUAL_STUDIO_VERSION}-{VERSION_WINDOWS_MSVC}"
 PACKAGES_WIN32_SDK=f"WindowsKits-{VERSION_WINDOWS_SDK}"
 
diff --git a/build_tools/waf_dynamo.py b/build_tools/waf_dynamo.py
index c5ebd801ec..9d8a4edcc5 100644
--- a/build_tools/waf_dynamo.py
+++ b/build_tools/waf_dynamo.py
@@ -82,7 +82,7 @@ def platform_supports_feature(platform, feature, data):
     if feature == 'opengl_compute':
         return platform not in ['wasm-web', 'wasm_pthread-web', 'x86_64-ios', 'arm64-ios', 'arm64-macos', 'x86_64-macos']
     if feature == 'opengles':
-        return platform in ['arm64-linux', 'armv7-android', 'arm64-android', 'x86_64-ios', 'arm64-ios']
+        return platform in ['arm64-linux', 'armv7-android', 'arm64-android', 'x86_64-ios', 'arm64-ios', 'x86_64-win32', 'win32']
     if feature == 'webgpu':
         return platform in ['wasm-web', 'wasm_pthread-web']
     if feature == 'metal':
@@ -265,6 +265,9 @@ def platform_graphics_libs_and_symbols(platform):
     elif platform in ('armv7-android', 'arm64-android'):
         use_opengles = Options.options.with_opengl or not Options.options.with_vulkan
         use_vulkan = Options.options.with_vulkan or not Options.options.with_opengl
+    elif platform in ('x86_64-win32', 'win32'):
+        use_opengles = True
+        use_vulkan = Options.options.with_vulkan
     else:
         use_opengl = True
         use_vulkan = Options.options.with_vulkan
diff --git a/engine/engine/wscript b/engine/engine/wscript
index b80a8d583d..021df90350 100644
--- a/engine/engine/wscript
+++ b/engine/engine/wscript
@@ -124,7 +124,7 @@ def configure(conf):
         conf.env['STLIB_CPP_RUNTIME'] = 'c++_static'
 
     elif target_os == TargetOS.WINDOWS:
-        conf.env.append_value('LINKFLAGS', ['opengl32.lib', 'user32.lib', 'shell32.lib', 'xinput9_1_0.lib', 'dbghelp.lib', 'dinput8.lib', 'dxguid.lib'])
+        conf.env.append_value('LINKFLAGS', ['libEGL.dll.lib', 'libGLESv2.dll.lib', 'user32.lib', 'shell32.lib', 'xinput9_1_0.lib', 'dbghelp.lib', 'dinput8.lib', 'dxguid.lib'])
 
         if waflib.Options.options.with_vulkan:
             conf.env.append_value('LINKFLAGS', ['vulkan-1.lib'])
diff --git a/engine/graphics/CMakeLists.txt b/engine/graphics/CMakeLists.txt
index 38a7ffe5a3..eeac5ec4bc 100644
--- a/engine/graphics/CMakeLists.txt
+++ b/engine/graphics/CMakeLists.txt
@@ -159,9 +159,12 @@ endif()
 if(TARGET_PLATFORM STREQUAL "x86_64-ios")
   set(GRAPHICS_PLATFORM_SUPPORTS_VULKAN OFF)
 endif()
-if(TARGET_PLATFORM MATCHES "^(arm64-linux|armv7-android|arm64-android|x86_64-ios|arm64-ios)$")
+if(TARGET_PLATFORM MATCHES "^(arm64-linux|armv7-android|arm64-android|x86_64-ios|arm64-ios|x86-win32|x86_64-win32)$")
   set(GRAPHICS_PLATFORM_SUPPORTS_OPENGLES ON)
 endif()
+if(TARGET_PLATFORM MATCHES "^(x86-win32|x86_64-win32)$")
+  set(GRAPHICS_PLATFORM_SUPPORTS_OPENGL OFF)
+endif()
 if(TARGET_PLATFORM STREQUAL "x86_64-win32")
   set(GRAPHICS_PLATFORM_SUPPORTS_DX12 ON)
 endif()
@@ -232,6 +235,10 @@ if(GRAPHICS_BUILD_OPENGLES)
   graphics_common_setup(graphics_opengles)
   target_include_directories(graphics_opengles PUBLIC "${GRAPHICS_SRC_DIR}/opengl")
   target_compile_definitions(graphics_opengles PUBLIC DM_GRAPHICS_USE_OPENGLES)
+  if(TARGET_PLATFORM MATCHES "^(x86-win32|x86_64-win32)$")
+    # Win32 OpenGLES links against ANGLE and enables its backend-specific paths.
+    target_compile_definitions(graphics_opengles PRIVATE DM_GRAPHICS_USE_ANGLE)
+  endif()
   if(NOT TARGET_PLATFORM MATCHES "^(x86_64-ios|arm64-ios)$")
     target_compile_definitions(graphics_opengles PUBLIC DM_HAVE_OPENGL_COMPUTE_SUPPORT)
   endif()
diff --git a/engine/graphics/src/graphics.cpp b/engine/graphics/src/graphics.cpp
index 63682194df..ec273c9d4e 100644
--- a/engine/graphics/src/graphics.cpp
+++ b/engine/graphics/src/graphics.cpp
@@ -368,6 +368,31 @@ namespace dmGraphics
     {
         ShaderDesc::Shader* selected_shader = 0x0;
 
+        // Prefer GLES SM300 shaders if available (e.g. for GLES3/WebGL2 contexts).
+        for(uint32_t i = 0; i < shader_desc->m_Shaders.m_Count; ++i)
+        {
+            ShaderDesc::Shader* shader = &shader_desc->m_Shaders.m_Data[i];
+            if (shader->m_Language != ShaderDesc::LANGUAGE_GLES_SM300 ||
+                shader->m_ShaderType != shader_type ||
+                !IsShaderLanguageSupported(context, shader->m_Language, shader->m_ShaderType))
+            {
+                continue;
+            }
+
+            if (shader->m_VariantTextureArray)
+            {
+                // Only select this variant if we don't support texture arrays natively
+                if (!IsContextFeatureSupported(context, CONTEXT_FEATURE_TEXTURE_ARRAY))
+                {
+                    return shader;
+                }
+            }
+            else
+            {
+                return shader;
+            }
+        }
+
         for(uint32_t i = 0; i < shader_desc->m_Shaders.m_Count; ++i)
         {
             ShaderDesc::Shader* shader = &shader_desc->m_Shaders.m_Data[i];
diff --git a/engine/graphics/src/opengl/graphics_opengl.cpp b/engine/graphics/src/opengl/graphics_opengl.cpp
index eff50fc44b..95e8aedaf0 100644
--- a/engine/graphics/src/opengl/graphics_opengl.cpp
+++ b/engine/graphics/src/opengl/graphics_opengl.cpp
@@ -14,6 +14,7 @@
 
 #include <string.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <assert.h>
 #include <dlib/dlib.h>
 #include <dlib/log.h>
@@ -85,121 +86,7 @@
 #elif defined (__linux__)
     // NOP
 #elif defined (_WIN32)
-    #ifdef GL_GLEXT_PROTOTYPES
-        #undef GL_GLEXT_PROTOTYPES
-        #include "win32/glext.h"
-        #define GL_GLEXT_PROTOTYPES
-    #else
-        #include "win32/glext.h"
-    #endif
-
-    // VBO Extension for OGL 1.4.1
-    typedef void (APIENTRY * PFNGLGENPROGRAMARBPROC) (GLenum, GLuint *);
-    typedef void (APIENTRY * PFNGLVERTEXPARAMFLOAT4ARBPROC) (GLenum, GLuint, GLfloat, GLfloat, GLfloat, GLfloat);
-    typedef void (APIENTRY * PFNGLVERTEXATTRIBSETPROC) (GLuint);
-    typedef void (APIENTRY * PFNGLVERTEXATTRIBPTRPROC) (GLuint, GLint, GLenum, GLboolean, GLsizei, const GLvoid *);
-    typedef void (APIENTRY * PFNGLTEXPARAM2DPROC) (GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, const GLvoid *);
-    typedef void (APIENTRY * PFNGLCOMPRTEXSUB2DPROC) (GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid *);
-    typedef void (APIENTRY * PFNGLBINDBUFFERPROC) (GLenum, GLuint);
-    typedef void (APIENTRY * PFNGLBUFFERDATAPROC) (GLenum, GLsizeiptr, const GLvoid*, GLenum);
-    typedef void (APIENTRY * PFNGLBINDRENDERBUFFERPROC) (GLenum, GLuint);
-    typedef void (APIENTRY * PFNGLRENDERBUFFERSTORAGEPROC) (GLenum, GLenum, GLsizei, GLsizei);
-    typedef void (APIENTRY * PFNGLRENDERBUFFERTEXTURE2DPROC) (GLenum, GLenum, GLenum, GLuint, GLint);
-    typedef void (APIENTRY * PFNGLFRAMEBUFFERRENDERBUFFERPROC) (GLenum, GLenum, GLenum, GLuint);
-    typedef void (APIENTRY * PFNGLBINDFRAMEBUFFERPROC) (GLenum, GLuint);
-    typedef void (APIENTRY * PFNGLBUFFERSUBDATAPROC) (GLenum, GLintptr, GLsizeiptr, const GLvoid*);
-    typedef void* (APIENTRY * PFNGLMAPBUFFERPROC) (GLenum, GLenum);
-    typedef GLboolean (APIENTRY * PFNGLUNMAPBUFFERPROC) (GLenum);
-    typedef void (APIENTRY * PFNGLACTIVETEXTUREPROC) (GLenum);
-    typedef void (APIENTRY * PFNGLSTENCILFUNCSEPARATEPROC) (GLenum, GLenum, GLint, GLuint);
-    typedef void (APIENTRY * PFNGLSTENCILOPSEPARATEPROC) (GLenum, GLenum, GLenum, GLenum);
-    typedef void (APIENTRY * PFNGLBLENDFUNCSEPARATEPROC) (GLenum, GLenum, GLenum, GLenum);
-    typedef void (APIENTRY * PFNGLBLENDEQUATIONSEPARATEPROC) (GLenum, GLenum);
-    typedef void (APIENTRY * PFNGLDRAWBUFFERSPROC) (GLsizei, const GLenum*);
-    typedef GLint (APIENTRY * PFNGLGETFRAGDATALOCATIONPROC) (GLuint, const char*);
-    typedef void (APIENTRY * PFNGLBINDFRAGDATALOCATIONPROC) (GLuint, GLuint, const char*);
-
-    PFNGLVERTEXATTRIBSETPROC glEnableVertexAttribArray = NULL;
-    PFNGLVERTEXATTRIBSETPROC glDisableVertexAttribArray = NULL;
-    PFNGLVERTEXATTRIBPTRPROC glVertexAttribPointer = NULL;
-    PFNGLTEXPARAM2DPROC glCompressedTexImage2D = NULL;
-    PFNGLCOMPRTEXSUB2DPROC glCompressedTexSubImage2D = NULL;
-    PFNGLGENBUFFERSPROC glGenBuffersARB = NULL;
-    PFNGLDELETEBUFFERSPROC glDeleteBuffersARB = NULL;
-    PFNGLBINDBUFFERPROC glBindBufferARB = NULL;
-    PFNGLBUFFERDATAPROC glBufferDataARB = NULL;
-    PFNGLGENRENDERBUFFERSPROC glGenRenderbuffers = NULL;
-    PFNGLBINDRENDERBUFFERPROC glBindRenderbuffer = NULL;
-    PFNGLRENDERBUFFERSTORAGEPROC glRenderbufferStorage = NULL;
-    PFNGLRENDERBUFFERTEXTURE2DPROC glFramebufferTexture2D = NULL;
-    PFNGLFRAMEBUFFERRENDERBUFFERPROC glFramebufferRenderbuffer = NULL;
-    PFNGLGENFRAMEBUFFERSPROC glGenFramebuffers = NULL;
-    PFNGLBINDFRAMEBUFFERPROC glBindFramebuffer = NULL;
-    PFNGLDELETEFRAMEBUFFERSPROC glDeleteFramebuffers = NULL;
-    PFNGLDELETERENDERBUFFERSPROC glDeleteRenderbuffers = NULL;
-    PFNGLBUFFERSUBDATAPROC glBufferSubDataARB = NULL;
-    PFNGLMAPBUFFERPROC glMapBufferARB = NULL;
-    PFNGLUNMAPBUFFERPROC glUnmapBufferARB = NULL;
-    PFNGLACTIVETEXTUREPROC glActiveTexture = NULL;
-    PFNGLCHECKFRAMEBUFFERSTATUSPROC glCheckFramebufferStatus = NULL;
-    PFNGLSTENCILFUNCSEPARATEPROC glStencilFuncSeparate = NULL;
-    PFNGLSTENCILOPSEPARATEPROC glStencilOpSeparate = NULL;
-    PFNGLBLENDFUNCSEPARATEPROC glBlendFuncSeparate = NULL;
-    PFNGLBLENDEQUATIONSEPARATEPROC glBlendEquationSeparate = NULL;
-
-    PFNGLGETACTIVEATTRIBPROC glGetActiveAttrib = NULL;
-    PFNGLGETATTRIBLOCATIONPROC glGetAttribLocation = NULL;
-    PFNGLCREATESHADERPROC glCreateShader = NULL;
-    PFNGLSHADERSOURCEPROC glShaderSource = NULL;
-    PFNGLCOMPILESHADERPROC glCompileShader = NULL;
-    PFNGLGETSHADERIVPROC glGetShaderiv = NULL;
-    PFNGLGETSHADERINFOLOGPROC glGetShaderInfoLog = NULL;
-    PFNGLGETPROGRAMINFOLOGPROC glGetProgramInfoLog = NULL;
-    PFNGLDELETESHADERPROC glDeleteShader = NULL;
-    PFNGLCREATEPROGRAMPROC glCreateProgram = NULL;
-    PFNGLATTACHSHADERPROC glAttachShader = NULL;
-    PFNGLLINKPROGRAMPROC glLinkProgram = NULL;
-    PFNGLDELETEPROGRAMPROC glDeleteProgram = NULL;
-    PFNGLUSEPROGRAMPROC glUseProgram = NULL;
-    PFNGLGETPROGRAMIVPROC glGetProgramiv = NULL;
-    PFNGLGETACTIVEUNIFORMPROC glGetActiveUniform = NULL;
-    PFNGLGETUNIFORMLOCATIONPROC glGetUniformLocation = NULL;
-    PFNGLUNIFORM4FVPROC glUniform4fv = NULL;
-    PFNGLUNIFORMMATRIX4FVPROC glUniformMatrix4fv = NULL;
-    PFNGLUNIFORM1IPROC glUniform1i = NULL;
-
-    PFNGLTEXSUBIMAGE3DPROC           glTexSubImage3D = NULL;
-    PFNGLTEXIMAGE3DPROC              glTexImage3D = NULL;
-    PFNGLCOMPRESSEDTEXIMAGE3DPROC    glCompressedTexImage3D = NULL;
-    PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glCompressedTexSubImage3D = NULL;
-
-    // Compute
-    PFNGLDISPATCHCOMPUTEPROC  glDispatchCompute  = NULL;
-    PFNGLMEMORYBARRIERPROC    glMemoryBarrier    = NULL;
-    PFNGLBINDIMAGETEXTUREPROC glBindImageTexture = NULL;
-
-    // Uniform buffer objects
-    PFNGLBINDBUFFERBASEPROC          glBindBufferBase          = NULL;
-    PFNGLBUFFERDATAPROC              glBufferData              = NULL;
-    PFNGLGETINTEGERI_VPROC           glGetIntegeri_v           = NULL;
-    PFNGLGETUNIFORMBLOCKINDEXPROC    glGetUniformBlockIndex    = NULL;
-    PFNGLGETACTIVEUNIFORMBLOCKIVPROC glGetActiveUniformBlockiv = NULL;
-    PFNGLGETACTIVEUNIFORMSIVPROC     glGetActiveUniformsiv     = NULL;
-    PFNGLGENBUFFERSPROC              glGenBuffers              = NULL;
-    PFNGLBINDBUFFERPROC              glBindBuffer              = NULL;
-    PFNGLUNIFORMBLOCKBINDINGPROC     glUniformBlockBinding     = NULL;
-
-    #if !defined(GL_ES_VERSION_2_0)
-        PFNGLGETSTRINGIPROC glGetStringi = NULL;
-        PFNGLGENVERTEXARRAYSPROC glGenVertexArrays = NULL;
-        PFNGLBINDVERTEXARRAYPROC glBindVertexArray = NULL;
-        PFNGLDRAWBUFFERSPROC glDrawBuffers = NULL;
-        PFNGLGETFRAGDATALOCATIONPROC glGetFragDataLocation = NULL;
-        PFNGLBINDFRAGDATALOCATIONPROC glBindFragDataLocation = NULL;
-        PFNGLDRAWARRAYSINSTANCEDPROC glDrawArraysInstanced = NULL;
-        PFNGLDRAWELEMENTSINSTANCEDPROC glDrawElementsInstanced = NULL;
-        PFNGLVERTEXATTRIBDIVISORPROC glVertexAttribDivisor = NULL;
-    #endif
+    #include <glfw/glfw3.h>
 #elif defined(__EMSCRIPTEN__)
     #include <GL/glext.h>
     #if defined GL_ES_VERSION_2_0
@@ -1207,7 +1094,7 @@ static void LogFrameBufferError(GLenum status)
             1) ARB - Extensions officially approved by the OpenGL Architecture Review Board
             2) EXT - Extensions agreed upon by multiple OpenGL vendors
             3) OES - Vendor specific code for the OpenGL ES working group
-            4) Optionally check as core function (if not GLES and core_name is set)
+            4) Optionally check as a core function when the current context supports it
         */
         uintptr_t func = 0x0;
 
@@ -1238,9 +1125,11 @@ static void LogFrameBufferError(GLenum status)
             }
         }
     #if !defined(__EMSCRIPTEN__)
-        if(func == 0 && core_name)
+        OpenGLContext* context = (OpenGLContext*) _context;
+        bool core_function_supported = !context->m_IsShaderLanguageGles || context->m_IsGles3Version;
+        if(func == 0 && core_name && core_function_supported)
         {
-            // On OpenGL, optionally check for core driver support if extension wasn't found (i.e extension has become part of core OpenGL)
+            // ANGLE exports GLES3 symbols for GLES2 contexts, so core lookup must follow the runtime context version.
             func = dmPlatform::GetProcAddress(window, core_name);
         }
     #endif
@@ -1366,107 +1255,6 @@ static void LogFrameBufferError(GLenum status)
         assert(_context);
         OpenGLContext* context = (OpenGLContext*) _context;
 
-#if defined (_WIN32)
-    #define GET_PROC_ADDRESS_OPTIONAL(function, name, type) \
-        function = (type)wglGetProcAddress(name);\
-        if (function == 0x0)\
-        {\
-            function = (type)wglGetProcAddress(name "ARB");\
-        }\
-        if (function == 0x0)\
-        {\
-            function = (type)wglGetProcAddress(name "EXT");\
-        }
-
-    #define GET_PROC_ADDRESS(function, name, type)\
-        GET_PROC_ADDRESS_OPTIONAL(function, name, type) \
-        if (function == 0x0)\
-        {\
-            dmLogError("Could not find gl function '%s'.", name);\
-            return false;\
-        }
-
-        GET_PROC_ADDRESS(glEnableVertexAttribArray, "glEnableVertexAttribArray", PFNGLVERTEXATTRIBSETPROC);
-        GET_PROC_ADDRESS(glDisableVertexAttribArray, "glDisableVertexAttribArray", PFNGLVERTEXATTRIBSETPROC);
-        GET_PROC_ADDRESS(glVertexAttribPointer, "glVertexAttribPointer", PFNGLVERTEXATTRIBPTRPROC);
-        GET_PROC_ADDRESS(glCompressedTexImage2D, "glCompressedTexImage2D", PFNGLTEXPARAM2DPROC);
-        GET_PROC_ADDRESS(glCompressedTexSubImage2D, "glCompressedTexSubImage2D", PFNGLCOMPRTEXSUB2DPROC);
-        GET_PROC_ADDRESS(glGenBuffersARB, "glGenBuffers", PFNGLGENBUFFERSPROC);
-        GET_PROC_ADDRESS(glDeleteBuffersARB, "glDeleteBuffers", PFNGLDELETEBUFFERSPROC);
-        GET_PROC_ADDRESS(glBindBufferARB, "glBindBuffer", PFNGLBINDBUFFERPROC);
-        GET_PROC_ADDRESS(glBufferDataARB, "glBufferData", PFNGLBUFFERDATAPROC);
-        GET_PROC_ADDRESS(glGenRenderbuffers, "glGenRenderbuffers", PFNGLGENRENDERBUFFERSPROC);
-        GET_PROC_ADDRESS(glBindRenderbuffer, "glBindRenderbuffer", PFNGLBINDRENDERBUFFERPROC);
-        GET_PROC_ADDRESS(glRenderbufferStorage, "glRenderbufferStorage", PFNGLRENDERBUFFERSTORAGEPROC);
-        GET_PROC_ADDRESS(glFramebufferTexture2D, "glFramebufferTexture2D", PFNGLRENDERBUFFERTEXTURE2DPROC);
-        GET_PROC_ADDRESS(glFramebufferRenderbuffer, "glFramebufferRenderbuffer", PFNGLFRAMEBUFFERRENDERBUFFERPROC);
-        GET_PROC_ADDRESS(glGenFramebuffers, "glGenFramebuffers", PFNGLGENFRAMEBUFFERSPROC);
-        GET_PROC_ADDRESS(glBindFramebuffer, "glBindFramebuffer", PFNGLBINDFRAMEBUFFERPROC);
-        GET_PROC_ADDRESS(glDeleteFramebuffers, "glDeleteFramebuffers", PFNGLDELETEFRAMEBUFFERSPROC);
-        GET_PROC_ADDRESS(glDeleteRenderbuffers, "glDeleteRenderbuffers", PFNGLDELETERENDERBUFFERSPROC);
-        GET_PROC_ADDRESS(glBufferSubDataARB, "glBufferSubData", PFNGLBUFFERSUBDATAPROC);
-        GET_PROC_ADDRESS(glMapBufferARB, "glMapBuffer", PFNGLMAPBUFFERPROC); // unused
-        GET_PROC_ADDRESS(glUnmapBufferARB, "glUnmapBuffer", PFNGLUNMAPBUFFERPROC); // unused
-        GET_PROC_ADDRESS(glActiveTexture, "glActiveTexture", PFNGLACTIVETEXTUREPROC);
-        GET_PROC_ADDRESS(glCheckFramebufferStatus, "glCheckFramebufferStatus", PFNGLCHECKFRAMEBUFFERSTATUSPROC);
-        GET_PROC_ADDRESS(glGetAttribLocation, "glGetAttribLocation", PFNGLGETATTRIBLOCATIONPROC);
-        GET_PROC_ADDRESS(glGetActiveAttrib, "glGetActiveAttrib", PFNGLGETACTIVEATTRIBPROC);
-        GET_PROC_ADDRESS(glCreateShader, "glCreateShader", PFNGLCREATESHADERPROC);
-        GET_PROC_ADDRESS(glShaderSource, "glShaderSource", PFNGLSHADERSOURCEPROC);
-        GET_PROC_ADDRESS(glCompileShader, "glCompileShader", PFNGLCOMPILESHADERPROC);
-        GET_PROC_ADDRESS(glGetShaderiv, "glGetShaderiv", PFNGLGETSHADERIVPROC);
-        GET_PROC_ADDRESS(glGetShaderInfoLog, "glGetShaderInfoLog", PFNGLGETSHADERINFOLOGPROC);
-        GET_PROC_ADDRESS(glGetProgramInfoLog, "glGetProgramInfoLog", PFNGLGETPROGRAMINFOLOGPROC);
-        GET_PROC_ADDRESS(glDeleteShader, "glDeleteShader", PFNGLDELETESHADERPROC);
-        GET_PROC_ADDRESS(glCreateProgram, "glCreateProgram", PFNGLCREATEPROGRAMPROC);
-        GET_PROC_ADDRESS(glAttachShader, "glAttachShader", PFNGLATTACHSHADERPROC);
-        GET_PROC_ADDRESS(glLinkProgram, "glLinkProgram", PFNGLLINKPROGRAMPROC);
-        GET_PROC_ADDRESS(glDeleteProgram, "glDeleteProgram", PFNGLDELETEPROGRAMPROC);
-        GET_PROC_ADDRESS(glUseProgram, "glUseProgram", PFNGLUSEPROGRAMPROC);
-        GET_PROC_ADDRESS(glGetProgramiv, "glGetProgramiv", PFNGLGETPROGRAMIVPROC);
-        GET_PROC_ADDRESS(glGetActiveUniform, "glGetActiveUniform", PFNGLGETACTIVEUNIFORMPROC);
-        GET_PROC_ADDRESS(glGetUniformLocation, "glGetUniformLocation", PFNGLGETUNIFORMLOCATIONPROC);
-        GET_PROC_ADDRESS(glUniform4fv, "glUniform4fv", PFNGLUNIFORM4FVPROC);
-        GET_PROC_ADDRESS(glUniformMatrix4fv, "glUniformMatrix4fv", PFNGLUNIFORMMATRIX4FVPROC);
-        GET_PROC_ADDRESS(glUniform1i, "glUniform1i", PFNGLUNIFORM1IPROC);
-        GET_PROC_ADDRESS(glStencilOpSeparate, "glStencilOpSeparate", PFNGLSTENCILOPSEPARATEPROC);
-        GET_PROC_ADDRESS(glStencilFuncSeparate, "glStencilFuncSeparate", PFNGLSTENCILFUNCSEPARATEPROC);
-        GET_PROC_ADDRESS(glBlendFuncSeparate, "glBlendFuncSeparate", PFNGLBLENDFUNCSEPARATEPROC);
-        GET_PROC_ADDRESS(glBlendEquationSeparate, "glBlendEquationSeparate", PFNGLBLENDEQUATIONSEPARATEPROC);
-        GET_PROC_ADDRESS(glTexSubImage3D, "glTexSubImage3D", PFNGLTEXSUBIMAGE3DPROC);
-        GET_PROC_ADDRESS(glTexImage3D, "glTexImage3D", PFNGLTEXIMAGE3DPROC);
-        GET_PROC_ADDRESS(glCompressedTexImage3D, "glCompressedTexImage3D", PFNGLCOMPRESSEDTEXIMAGE3DPROC);
-        GET_PROC_ADDRESS(glCompressedTexSubImage3D, "glCompressedTexSubImage3D", PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC);
-
-        GET_PROC_ADDRESS_OPTIONAL(glDispatchCompute,  "glDispatchCompute",  PFNGLDISPATCHCOMPUTEPROC);
-        GET_PROC_ADDRESS_OPTIONAL(glMemoryBarrier,    "glMemoryBarrier",    PFNGLMEMORYBARRIERPROC);
-        GET_PROC_ADDRESS_OPTIONAL(glBindImageTexture, "glBindImageTexture", PFNGLBINDIMAGETEXTUREPROC);
-
-        GET_PROC_ADDRESS(glBindBufferBase, "glBindBufferBase", PFNGLBINDBUFFERBASEPROC);
-        GET_PROC_ADDRESS(glBufferData, "glBufferData", PFNGLBUFFERDATAPROC);
-        GET_PROC_ADDRESS(glGetIntegeri_v, "glGetIntegeri_v", PFNGLGETINTEGERI_VPROC);
-        GET_PROC_ADDRESS(glGetUniformBlockIndex, "glGetUniformBlockIndex", PFNGLGETUNIFORMBLOCKINDEXPROC);
-        GET_PROC_ADDRESS(glGetActiveUniformBlockiv, "glGetActiveUniformBlockiv", PFNGLGETACTIVEUNIFORMBLOCKIVPROC);
-        GET_PROC_ADDRESS(glGetActiveUniformsiv, "glGetActiveUniformsiv", PFNGLGETACTIVEUNIFORMSIVPROC);
-        GET_PROC_ADDRESS(glGenBuffers, "glGenBuffers", PFNGLGENBUFFERSPROC);
-        GET_PROC_ADDRESS(glBindBuffer, "glBindBuffer", PFNGLBINDBUFFERPROC);
-        GET_PROC_ADDRESS(glUniformBlockBinding, "glUniformBlockBinding", PFNGLUNIFORMBLOCKBINDINGPROC);
-
-    #if !defined(GL_ES_VERSION_2_0)
-        GET_PROC_ADDRESS(glGetStringi,"glGetStringi",PFNGLGETSTRINGIPROC);
-        GET_PROC_ADDRESS(glGenVertexArrays, "glGenVertexArrays", PFNGLGENVERTEXARRAYSPROC);
-        GET_PROC_ADDRESS(glBindVertexArray, "glBindVertexArray", PFNGLBINDVERTEXARRAYPROC);
-        GET_PROC_ADDRESS(glDrawBuffers, "glDrawBuffers", PFNGLDRAWBUFFERSPROC);
-        GET_PROC_ADDRESS(glGetFragDataLocation, "glGetFragDataLocation", PFNGLGETFRAGDATALOCATIONPROC);
-        GET_PROC_ADDRESS(glBindFragDataLocation, "glBindFragDataLocation", PFNGLBINDFRAGDATALOCATIONPROC);
-        GET_PROC_ADDRESS(glDrawArraysInstanced, "glDrawArraysInstanced", PFNGLDRAWARRAYSINSTANCEDPROC);
-        GET_PROC_ADDRESS(glDrawElementsInstanced, "glDrawElementsInstanced", PFNGLDRAWELEMENTSINSTANCEDPROC);
-        GET_PROC_ADDRESS(glVertexAttribDivisor, "glVertexAttribDivisor", PFNGLVERTEXATTRIBDIVISORPROC);
-    #endif
-
-    #undef GET_PROC_ADDRESS
-#endif
-
         context->m_IsGles3Version   = 1; // 0 == gles 2, 1 == gles 3
         context->m_PipelineState    = GetDefaultPipelineState();
         context->m_PipelineStateDirty = context->m_PipelineState;
@@ -1641,6 +1429,12 @@ static void LogFrameBufferError(GLenum status)
             context->m_BaseContext.m_TextureFormatSupport |= 1ULL << TEXTURE_FORMAT_RGBA_BC3; // DXT5
         }
 
+        // Native ANGLE may expose DXT1 and DXT5 separately instead of the combined S3TC extension.
+        if (OpenGLIsExtensionSupported(_context, "GL_EXT_texture_compression_dxt1"))
+            context->m_BaseContext.m_TextureFormatSupport |= 1ULL << TEXTURE_FORMAT_RGB_BC1;
+        if (OpenGLIsExtensionSupported(_context, "GL_ANGLE_texture_compression_dxt5"))
+            context->m_BaseContext.m_TextureFormatSupport |= 1ULL << TEXTURE_FORMAT_RGBA_BC3;
+
         // https://www.khronos.org/registry/OpenGL/extensions/ARB/ARB_texture_compression_rgtc.txt
         if (OpenGLIsExtensionSupported(_context, "GL_ARB_texture_compression_rgtc") ||
             OpenGLIsExtensionSupported(_context, "GL_EXT_texture_compression_rgtc") ||
@@ -1694,7 +1488,10 @@ static void LogFrameBufferError(GLenum status)
         else
         {
             // https://registry.khronos.org/OpenGL/extensions/EXT/EXT_color_buffer_half_float.txt
-            if (OpenGLIsExtensionSupported(_context, "EXT_color_buffer_half_float"))
+            if (OpenGLIsExtensionSupported(_context, "EXT_color_buffer_half_float") ||
+                // Native ANGLE exposes GL-prefixed ES extension names instead of WebGL names.
+                (OpenGLIsExtensionSupported(_context, "GL_EXT_color_buffer_half_float") &&
+                 OpenGLIsExtensionSupported(_context, "GL_OES_texture_half_float")))
             {
                 context->m_BaseContext.m_TextureFormatSupport |= 1ULL << TEXTURE_FORMAT_RGB16F;
                 context->m_BaseContext.m_TextureFormatSupport |= 1ULL << TEXTURE_FORMAT_RGBA16F;
@@ -1707,8 +1504,19 @@ static void LogFrameBufferError(GLenum status)
                 context->m_BaseContext.m_TextureFormatSupport |= 1ULL << TEXTURE_FORMAT_RGBA32F;
             }
 
+            if (OpenGLIsExtensionSupported(_context, "GL_OES_texture_float"))
+            {
+                // ANGLE D3D9 advertises RGB and RGBA float renderability as separate CHROMIUM extensions.
+                if (OpenGLIsExtensionSupported(_context, "GL_CHROMIUM_color_buffer_float_rgb"))
+                    context->m_BaseContext.m_TextureFormatSupport |= 1ULL << TEXTURE_FORMAT_RGB32F;
+                if (OpenGLIsExtensionSupported(_context, "GL_CHROMIUM_color_buffer_float_rgba"))
+                    context->m_BaseContext.m_TextureFormatSupport |= 1ULL << TEXTURE_FORMAT_RGBA32F;
+            }
+
             // https://registry.khronos.org/webgl/extensions/ANGLE_instanced_arrays/
-            if (OpenGLIsExtensionSupported(_context, "ANGLE_instanced_arrays"))
+            if (OpenGLIsExtensionSupported(_context, "ANGLE_instanced_arrays") ||
+                // Native ANGLE exposes the GL-prefixed extension name instead of the WebGL name.
+                OpenGLIsExtensionSupported(_context, "GL_ANGLE_instanced_arrays"))
             {
                 context->m_InstancingSupport = 1;
             }
@@ -1871,6 +1679,11 @@ static void LogFrameBufferError(GLenum status)
 #endif
 
     #ifdef DM_HAVE_OPENGL_COMPUTE_SUPPORT
+        #if defined(DM_GRAPHICS_USE_ANGLE)
+        // ANGLE exports compute symbols independently of context version, but D3D9 only supports GLES2.
+        if (context->m_IsGles3Version)
+        #endif
+        {
         int32_t version_major = 0, version_minor = 0;
         glGetIntegerv(DMGRAPHICS_MAJOR_VERSION, &version_major);
         glGetIntegerv(DMGRAPHICS_MINOR_VERSION, &version_minor);
@@ -1888,6 +1701,7 @@ static void LogFrameBufferError(GLenum status)
         context->m_ComputeSupport &= glBindImageTexture != 0;
 
         #undef COMPUTE_VERSION_NEEDED
+        }
     #endif
 
         // GL_MIN/GL_MAX blend equations are core in GLES3+ and desktop GL.
@@ -2046,12 +1860,26 @@ static void LogFrameBufferError(GLenum status)
             }
         }
 
+    #if defined(DM_GRAPHICS_USE_ANGLE)
+        GLuint handle;
+        if (context->m_IsGles3Version)
+        {
+            glGenVertexArrays(1, &handle);
+        }
+        else
+        {
+            // ANGLE implements OES_vertex_array_object in its frontend for every GLES2 backend.
+            glGenVertexArraysOES(1, &handle);
+        }
+        context->m_GlobalVAO = AddNewGLHandle(context, handle);
+    #else
         if (glGenVertexArrays)
         {
             GLuint handle;
             glGenVertexArrays(1, &handle);
             context->m_GlobalVAO = AddNewGLHandle(context, handle);
         }
+    #endif
 
         SetSwapInterval(_context, params.m_SwapInterval);
 
@@ -2545,7 +2373,19 @@ static void LogFrameBufferError(GLenum status)
 
         if (context->m_InstancingSupport)
         {
+        #if defined(DM_GRAPHICS_USE_ANGLE)
+            // GLES2 requires ANGLE-suffixed instancing entry points; the core variants require GLES3.
+            if (context->m_IsGles3Version)
+            {
+                glVertexAttribDivisor(loc, step_function);
+            }
+            else
+            {
+                glVertexAttribDivisorANGLE(loc, step_function);
+            }
+        #else
             glVertexAttribDivisor(loc, step_function);
+        #endif
             CHECK_GL_ERROR;
         }
     }
@@ -2557,8 +2397,20 @@ static void LogFrameBufferError(GLenum status)
 
         OpenGLContext* context = (OpenGLContext*) _context;
 
+    #if defined(DM_GRAPHICS_USE_ANGLE)
+        if (context->m_IsGles3Version)
+        {
+            glBindVertexArray(GetGLHandle(context, context->m_GlobalVAO));
+        }
+        else
+        {
+            // ANGLE implements OES_vertex_array_object in its frontend for every GLES2 backend.
+            glBindVertexArrayOES(GetGLHandle(context, context->m_GlobalVAO));
+        }
+    #else
         if (glBindVertexArray)
             glBindVertexArray(GetGLHandle(context, context->m_GlobalVAO));
+    #endif
 
         if (context->m_ModificationVersion != vertex_declaration->m_ModificationVersion || vertex_declaration->m_BoundForProgram != program)
         {
@@ -2639,16 +2491,27 @@ static void LogFrameBufferError(GLenum status)
     #else
         #define ANDROID_ES2_BACKWARDS_COMPAT(var, value)
     #endif
+    #if defined(DM_GRAPHICS_USE_ANGLE)
+        #define ANGLE_ES2_BACKWARDS_COMPAT(var, value) ES2_ENUM_WORKAROUND(var, value)
+    #else
+        #define ANGLE_ES2_BACKWARDS_COMPAT(var, value)
+    #endif
 
         switch (format)
         {
         case TEXTURE_FORMAT_LUMINANCE:
             gl_format          = DMGRAPHICS_TEXTURE_FORMAT_LUMINANCE;
             gl_internal_format = DMGRAPHICS_TEXTURE_FORMAT_LUMINANCE;
+            // ANGLE headers expose GLES3 GL_RED even when the D3D9 context is GLES2.
+            ANGLE_ES2_BACKWARDS_COMPAT(gl_format, GL_LUMINANCE);
+            ANGLE_ES2_BACKWARDS_COMPAT(gl_internal_format, GL_LUMINANCE);
             break;
         case TEXTURE_FORMAT_LUMINANCE_ALPHA:
             gl_format          = DMGRAPHICS_TEXTURE_FORMAT_LUMINANCE_ALPHA;
             gl_internal_format = DMGRAPHICS_TEXTURE_FORMAT_LUMINANCE_ALPHA;
+            // ANGLE headers expose GLES3 GL_RG even when the D3D9 context is GLES2.
+            ANGLE_ES2_BACKWARDS_COMPAT(gl_format, GL_LUMINANCE_ALPHA);
+            ANGLE_ES2_BACKWARDS_COMPAT(gl_internal_format, GL_LUMINANCE_ALPHA);
             break;
         case TEXTURE_FORMAT_RGB:
             gl_format          = DMGRAPHICS_TEXTURE_FORMAT_RGB;
@@ -2707,12 +2570,16 @@ static void LogFrameBufferError(GLenum status)
             EMSCRIPTEN_ES2_BACKWARDS_COMPAT(gl_internal_format, DMGRAPHICS_TEXTURE_FORMAT_RGB);
             EMSCRIPTEN_ES2_BACKWARDS_COMPAT(gl_type, DMGRAPHICS_TYPE_HALF_FLOAT_OES);
             ANDROID_ES2_BACKWARDS_COMPAT(gl_type, DMGRAPHICS_TYPE_HALF_FLOAT_OES);
+            // ANGLE GLES2 requires the OES type and an unsized internal format.
+            ANGLE_ES2_BACKWARDS_COMPAT(gl_internal_format, DMGRAPHICS_TEXTURE_FORMAT_RGB);
+            ANGLE_ES2_BACKWARDS_COMPAT(gl_type, DMGRAPHICS_TYPE_HALF_FLOAT_OES);
             break;
         case TEXTURE_FORMAT_RGB32F:
             gl_type            = GL_FLOAT;
             gl_format          = DMGRAPHICS_TEXTURE_FORMAT_RGB;
             gl_internal_format = DMGRAPHICS_TEXTURE_FORMAT_RGB32F;
             EMSCRIPTEN_ES2_BACKWARDS_COMPAT(gl_internal_format, DMGRAPHICS_TEXTURE_FORMAT_RGB);
+            ANGLE_ES2_BACKWARDS_COMPAT(gl_internal_format, DMGRAPHICS_TEXTURE_FORMAT_RGB);
             break;
         case TEXTURE_FORMAT_RGBA16F:
             gl_type            = DMGRAPHICS_TYPE_HALF_FLOAT;
@@ -2721,12 +2588,15 @@ static void LogFrameBufferError(GLenum status)
             EMSCRIPTEN_ES2_BACKWARDS_COMPAT(gl_internal_format, DMGRAPHICS_TEXTURE_FORMAT_RGBA);
             EMSCRIPTEN_ES2_BACKWARDS_COMPAT(gl_type, DMGRAPHICS_TYPE_HALF_FLOAT_OES);
             ANDROID_ES2_BACKWARDS_COMPAT(gl_type, DMGRAPHICS_TYPE_HALF_FLOAT_OES);
+            ANGLE_ES2_BACKWARDS_COMPAT(gl_internal_format, DMGRAPHICS_TEXTURE_FORMAT_RGBA);
+            ANGLE_ES2_BACKWARDS_COMPAT(gl_type, DMGRAPHICS_TYPE_HALF_FLOAT_OES);
             break;
         case TEXTURE_FORMAT_RGBA32F:
             gl_type            = GL_FLOAT;
             gl_format          = DMGRAPHICS_TEXTURE_FORMAT_RGBA;
             gl_internal_format = DMGRAPHICS_TEXTURE_FORMAT_RGBA32F;
             EMSCRIPTEN_ES2_BACKWARDS_COMPAT(gl_internal_format, DMGRAPHICS_TEXTURE_FORMAT_RGBA);
+            ANGLE_ES2_BACKWARDS_COMPAT(gl_internal_format, DMGRAPHICS_TEXTURE_FORMAT_RGBA);
             break;
         case TEXTURE_FORMAT_R16F:
             gl_type            = DMGRAPHICS_TYPE_HALF_FLOAT;
@@ -2754,6 +2624,15 @@ static void LogFrameBufferError(GLenum status)
             gl_type            = GL_FLOAT;
             gl_format          = GL_DEPTH_COMPONENT;
             gl_internal_format = GetDepthBufferFormat(context);
+        #if defined(DM_GRAPHICS_USE_ANGLE)
+            // GLES depth textures require integer upload types here; GL_FLOAT is only valid with DEPTH_COMPONENT32F.
+            gl_type = context->m_DepthBufferBits == 16 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT;
+            if (!context->m_IsGles3Version)
+            {
+                // OES_depth_texture requires matching unsized formats in GLES2.
+                gl_internal_format = GL_DEPTH_COMPONENT;
+            }
+        #endif
         #ifdef __EMSCRIPTEN__
             gl_type            = GL_UNSIGNED_INT;
             gl_internal_format = context->m_IsGles3Version ? GL_DEPTH_COMPONENT24 : DMGRAPHICS_RENDER_BUFFER_FORMAT_DEPTH16;
@@ -2769,6 +2648,7 @@ static void LogFrameBufferError(GLenum status)
     #undef ES2_ENUM_WORKAROUND
     #undef EMSCRIPTEN_ES2_BACKWARDS_COMPAT
     #undef ANDROID_ES2_BACKWARDS_COMPAT
+    #undef ANGLE_ES2_BACKWARDS_COMPAT
     }
 
 #ifdef DM_HAVE_OPENGL_COMPUTE_SUPPORT
@@ -3063,7 +2943,19 @@ static void LogFrameBufferError(GLenum status)
 
         if (context->m_InstancingSupport)
         {
+        #if defined(DM_GRAPHICS_USE_ANGLE)
+            // GLES2 requires ANGLE-suffixed instancing entry points; the core variants require GLES3.
+            if (context->m_IsGles3Version)
+            {
+                glDrawElementsInstanced(GetOpenGLPrimitiveType(prim_type), count, GetOpenGLType(type), (GLvoid*)(uintptr_t) first, dmMath::Max((uint32_t) 1, instance_count));
+            }
+            else
+            {
+                glDrawElementsInstancedANGLE(GetOpenGLPrimitiveType(prim_type), count, GetOpenGLType(type), (GLvoid*)(uintptr_t) first, dmMath::Max((uint32_t) 1, instance_count));
+            }
+        #else
             glDrawElementsInstanced(GetOpenGLPrimitiveType(prim_type), count, GetOpenGLType(type), (GLvoid*)(uintptr_t) first, dmMath::Max((uint32_t) 1, instance_count));
+        #endif
             CHECK_GL_ERROR;
         }
         else
@@ -3084,7 +2976,19 @@ static void LogFrameBufferError(GLenum status)
 
         if (context->m_InstancingSupport)
         {
+        #if defined(DM_GRAPHICS_USE_ANGLE)
+            // GLES2 requires ANGLE-suffixed instancing entry points; the core variants require GLES3.
+            if (context->m_IsGles3Version)
+            {
+                glDrawArraysInstanced(GetOpenGLPrimitiveType(prim_type), first, count, dmMath::Max((uint32_t) 1, instance_count));
+            }
+            else
+            {
+                glDrawArraysInstancedANGLE(GetOpenGLPrimitiveType(prim_type), first, count, dmMath::Max((uint32_t) 1, instance_count));
+            }
+        #else
             glDrawArraysInstanced(GetOpenGLPrimitiveType(prim_type), first, count, dmMath::Max((uint32_t) 1, instance_count));
+        #endif
             CHECK_GL_ERROR;
         }
         else
@@ -3155,6 +3059,7 @@ static void LogFrameBufferError(GLenum status)
                 glGetShaderInfoLog(shader_id, logLength, &logLength, log_str);
             }
 #endif
+
             if (error_buffer)
             {
                 dmSnPrintf(error_buffer, error_buffer_size, "Unable to compile %s shader.\nError: %s", type_str, log_str == 0 ? "Unknown" : log_str);
@@ -3791,6 +3696,12 @@ static void LogFrameBufferError(GLenum status)
         {
         #ifdef DM_HAVE_OPENGL_COMPUTE_SUPPORT
             OpenGLShader* compute_shader = CreateShader(_context, DMGRAPHICS_TYPE_COMPUTE_SHADER, ddf_cp, error_buffer, error_buffer_size);
+            if (!compute_shader)
+            {
+                // A failed shader compilation must return the compiler error instead of entering program setup with a null shader.
+                delete program;
+                return 0;
+            }
             if (!SetupComputeProgram(context, program, compute_shader))
             {
                 DeleteShader(context, compute_shader);
@@ -3804,7 +3715,22 @@ static void LogFrameBufferError(GLenum status)
         else
         {
             OpenGLShader* vertex_shader = CreateShader(_context, GL_VERTEX_SHADER, ddf_vp, error_buffer, error_buffer_size);
+            if (!vertex_shader)
+            {
+                // A failed shader compilation must return the compiler error instead of entering program setup with a null shader.
+                delete program;
+                return 0;
+            }
+
             OpenGLShader* fragment_shader = CreateShader(_context, GL_FRAGMENT_SHADER, ddf_fp, error_buffer, error_buffer_size);
+            if (!fragment_shader)
+            {
+                // A failed shader compilation must return the compiler error instead of entering program setup with a null shader.
+                DeleteShader(context, vertex_shader);
+                delete program;
+                return 0;
+            }
+
             if (!SetupGraphicsProgram(context, program, vertex_shader, fragment_shader))
             {
                 DeleteShader(context, vertex_shader);
@@ -4254,6 +4180,29 @@ static void LogFrameBufferError(GLenum status)
         attachment.m_Attached = true;
     }
 
+    static inline uint32_t GetDepthStencilAttachmentTargets(OpenGLContext* context, GLenum attachment_targets[2])
+    {
+        (void) context;
+    #if defined(DM_GRAPHICS_USE_ANGLE)
+        if (!context->m_IsGles3Version)
+        {
+            // GLES2 attaches packed depth-stencil storage to both attachment points; the combined target is GLES3.
+            attachment_targets[0] = GL_DEPTH_ATTACHMENT;
+            attachment_targets[1] = GL_STENCIL_ATTACHMENT;
+            return 2;
+        }
+    #endif
+
+    #ifdef GL_DEPTH_STENCIL_ATTACHMENT
+        attachment_targets[0] = GL_DEPTH_STENCIL_ATTACHMENT;
+        return 1;
+    #else
+        attachment_targets[0] = GL_DEPTH_ATTACHMENT;
+        attachment_targets[1] = GL_STENCIL_ATTACHMENT;
+        return 2;
+    #endif
+    }
+
     static void ApplyRenderTargetAttachments(HContext _context, OpenGLRenderTarget* rt, bool update_current)
     {
         OpenGLContext* context = (OpenGLContext*) _context;
@@ -4275,15 +4224,9 @@ static void LogFrameBufferError(GLenum status)
                 glBindRenderbuffer(GL_RENDERBUFFER, GetGLHandle(context, rt->m_DepthStencilAttachment.m_Buffer));
                 glRenderbufferStorage(GL_RENDERBUFFER, DMGRAPHICS_RENDER_BUFFER_FORMAT_DEPTH_STENCIL, rt->m_Base.m_DepthStencilTextureParams.m_Width, rt->m_Base.m_DepthStencilTextureParams.m_Height);
                 CHECK_GL_ERROR;
-    #ifdef GL_DEPTH_STENCIL_ATTACHMENT
-                // if we have the capability of GL_DEPTH_STENCIL_ATTACHMENT, create a single combined depth-stencil buffer
-                GLenum attachments[] = { GL_DEPTH_STENCIL_ATTACHMENT };
-                AttachRenderTargetAttachment(context, rt->m_DepthStencilAttachment, rt->m_Base.m_TextureDepthStencil, attachments, DM_ARRAY_SIZE(attachments));
-    #else
-                // create a depth-stencil that has the same buffer attached to both GL_DEPTH_ATTACHMENT and GL_STENCIL_ATTACHMENT (typical ES <= 2.0)
-                GLenum attachments[] = { GL_DEPTH_ATTACHMENT, GL_STENCIL_ATTACHMENT };
-                AttachRenderTargetAttachment(context, rt->m_DepthStencilAttachment, rt->m_Base.m_TextureDepthStencil, attachments, DM_ARRAY_SIZE(attachments));
-    #endif
+                GLenum attachments[2];
+                uint32_t attachment_count = GetDepthStencilAttachmentTargets(context, attachments);
+                AttachRenderTargetAttachment(context, rt->m_DepthStencilAttachment, rt->m_Base.m_TextureDepthStencil, attachments, attachment_count);
                 glBindRenderbuffer(GL_RENDERBUFFER, 0);
             }
             else if (rt->m_DepthStencilAttachment.m_Type == ATTACHMENT_TYPE_TEXTURE)
@@ -4296,21 +4239,25 @@ static void LogFrameBufferError(GLenum status)
                 CHECK_GL_ERROR;
 
                  // The data type (DMGRAPHICS_TYPE_UNSIGNED_INT_24_8) might change later when we introduce 32f depth formats
+                GLint depth_stencil_internal_format = DMGRAPHICS_RENDER_BUFFER_FORMAT_DEPTH24_STENCIL8;
+            #if defined(DM_GRAPHICS_USE_ANGLE)
+                if (!context->m_IsGles3Version)
+                {
+                    // OES_packed_depth_stencil requires matching unsized formats for GLES2 textures.
+                    depth_stencil_internal_format = DMGRAPHICS_FORMAT_DEPTH_STENCIL;
+                }
+            #endif
                 glTexImage2D(GL_TEXTURE_2D, 0,
-                    DMGRAPHICS_RENDER_BUFFER_FORMAT_DEPTH24_STENCIL8,
+                    depth_stencil_internal_format,
                     rt->m_Base.m_DepthStencilTextureParams.m_Width,
                     rt->m_Base.m_DepthStencilTextureParams.m_Height,
                     0, DMGRAPHICS_FORMAT_DEPTH_STENCIL, DMGRAPHICS_TYPE_UNSIGNED_INT_24_8, 0);
                 CHECK_GL_ERROR;
 
                 glBindTexture(GL_TEXTURE_2D, 0);
-            #ifdef GL_DEPTH_STENCIL_ATTACHMENT
-                GLenum attachments[] = { GL_DEPTH_STENCIL_ATTACHMENT };
-                AttachRenderTargetAttachment(context, rt->m_DepthStencilAttachment, rt->m_Base.m_TextureDepthStencil, attachments, DM_ARRAY_SIZE(attachments));
-            #else
-                GLenum attachments[] = { GL_DEPTH_ATTACHMENT, GL_STENCIL_ATTACHMENT };
-                AttachRenderTargetAttachment(context, rt->m_DepthStencilAttachment, rt->m_Base.m_TextureDepthStencil, attachments, DM_ARRAY_SIZE(attachments));
-            #endif
+                GLenum attachments[2];
+                uint32_t attachment_count = GetDepthStencilAttachmentTargets(context, attachments);
+                AttachRenderTargetAttachment(context, rt->m_DepthStencilAttachment, rt->m_Base.m_TextureDepthStencil, attachments, attachment_count);
             }
             else
             {
@@ -4375,6 +4322,24 @@ static void LogFrameBufferError(GLenum status)
             BUFFER_TYPE_COLOR3_BIT,
         };
 
+    #if defined(DM_GRAPHICS_USE_ANGLE)
+        bool depth_texture_supported = context->m_IsGles3Version ||
+            OpenGLIsExtensionSupported(_context, "GL_OES_depth_texture") ||
+            OpenGLIsExtensionSupported(_context, "GL_ANGLE_depth_texture");
+        if (depth_texture && !depth_texture_supported)
+        {
+            // ANGLE D3D9 does not expose depth textures, so keep the render target usable with a renderbuffer.
+            dmLogWarning("Depth textures are not supported by this OpenGL ES context, defaulting to render buffer.");
+            depth_texture = false;
+        }
+        if (depth_texture && use_stencil_attachment && !context->m_PackedDepthStencilSupport)
+        {
+            // A shared GLES2 depth-stencil texture also requires OES_packed_depth_stencil.
+            dmLogWarning("Packed depth-stencil textures are not supported by this OpenGL ES context, defaulting to render buffer.");
+            depth_texture = false;
+        }
+    #endif
+
         // NOTE: Regarding this, the OpenGL context we create is to low on all current desktop platforms to use, but it should work for the other adapters.
         if (stencil_texture)
         {
@@ -5553,6 +5518,15 @@ static void LogFrameBufferError(GLenum status)
     {
         GraphicsAdapterFunctionTable fn_table = {};
         DM_REGISTER_GRAPHICS_FUNCTION_TABLE(fn_table, OpenGL);
+
+        #if defined(GLFW_ANGLE_PLATFORM_TYPE)
+        const char* angle_platform_type = getenv("DM_ANGLE_PLATFORM_TYPE");
+        if (angle_platform_type && strcmp(angle_platform_type, "d3d9") == 0)
+        {
+            glfwInitHint(GLFW_ANGLE_PLATFORM_TYPE, GLFW_ANGLE_PLATFORM_TYPE_D3D9);
+        }
+        #endif
+
         return fn_table;
     }
 }
diff --git a/engine/graphics/src/opengl/graphics_opengl_defines.h b/engine/graphics/src/opengl/graphics_opengl_defines.h
index 1e190182a5..28a1cdae3f 100644
--- a/engine/graphics/src/opengl/graphics_opengl_defines.h
+++ b/engine/graphics/src/opengl/graphics_opengl_defines.h
@@ -43,12 +43,10 @@
 #define GL_HAS_RENDERDOC_SUPPORT
 #include <dlib/safe_windows.h>
 #include <stdlib.h>
-#include <GL/gl.h>
-#include <GL/glu.h>
-#include <win32/glut.h>
 
-#include "win32/glext.h"
-#include "win32/glcorearb.h"
+#define GL_GLEXT_PROTOTYPES
+#include <angle_gl.h>
+#define GL_BGRA GL_BGRA_EXT
 
 #elif defined (ANDROID)
 #define GL_GLEXT_PROTOTYPES
diff --git a/engine/graphics/src/wscript b/engine/graphics/src/wscript
index ea75ce413c..f41fe76cb0 100755
--- a/engine/graphics/src/wscript
+++ b/engine/graphics/src/wscript
@@ -72,6 +72,9 @@ def build(bld):
             if graphics_feature == 'opengles':
                 opengl_target = 'graphics_opengles'
                 opengl_defines = ['DM_GRAPHICS_USE_OPENGLES']
+                if bld.env.PLATFORM in ('x86_64-win32', 'win32'):
+                    # Win32 OpenGLES links against ANGLE and enables its backend-specific paths.
+                    opengl_defines.append('DM_GRAPHICS_USE_ANGLE')
 
             if platform_supports_feature(bld.env.PLATFORM, 'opengl_compute', {}):
                 opengl_defines.append('DM_HAVE_OPENGL_COMPUTE_SUPPORT')
diff --git a/engine/graphics/wscript b/engine/graphics/wscript
index 73ebcf8b8c..7834eac6b2 100644
--- a/engine/graphics/wscript
+++ b/engine/graphics/wscript
@@ -59,7 +59,7 @@ def configure(conf):
     elif platform == "arm64-linux":
         conf.env.append_value('LINKFLAGS', ['-lXext', '-lX11', '-lXi', '-lEGL', '-lGLESv1_CM', '-lGLESv2', '-lpthread'])
     elif target_os == TargetOS.WINDOWS:
-        conf.env.append_value('LINKFLAGS', ['opengl32.lib'])
+        conf.env.append_value('LINKFLAGS', ['libEGL.dll.lib', 'libGLESv2.dll.lib'])
 
     conf.env.append_value('INCLUDES', "../src")
     conf.env.append_value('INCLUDES', os.path.join(dynamo_ext, "include"))
diff --git a/engine/tools/CMakeLists.txt b/engine/tools/CMakeLists.txt
index 0083a9bb43..947dce3432 100644
--- a/engine/tools/CMakeLists.txt
+++ b/engine/tools/CMakeLists.txt
@@ -34,8 +34,13 @@ endif()
 
 if(TOOLS_IS_DESKTOP)
   block()
-    # gdc creates an OpenGL window even when the engine build also enables Vulkan.
+    # gdc creates a graphics window even when the engine build also enables Vulkan.
+    set(TOOLS_GDC_GRAPHICS_LIBRARY graphics)
     set(TOOLS_GDC_EXPORTS GraphicsAdapterOpenGL)
+    if(TARGET_PLATFORM MATCHES "^(x86-win32|x86_64-win32)$")
+      set(TOOLS_GDC_GRAPHICS_LIBRARY graphics_opengles)
+      set(TOOLS_GDC_EXPORTS GraphicsAdapterOpenGLES)
+    endif()
     set(TOOLS_GDC_EXPORT_FILE "${CMAKE_CURRENT_BINARY_DIR}/gdc_exported_symbols.cpp")
     defold_create_exported_symbols_file("${TOOLS_GDC_EXPORT_FILE}" "${TOOLS_GDC_EXPORTS}")
     defold_add_executable(gdc
@@ -53,7 +58,7 @@ if(TOOLS_IS_DESKTOP)
       zip
       mbedtls
       profile_null
-      graphics
+      ${TOOLS_GDC_GRAPHICS_LIBRARY}
       image
       graphics_transcoder_basisu
       basis_transcoder
diff --git a/engine/tools/wscript b/engine/tools/wscript
index 63def42bdc..95c5b29efe 100755
--- a/engine/tools/wscript
+++ b/engine/tools/wscript
@@ -48,7 +48,8 @@ def configure(conf):
     elif platform == 'x86_64-ios':
         pass
     elif target_os == TargetOS.WINDOWS:
-        conf.env.append_value('LINKFLAGS', ['opengl32.lib', 'user32.lib', 'shell32.lib', 'xinput9_1_0.lib', 'dinput8.lib', 'dxguid.lib'])
+        conf.env.append_value('LINKFLAGS', ['user32.lib', 'shell32.lib', 'xinput9_1_0.lib', 'dinput8.lib', 'dxguid.lib'])
+        conf.env.append_value('LINKFLAGS', ['libEGL.dll.lib', 'libGLESv2.dll.lib'])
     elif target_os == TargetOS.ANDROID:
         conf.env.append_value('LINKFLAGS', ['-lEGL', '-lGLESv1_CM', '-lGLESv2', '-landroid'])
 
diff --git a/scripts/build.py b/scripts/build.py
index 155d1b4557..e6561911a6 100755
--- a/scripts/build.py
+++ b/scripts/build.py
@@ -263,6 +263,7 @@ PACKAGES_MACOS_ARM64=[
     "zipalign"]
 
 PACKAGES_WIN32=[
+    "angle-06e6c6b5",
     "protobuf-3.20.1",
     "luajit-2.1.0-3e223cb",
     "glut-3.7.6",
@@ -278,6 +279,7 @@ PACKAGES_WIN32=[
     "SkriBidi-1e8038"]
 
 PACKAGES_WIN32_64=[
+    "angle-06e6c6b5",
     "protobuf-3.20.1",
     "luajit-2.1.0-3e223cb",
     "glut-3.7.6",
diff --git a/scripts/cmake/functions_graphics.cmake b/scripts/cmake/functions_graphics.cmake
index ce6a390e12..d52ec12f1b 100644
--- a/scripts/cmake/functions_graphics.cmake
+++ b/scripts/cmake/functions_graphics.cmake
@@ -62,6 +62,9 @@ function(defold_get_graphics_symbols OUT_VAR PLATFORM)
     elseif("${PLATFORM}" MATCHES "^(arm64-linux)$")
         set(_use_opengles ON)
         set(_use_vulkan ${_WITH_VULKAN})
+    elseif("${PLATFORM}" MATCHES "^(x86-win32|x86_64-win32)$")
+        set(_use_opengles ON)
+        set(_use_vulkan ${_WITH_VULKAN})
     elseif("${PLATFORM}" MATCHES "^(armv7-android|arm64-android)$")
         set(_use_opengles ${_WITH_OPENGL})
         if(NOT _WITH_VULKAN)
@@ -173,7 +176,7 @@ function(defold_target_link_graphics target platform)
         set(OPENGL   GL;GLU)
         set(OPENGLES EGL;GLESv1_CM;GLESv2)
     elseif(_PLAT_OS STREQUAL "win32")
-        set(OPENGL_LINKFLAGS opengl32.lib;glu32.lib)
+        set(OPENGLES libEGL.dll.lib;libGLESv2.dll.lib)
     elseif(_PLAT_OS STREQUAL "macos")
         set(FRAMEWORK_OPENGL OpenGL)
     elseif(_PLAT_OS STREQUAL "ios")
@@ -255,6 +258,9 @@ function(defold_target_link_graphics target platform)
     elseif("${platform}" MATCHES "^(arm64-linux)$")
         set(_use_opengles ON)
         set(_use_vulkan ${_WITH_VULKAN})
+    elseif("${platform}" MATCHES "^(x86-win32|x86_64-win32)$")
+        set(_use_opengles ON)
+        set(_use_vulkan ${_WITH_VULKAN})
     elseif("${platform}" MATCHES "^(armv7-android|arm64-android)$")
         set(_use_opengles ${_WITH_OPENGL})
         if(NOT _WITH_VULKAN)
diff --git a/scripts/cmake/functions_libs.cmake b/scripts/cmake/functions_libs.cmake
index ffbd802d6a..513d31b0ff 100644
--- a/scripts/cmake/functions_libs.cmake
+++ b/scripts/cmake/functions_libs.cmake
@@ -146,6 +146,8 @@ function(defold_target_link_libraries target platform)
       list(APPEND _LIBS ${_vendor_libs})
     elseif(_lib STREQUAL "graphics" AND DEFINED DEFOLD_PLATFORM_GRAPHICS_LIBS)
       list(APPEND _LIBS ${DEFOLD_PLATFORM_GRAPHICS_LIBS})
+    elseif(_lib STREQUAL "graphics" AND "${platform}" MATCHES "^(x86-win32|x86_64-win32)$")
+      list(APPEND _LIBS graphics_opengles)
     elseif(_lib STREQUAL "lua" AND NOT "${platform}" MATCHES "^(js-web|wasm-web|wasm_pthread-web)$")
       list(APPEND _LIBS luajit-5.1)
     else()
diff --git a/scripts/cmake/functions_opengl.cmake b/scripts/cmake/functions_opengl.cmake
index 9b5d25715b..ed412854a5 100644
--- a/scripts/cmake/functions_opengl.cmake
+++ b/scripts/cmake/functions_opengl.cmake
@@ -27,8 +27,8 @@ function(defold_target_link_opengl target platform)
     string(REGEX REPLACE "^[^-]+-" "" _PLAT_OS "${platform}")
 
     if(_PLAT_OS STREQUAL "win32")
-        # Windows OpenGL libraries
-        target_link_libraries(${target} ${DOGL_SCOPE} opengl32 glu32)
+        # Windows uses ANGLE's OpenGL ES import libraries in the ANGLE build.
+        target_link_libraries(${target} ${DOGL_SCOPE} libEGL.dll.lib libGLESv2.dll.lib)
 
     elseif(_PLAT_OS STREQUAL "macos")
         # macOS frameworks