1. [Home](https://scrapfly.io/)
2. [Tools](https://scrapfly.io/web-scraping-tools)
3. [GPU Fingerprint](https://scrapfly.io/web-scraping-tools/gpu-fingerprint)
4. WebGL Extensions
 
   # WebGL Extensions Database

Complete reference of 49 WebGL extensions

 

  ### About WebGL Extensions

 

 WebGL extensions provide additional functionality beyond the core WebGL API. They expose hardware capabilities, enable advanced rendering techniques, and provide access to specialized GPU features.

 In **GPU fingerprinting**, the set of available WebGL extensions is a highly distinctive identifier of the graphics hardware, driver version, and browser implementation. Different GPUs and drivers support different extensions, making this a reliable fingerprinting vector.

 **WebGL Versions:** Extensions are categorized by WebGL 1.0 (based on OpenGL ES 2.0) and WebGL 2.0 (based on OpenGL ES 3.0). Some extensions are promoted to core features in WebGL 2.0.

 

 

  ### Search WebGL Extensions

 

  

  All WebGL Versions WebGL 1.0 WebGL 2.0 Both Versions  

 

   Try searching for: "instanced", "texture", "draw buffers", "ANGLE", "EXT"

 

  ### All WebGL Extensions (49)

 

 | Extension Name | WebGL Version | Description |
|---|---|---|
| [ `ANGLE_instanced_arrays` ](#angle-instanced-arrays) | WebGL1 | The ANGLE\_instanced\_arrays extension is part of the WebGL API and allows to draw the same object or groups of similar objects multiple times, if they share the same vertex data, primitive count and type. Instancing helps with drawing objects like trees, grass, or a large number of objects in a scene. Use drawArraysInstancedANGLE() and drawElementsInstancedANGLE() methods. Available in WebGL1; in WebGL2, this functionality is built-in by default. |
| [ `EXT_blend_minmax` ](#ext-blend-minmax) | WebGL1 | The EXT\_blend\_minmax extension is part of the WebGL API and extends blending capabilities by adding two new blend equations: the minimum or maximum color components of the source and destination colors. Use MIN\_EXT and MAX\_EXT constants with blendEquation() and blendEquationSeparate(). Available in WebGL1 only; in WebGL2, the functionality is available by default as gl.MIN and gl.MAX. |
| [ `EXT_color_buffer_float` ](#ext-color-buffer-float) | WebGL2 | The EXT\_color\_buffer\_float extension is part of the WebGL API and adds the ability to render to a variety of floating point formats. Makes seven sized formats color-renderable: R16F, RG16F, RGBA16F, R32F, RG32F, RGBA32F, and R11F\_G11F\_B10F for use with renderbufferStorage(). Available in WebGL2 only; for WebGL1, use EXT\_color\_buffer\_half\_float or WEBGL\_color\_buffer\_float. |
| [ `EXT_color_buffer_half_float` ](#ext-color-buffer-half-float) | Both | The EXT\_color\_buffer\_half\_float extension is part of the WebGL API and adds the ability to render to 16-bit floating-point color buffers. Provides RGBA16F\_EXT and RGB16F\_EXT constants for use with renderbufferStorage(). Available in both WebGL1 and WebGL2; implicitly enabled by OES\_texture\_half\_float extension. |
| [ `EXT_disjoint_timer_query` ](#ext-disjoint-timer-query) | WebGL1 | The EXT\_disjoint\_timer\_query extension is part of the WebGL API and provides a way to measure the duration of GL commands without stalling the rendering pipeline. Provides query objects, constants (QUERY\_COUNTER\_BITS\_EXT, TIME\_ELAPSED\_EXT, TIMESTAMP\_EXT, GPU\_DISJOINT\_EXT), and methods like createQueryEXT(), beginQueryEXT(), endQueryEXT(). Available in WebGL1 only; in WebGL2, use EXT\_disjoint\_timer\_query\_webgl2. |
| [ `EXT_float_blend` ](#ext-float-blend) | Both | The EXT\_float\_blend extension is part of the WebGL API and allows blending and draw buffers with 32-bit floating-point components. Automatically enabled when WEBGL\_color\_buffer\_float or EXT\_color\_buffer\_float are enabled. Prevents INVALID\_OPERATION errors when calling drawArrays() or drawElements() with blending enabled on 32-bit float draw buffers. Available in both WebGL1 and WebGL2. |
| [ `EXT_frag_depth` ](#ext-frag-depth) | WebGL1 | The EXT\_frag\_depth extension is part of the WebGL API and enables setting a depth value of a fragment from within the fragment shader. Provides the gl\_FragDepthEXT output variable for custom depth values, useful for depth-based effects and advanced rendering techniques. Available in WebGL1 only; in WebGL2, this functionality is available by default with GLSL #version 300 es. |
| [ `EXT_shader_texture_lod` ](#ext-shader-texture-lod) | WebGL1 | The EXT\_shader\_texture\_lod extension is part of the WebGL API and adds texture functions to GLSL shaders providing explicit control of LOD (Level of Detail). Provides texture2DLodEXT, texture2DProjLodEXT, textureCubeLodEXT, and gradient functions for avoiding wrapping artifacts. Available in WebGL1 only; in WebGL2, this functionality is available by default with GLSL #version 300 es. |
| [ `EXT_sRGB` ](#ext-srgb) | WebGL1 | The EXT\_sRGB extension is part of the WebGL API and adds sRGB support to textures and framebuffers. Provides constants SRGB\_EXT, SRGB\_ALPHA\_EXT, SRGB8\_ALPHA8\_EXT, and FRAMEBUFFER\_ATTACHMENT\_COLOR\_ENCODING\_EXT for textures/framebuffers in sRGB color space, ensuring accurate color representation. Available in WebGL1 only; in WebGL2, sRGB formats are available by default without the \_EXT suffix. |
| [ `EXT_texture_compression_bptc` ](#ext-texture-compression-bptc) | Both | The EXT\_texture\_compression\_bptc extension is part of the WebGL API and exposes 4 BPTC compressed texture formats (BC7 and BC6H in DirectX). Provides COMPRESSED\_RGBA\_BPTC\_UNORM\_EXT, COMPRESSED\_SRGB\_ALPHA\_BPTC\_UNORM\_EXT, COMPRESSED\_RGB\_BPTC\_SIGNED\_FLOAT\_EXT, and COMPRESSED\_RGB\_BPTC\_UNSIGNED\_FLOAT\_EXT. Each 4x4 block uses 128 bits. Available in both WebGL1 and WebGL2, but not supported on Windows. |
| [ `EXT_texture_compression_rgtc` ](#ext-texture-compression-rgtc) | Both | The EXT\_texture\_compression\_rgtc extension is part of the WebGL API and exposes 4 RGTC compressed texture formats. RGTC is a block-based texture compression format suited for unsigned and signed red and red-green textures (Red-Green Texture Compression). It provides 4 formats: COMPRESSED\_RED\_RGTC1\_EXT, COMPRESSED\_SIGNED\_RED\_RGTC1\_EXT, COMPRESSED\_RED\_GREEN\_RGTC2\_EXT, and COMPRESSED\_SIGNED\_RED\_GREEN\_RGTC2\_EXT. Each format uses 64-bit blocks for 4x4 texel regions, equivalent to BC4 and BC5. Use with compressedTexImage2D() and compressedTexSubImage2D(). |
| [ `EXT_texture_filter_anisotropic` ](#ext-texture-filter-anisotropic) | Both | The EXT\_texture\_filter\_anisotropic extension is part of the WebGL API and exposes two constants for anisotropic filtering (AF). Improves the quality of mipmapped texture access when viewing textured primitives at oblique angles. Provides MAX\_TEXTURE\_MAX\_ANISOTROPY\_EXT and TEXTURE\_MAX\_ANISOTROPY\_EXT constants. Available in both WebGL1 and WebGL2. |
| [ `EXT_texture_norm16` ](#ext-texture-norm16) | WebGL2 | The EXT\_texture\_norm16 extension is part of the WebGL API and provides 16-bit signed normalized and unsigned normalized formats for textures, renderbuffers, and texture buffers. Provides R16\_EXT, RG16\_EXT, RGB16\_EXT, RGBA16\_EXT (unsigned) and R16\_SNORM\_EXT, RG16\_SNORM\_EXT, RGB16\_SNORM\_EXT, RGBA16\_SNORM\_EXT (signed). Available in WebGL2 only. |
| [ `KHR_parallel_shader_compile` ](#khr-parallel-shader-compile) | Both | The KHR\_parallel\_shader\_compile extension is part of the WebGL API and enables non-blocking poll operations for compile/link status. Provides COMPLETION\_STATUS\_KHR constant to check shader/program compilation status without stalling the runtime, allowing asynchronous shader compilation for improved loading performance. Available in both WebGL1 and WebGL2. |
| [ `OES_draw_buffers_indexed` ](#oes-draw-buffers-indexed) | WebGL2 | The OES\_draw\_buffers\_indexed extension is part of the WebGL API and enables different blend options when writing to multiple color buffers simultaneously. Provides blendEquationiOES(), blendFunciOES(), colorMaskiOES(), enableiOES(), and disableiOES() methods for per-buffer blend control. Available in WebGL2 only. |
| [ `OES_element_index_uint` ](#oes-element-index-uint) | WebGL1 | The OES\_element\_index\_uint extension is part of the WebGL API and adds support for gl.UNSIGNED\_INT types to drawElements(). This allows using 32-bit unsigned integer indices instead of just 16-bit, enabling much larger geometry (up to 4.29 billion vertices instead of 65,536). Available in WebGL1 only; in WebGL2, this functionality is available by default. |
| [ `OES_fbo_render_mipmap` ](#oes-fbo-render-mipmap) | WebGL1 | The OES\_fbo\_render\_mipmap extension is part of the WebGL API and makes it possible to attach any level of a texture to a framebuffer object for rendering directly to specific mipmap levels. Available in WebGL1 only; in WebGL2, this functionality is available by default. |
| [ `OES_standard_derivatives` ](#oes-standard-derivatives) | WebGL1 | The OES\_standard\_derivatives extension is part of the WebGL API and adds the GLSL derivative functions dFdx, dFdy, and fwidth to fragment shaders. These functions allow shaders to compute the rate of change of values across pixels, useful for procedural effects, anti-aliasing, and normal map calculations. The GL\_OES\_standard\_derivatives directive must be enabled in shaders. Available in WebGL1 only; in WebGL2, these functions are available by default. |
| [ `OES_texture_float` ](#oes-texture-float) | WebGL1 | The OES\_texture\_float extension is part of the WebGL API and exposes floating-point pixel types for textures. The type parameter of texImage2D() and texSubImage2D() accepts gl.FLOAT, and pixels can be a Float32Array. Linear filtering is not allowed unless OES\_texture\_float\_linear extension is also enabled. This extension implicitly enables WEBGL\_color\_buffer\_float if supported. Available in WebGL1 only; in WebGL2, this functionality is available by default. |
| [ `OES_texture_float_linear` ](#oes-texture-float-linear) | WebGL1 | The OES\_texture\_float\_linear extension is part of the WebGL API and allows LINEAR and LINEAR\_MIPMAP\_\* magnification/minification filters to be used with floating-point pixel types. Must be used in conjunction with OES\_texture\_float extension. Without this extension, nearest-neighbor filtering is the only option for float textures. Available in WebGL1 only; in WebGL2, linear filtering for float textures is available by default. |
| [ `OES_texture_half_float` ](#oes-texture-half-float) | WebGL1 | The OES\_texture\_half\_float extension is part of the WebGL API and adds texture formats with 16-bit (half float) and 32-bit floating-point components. The type parameter of texImage2D() and texSubImage2D() accepts ext.HALF\_FLOAT\_OES constant. Linear filtering is not allowed unless OES\_texture\_half\_float\_linear extension is also enabled. This extension implicitly enables EXT\_color\_buffer\_half\_float if supported. Available in WebGL1 only; in WebGL2, the constant is gl.HALF\_FLOAT. |
| [ `OES_texture_half_float_linear` ](#oes-texture-half-float-linear) | WebGL1 | The OES\_texture\_half\_float\_linear extension is part of the WebGL API and allows LINEAR and LINEAR\_MIPMAP\_\* magnification/minification filters to be used with half floating-point pixel types. Must be used with OES\_texture\_half\_float extension. Without this extension, only nearest-neighbor filtering is available for half-float textures. Available in WebGL1 only; in WebGL2, linear filtering for half-float textures is available by default. |
| [ `OES_vertex_array_object` ](#oes-vertex-array-object) | WebGL1 | The OES\_vertex\_array\_object extension is part of the WebGL API and provides vertex array objects (VAOs) which encapsulate vertex array states. Provides createVertexArrayOES(), deleteVertexArrayOES(), isVertexArrayOES(), and bindVertexArrayOES() methods for efficient vertex state management. Available in WebGL1 only; in WebGL2, this functionality is available by default without the OES\_ suffix. |
| [ `OVR_multiview2` ](#ovr-multiview2) | WebGL2 | The OVR\_multiview2 extension is part of the WebGL API and adds support for rendering into multiple views simultaneously, especially useful for VR/WebXR. Provides framebufferTextureMultiviewOVR() method and constants like MAX\_VIEWS\_OVR. Requires WebGL2 and GLSL 3.00, not available on all platforms (Windows+ANGLE and Android supported). Available in WebGL2 only. |
| [ `WEBGL_blend_func_extended` ](#webgl-blend-func-extended) | Both | The WEBGL\_blend\_func\_extended extension is part of the WebGL API and provides extended blending capabilities with dual-source blending. Enables advanced blending operations by providing SRC1\_COLOR\_WEBGL, SRC1\_ALPHA\_WEBGL, ONE\_MINUS\_SRC1\_COLOR\_WEBGL, and ONE\_MINUS\_SRC1\_ALPHA\_WEBGL constants for use with blendFunc() and blendFuncSeparate(). Dual-source blending allows fragment shaders to output two colors that are blended together, enabling techniques like order-independent transparency. Available in both WebGL1 and WebGL2. |
| [ `WEBGL_color_buffer_float` ](#webgl-color-buffer-float) | WebGL1 | The WEBGL\_color\_buffer\_float extension is part of the WebGL API and adds the ability to render to 32-bit floating-point color buffers. Provides RGBA32F\_EXT and deprecated RGB32F\_EXT constants for renderbufferStorage(). Implicitly enabled by OES\_texture\_float extension. Available in WebGL1 only; for WebGL2, use EXT\_color\_buffer\_float. |
| [ `WEBGL_compressed_texture_astc` ](#webgl-compressed-texture-astc) | Both | The WEBGL\_compressed\_texture\_astc extension is part of the WebGL API and exposes ASTC (Adaptive Scalable Texture Compression) compressed texture formats. Provides 28 constants for different block sizes and getSupportedProfiles() method. Typically available on Mali ARM GPUs, Intel GPUs, and NVIDIA Tegra. Available in both WebGL1 and WebGL2. |
| [ `WEBGL_compressed_texture_etc` ](#webgl-compressed-texture-etc) | Both | The WEBGL\_compressed\_texture\_etc extension is part of the WebGL API and exposes 10 ETC/EAC compressed texture formats. Provides formats like COMPRESSED\_RGB8\_ETC2, COMPRESSED\_RGBA8\_ETC2\_EAC, COMPRESSED\_R11\_EAC, and COMPRESSED\_RG11\_EAC for reduced memory usage. Available in both WebGL1 and WebGL2. |
| [ `WEBGL_compressed_texture_etc1` ](#webgl-compressed-texture-etc1) | Both | The WEBGL\_compressed\_texture\_etc1 extension is part of the WebGL API and exposes the ETC1 compressed texture format. Provides COMPRESSED\_RGB\_ETC1\_WEBGL constant for compressing 24-bit RGB data with no alpha. Note: NOT supported with compressedTexSubImage2D(). Available in both WebGL1 and WebGL2. |
| [ `WEBGL_compressed_texture_pvrtc` ](#webgl-compressed-texture-pvrtc) | Both | The WEBGL\_compressed\_texture\_pvrtc extension is part of the WebGL API and exposes four PVRTC compressed texture formats. Provides COMPRESSED\_RGB\_PVRTC\_4BPPV1\_IMG, COMPRESSED\_RGBA\_PVRTC\_4BPPV1\_IMG, COMPRESSED\_RGB\_PVRTC\_2BPPV1\_IMG, and COMPRESSED\_RGBA\_PVRTC\_2BPPV1\_IMG for reduced memory usage. Typically only available on mobile devices with PowerVR chipsets (iPhone, iPod Touch, iPad, and certain Android devices). Available in both WebGL1 and WebGL2, but named WEBKIT\_WEBGL\_compressed\_texture\_pvrtc on iOS devices. |
| [ `WEBGL_compressed_texture_s3tc` ](#webgl-compressed-texture-s3tc) | Both | The WEBGL\_compressed\_texture\_s3tc extension is part of the WebGL API and exposes four S3TC compressed texture formats. S3TC is a group of texture compression algorithms (also known as DXT or DXTC). Provides COMPRESSED\_RGB\_S3TC\_DXT1\_EXT, COMPRESSED\_RGBA\_S3TC\_DXT1\_EXT, COMPRESSED\_RGBA\_S3TC\_DXT3\_EXT, and COMPRESSED\_RGBA\_S3TC\_DXT5\_EXT. These formats are supported primarily on desktop GPUs. Use with compressedTexImage2D() and compressedTexSubImage2D(). |
| [ `WEBGL_compressed_texture_s3tc_srgb` ](#webgl-compressed-texture-s3tc-srgb) | Both | The WEBGL\_compressed\_texture\_s3tc\_srgb extension is part of the WebGL API and exposes four S3TC compressed texture formats for the sRGB colorspace. Provides COMPRESSED\_SRGB\_S3TC\_DXT1\_EXT, COMPRESSED\_SRGB\_ALPHA\_S3TC\_DXT1\_EXT, COMPRESSED\_SRGB\_ALPHA\_S3TC\_DXT3\_EXT, and COMPRESSED\_SRGB\_ALPHA\_S3TC\_DXT5\_EXT. These formats ensure accurate color representation in sRGB space with S3TC compression. Available in both WebGL1 and WebGL2. |
| [ `WEBGL_debug_renderer_info` ](#webgl-debug-renderer-info) | Both | The WEBGL\_debug\_renderer\_info extension is part of the WebGL API and exposes two constants with information about the GPU: UNMASKED\_VENDOR\_WEBGL returns the vendor string, and UNMASKED\_RENDERER\_WEBGL returns the renderer string. This can be used for debugging, but also poses a privacy/fingerprinting risk. Use with getParameter(). Available in both WebGL1 and WebGL2. |
| [ `WEBGL_debug_shaders` ](#webgl-debug-shaders) | Both | The WEBGL\_debug\_shaders extension is part of the WebGL API and exposes the getTranslatedShaderSource() method which returns translated shader source code as compiled by the ANGLE layer. Useful for debugging GLSL shaders, but is restricted to privileged contexts and disabled in most browsers for security/privacy reasons. Available in both WebGL1 and WebGL2, but typically not accessible. |
| [ `WEBGL_depth_texture` ](#webgl-depth-texture) | WebGL1 | The WEBGL\_depth\_texture extension is part of the WebGL API and defines 2D depth and depth-stencil textures. Adds the UNSIGNED\_INT\_24\_8\_WEBGL constant and extends texImage2D() to accept DEPTH\_COMPONENT and DEPTH\_STENCIL formats, enabling shadow mapping and depth-based effects. Available in WebGL1 only; in WebGL2, the constant is gl.UNSIGNED\_INT\_24\_8. |
| [ `WEBGL_draw_buffers` ](#webgl-draw-buffers) | WebGL1 | The WEBGL\_draw\_buffers extension is part of the WebGL API and enables a fragment shader to write to several textures, useful for deferred shading and multiple render targets (MRT). Provides 16 COLOR\_ATTACHMENT and 16 DRAW\_BUFFER constants, along with the drawBuffersWEBGL() method. Available in WebGL1 only; in WebGL2, available as gl.drawBuffers() by default. |
| [ `WEBGL_lose_context` ](#webgl-lose-context) | Both | The WEBGL\_lose\_context extension is part of the WebGL API and exposes functions to simulate losing and restoring a WebGLRenderingContext. Use loseContext() to simulate context loss and restoreContext() to restore it. This is useful for testing how applications handle webglcontextlost and webglcontextrestored events. Available in both WebGL1 and WebGL2. |
| [ `WEBGL_multi_draw` ](#webgl-multi-draw) | Both | The WEBGL\_multi\_draw extension is part of the WebGL API and allows rendering more than one primitive with a single function call. Provides multiDrawArraysWEBGL(), multiDrawElementsWEBGL(), multiDrawArraysInstancedWEBGL(), and multiDrawElementsInstancedWEBGL() methods plus gl\_DrawID built-in for shaders. Improves WebGL application performance by reducing binding costs and speeding up GPU thread time with uniform data. Available in both WebGL1 and WebGL2, and implicitly enables ANGLE\_instanced\_arrays extension. |
| [ `EXT_polygon_offset_clamp` ](#ext-polygon-offset-clamp) | Both | EXT\_polygon\_offset\_clamp adds a clamp to the polygon offset (depth bias) so the offset cannot exceed a configurable maximum. Useful for shadow mapping pipelines that need predictable depth-bias behavior across hardware. Exposes polygonOffsetClampEXT(factor, units, clamp). Mirrors the OpenGL EXT\_polygon\_offset\_clamp extension. Presence in a WebGL fingerprint correlates with current Chromium and Firefox builds on desktop GPUs. |
| [ `EXT_clip_control` ](#ext-clip-control) | Both | EXT\_clip\_control lets the application choose the clip-space depth convention (zero-to-one vs negative-one-to-one) and the clip origin (lower-left vs upper-left). Matching the convention used by other graphics APIs (Direct3D, Vulkan) avoids having to flip the projection matrix. Exposes clipControlEXT(origin, depth). Common in Chrome 110+ on hardware with full GL 4.5 support. |
| [ `EXT_depth_clamp` ](#ext-depth-clamp) | Both | EXT\_depth\_clamp disables the standard near/far clipping planes and instead clamps the depth value to the \[0, 1\] range, so geometry beyond the near or far plane is rendered with the boundary depth instead of being discarded. Useful for shadow volumes and large skybox geometry. Enabled via gl.enable(gl.DEPTH\_CLAMP\_EXT). Mirrors OpenGL EXT\_depth\_clamp. |
| [ `EXT_conservative_depth` ](#ext-conservative-depth) | WebGL2 | EXT\_conservative\_depth lets a fragment shader declare how it modifies gl\_FragDepth (greater, less, unchanged) so the GPU can keep early-Z optimizations even when the shader writes depth. Without this hint, writing gl\_FragDepth disables early-Z. Declared via layout(depth\_greater) etc. in GLSL ES 3.0 shaders. |
| [ `EXT_texture_mirror_clamp_to_edge` ](#ext-texture-mirror-clamp-to-edge) | Both | EXT\_texture\_mirror\_clamp\_to\_edge adds a new texture wrap mode (MIRROR\_CLAMP\_TO\_EDGE\_EXT) that mirrors the texture exactly once and then clamps to the edge texel. Useful for tiling textures with a mirrored seam without repeating beyond it. Set via texParameteri with gl.TEXTURE\_WRAP\_S / TEXTURE\_WRAP\_T. |
| [ `WEBGL_clip_cull_distance` ](#webgl-clip-cull-distance) | WebGL2 | WEBGL\_clip\_cull\_distance enables gl\_ClipDistance and gl\_CullDistance built-ins in vertex shaders, allowing per-vertex clipping and culling against arbitrary planes. Used for portal rendering, reflective water surfaces, and frustum-shaped clipping volumes. Equivalent to OpenGL ARB\_cull\_distance and Vulkan VK\_EXT\_shader\_clip\_distance. |
| [ `WEBGL_polygon_mode` ](#webgl-polygon-mode) | Both | WEBGL\_polygon\_mode reintroduces the OpenGL glPolygonMode call removed from core WebGL, allowing wireframe rendering by drawing only polygon edges. Exposes polygonModeWEBGL(face, mode) with FILL, LINE, and POINT modes. Heavily used by debugging and CAD-style applications. Limited driver coverage on mobile GPUs. |
| [ `WEBGL_stencil_texturing` ](#webgl-stencil-texturing) | WebGL2 | WEBGL\_stencil\_texturing exposes the depth-stencil texture's stencil component to fragment shaders by setting DEPTH\_STENCIL\_TEXTURE\_MODE to STENCIL\_INDEX. Without this extension, only the depth component is sampleable. Useful for advanced stencil-based effects like outlining, deferred decals, or per-pixel stencil queries. |
| [ `OES_shader_multisample_interpolation` ](#oes-shader-multisample-interpolation) | WebGL2 | OES\_shader\_multisample\_interpolation enables per-sample shading and the interpolateAtSample / interpolateAtCentroid / interpolateAtOffset GLSL ES built-ins. Lets the shader read varyings at specific sub-pixel sample positions instead of the pixel center, which improves antialiasing quality on transparent and high-frequency materials. |
| [ `OES_sample_variables` ](#oes-sample-variables) | WebGL2 | OES\_sample\_variables exposes per-sample built-in variables in fragment shaders: gl\_SampleID (which sample is being shaded), gl\_SamplePosition (sub-pixel coordinate), gl\_SampleMaskIn / gl\_SampleMask (sample coverage masks). Required for custom multisample resolve, shader-based AA, and sample-rate shading techniques. |
| [ `NV_shader_noperspective_interpolation` ](#nv-shader-noperspective-interpolation) | WebGL2 | NV\_shader\_noperspective\_interpolation adds the noperspective qualifier to GLSL ES varyings so the value is interpolated linearly in window space instead of being perspective-corrected. Useful for screen-space effects (silhouette outlines, screen-aligned decals) where perspective correction would skew the shading. Originally an Nvidia extension; mirrors the desktop GL\_NV\_shader\_noperspective\_interpolation. |

 

 No WebGL extensions found matching your filters.

Try adjusting your search query or filters.

 

 

   WebGL 1.0 vs WebGL 2.0 Extensions 

 **WebGL 1.0 Extensions:** Required for features not in core API (instancing, multiple render targets, etc.)

 **WebGL 2.0 Extensions:** Many WebGL 1.0 extensions are built into WebGL 2.0 core. WebGL 2.0 extensions add advanced features like floating-point rendering, timer queries, and parallel shader compilation.

 **Promoted Features:** ANGLE\_instanced\_arrays, WEBGL\_draw\_buffers, OES\_vertex\_array\_object, OES\_standard\_derivatives, and others are core features in WebGL 2.0.

 

 

 

  ### Related Resources

 

##### GPU Fingerprinting

- [GPU Fingerprint Tool](https://scrapfly.io/web-scraping-tools/gpu-fingerprint)
- [Browse All WebGPU Features](https://scrapfly.io/web-scraping-tools/gpu-fingerprint/webgpu)
- [WebGL Fingerprint Test](https://scrapfly.io/web-scraping-tools/webgl-fingerprint)
 
 

##### External References

- [Khronos WebGL Extension Registry ](https://registry.khronos.org/webgl/extensions/)
- [MDN - Using WebGL Extensions ](https://developer.mozilla.org/en-US/docs/Web/API/WebGL_API/Using_Extensions)
- [WebGL Report - Extension Compatibility ](https://webglreport.com/)