Add Support for GL 4.3 (Bug 716) and ES 3.0 (Bug 717)

ES3 / GL4.3:

- Update all EGL, GLX, WGL and GL (desktop and mobile) khronos headers to latest version.
  - GL3/gl3* -> GL/glcorearb*

  - Explicitly preserve ES2_compatibility and ES3_compatibility in header,
    most extension grouping was removed in new headers.

  - Always load all GLHeader to ensure proper extension association across all profiles.

  - Unified method signatures

  - Added GL_EXT_map_buffer_range to core

  - Using common 'glMapBufferImpl(..)' for all glMapBuffer(..) and glMapBufferRange(..) impl.

  - Init necessary fields of GL instances via 'finalizeInit()' called by reflection, if exist.
    This allows removing initialization checks, i.e. for all buffer validations.

- BuildStaticGLInfo: Can handle new GL header structure, i.e. one CPP extenstion block incl. define + funcs.

- GLJavaMethodBindingEmitter: Simply print the

- No GL duplication due to new intermediate interfaces, see below

- OO lineare inheritance (Added GL2ES3, GL3ES3 and GL4ES3 intemediates):
  GLBase - GL - GL2ES2 - GLES2
  GLBase - GL - GL2ES2 - GL2GL3 - [ GL2, GL3 ]
  GLBase - GL - GL2ES2 - GL2ES3 - GL3ES3 - [ GL3 ]
  GLBase - GL - GL2ES2 - GL2ES3 - GL3ES3 - GL4ES3 - [ GLES3, GL4, .. ]

- Expose 'usable' intermediate interfaces GL3ES3 and GL4ES3 in GLBase/GLProfile/GLContext
  via is*() and get*().

- GLContext*:
  - isGL3core() is true if [ GL4, GL3, GLES3 ] (added GLES3)

  - Added ctxProfile argument to allow handling ES versions:
    - getMaxMajor(..), getMaxMinor(..), isValidGLVersion(..) and decrementGLVersion(..)
    - mapGLVersions(..) prepared for ES ARB/KHR validation

  - EGLContext checks ES3 (via old ctx's GL_VERSION)

- ExtensionAvailabilityCache adds GL_ES_Version_X_Y for ES.

- Prelim tests w/ Mesa 9.1.3
  GL Version     3.0 (ES profile, ES2 compat, ES3 compat, FBO, hardware) - OpenGL ES 3.0 Mesa 9.1.3 [GL 3.0.0, vendor 9.1.3 (Mesa 9.1.3)]

- TODO:
  - Use KHR_create_context in EGLContext.createContextARBImpl(..)
  - More tests (Mobile, ..)

+++

Misc:

- GLContext*:
  - Complete glAllocateMemoryNV w/ glFreeMemoryNV.

21 files changed, 855 insertions, 367 deletions

diff --git a/src/jogl/classes/com/jogamp/gluegen/opengl/BuildComposablePipeline.java b/src/jogl/classes/com/jogamp/gluegen/opengl/BuildComposablePipeline.java
index 5334d45cf..b9096df3c 100644
--- a/src/jogl/classes/com/jogamp/gluegen/opengl/BuildComposablePipeline.java
+++ b/src/jogl/classes/com/jogamp/gluegen/opengl/BuildComposablePipeline.java
@@ -71,7 +71,7 @@ public class BuildComposablePipeline {
     // Only desktop OpenGL has immediate mode glBegin / glEnd
     private boolean hasImmediateMode;
     // Desktop OpenGL and GLES1 have GL_STACK_OVERFLOW and GL_STACK_UNDERFLOW errors
-    private boolean hasStackOverflow;
+    private boolean hasGL2ES1StackOverflow;
 
     public static Class<?> getClass(String name) {
         Class<?> clazz = null;
@@ -155,7 +155,7 @@ public class BuildComposablePipeline {
         }
 
         try {
-            hasStackOverflow =
+            hasGL2ES1StackOverflow = hasImmediateMode &&
                     (classToComposeAround.getField("GL_STACK_OVERFLOW") != null);
         } catch (Exception e) {
         }
@@ -602,13 +602,9 @@ public class BuildComposablePipeline {
          * Emits one of the isGL* methods.
          */
         protected void emitGLIsMethod(PrintWriter output, String type) {
+            output.println("  @Override");
             output.println("  public boolean is" + type + "() {");
-            Class<?> clazz = BuildComposablePipeline.getClass("javax.media.opengl." + type);
-            if (clazz.isAssignableFrom(baseInterfaceClass)) {
-                output.println("    return true;");
-            } else {
-                output.println("    return false;");
-            }
+            output.println("    return " + getDownstreamObjectName() + ".is" + type + "();");
             output.println("  }");
         }
 
@@ -624,28 +620,24 @@ public class BuildComposablePipeline {
             emitGLIsMethod(output, "GL2");
             emitGLIsMethod(output, "GLES1");
             emitGLIsMethod(output, "GLES2");
+            emitGLIsMethod(output, "GLES3");
             emitGLIsMethod(output, "GL2ES1");
             emitGLIsMethod(output, "GL2ES2");
+            emitGLIsMethod(output, "GL3ES3");
+            emitGLIsMethod(output, "GL4ES3");
             emitGLIsMethod(output, "GL2GL3");
-            output.println("  public boolean isGLES() {");
-            output.println("    return isGLES2() || isGLES1();");
-            output.println("  }");
-            output.println("  public boolean isGLES2Compatible() {");
-            output.println("    return " + getDownstreamObjectName() + ".isGLES2Compatible();");
-            output.println("  }");
+            emitGLIsMethod(output, "GLES");
+            emitGLIsMethod(output, "GLES2Compatible");
+            emitGLIsMethod(output, "GLES3Compatible");
         }
 
         /**
          * Emits one of the getGL* methods.
          */
         protected void emitGLGetMethod(PrintWriter output, String type) {
+            output.println("  @Override");
             output.println("  public javax.media.opengl." + type + " get" + type + "() {");
-            Class<?> clazz = BuildComposablePipeline.getClass("javax.media.opengl." + type);
-            if (clazz.isAssignableFrom(baseInterfaceClass)) {
-                output.println("    return this;");
-            } else {
-                output.println("    throw new GLException(\"Not a " + type + " implementation\");");
-            }
+            output.println("    return " + getDownstreamObjectName() + ".get" + type + "();");
             output.println("  }");
         }
 
@@ -661,9 +653,13 @@ public class BuildComposablePipeline {
             emitGLGetMethod(output, "GL2");
             emitGLGetMethod(output, "GLES1");
             emitGLGetMethod(output, "GLES2");
+            emitGLGetMethod(output, "GLES3");
             emitGLGetMethod(output, "GL2ES1");
             emitGLGetMethod(output, "GL2ES2");
+            emitGLGetMethod(output, "GL3ES3");
+            emitGLGetMethod(output, "GL4ES3");
             emitGLGetMethod(output, "GL2GL3");
+            output.println("  @Override");
             output.println("  public GLProfile getGLProfile() {");
             output.println("    return " + getDownstreamObjectName() + ".getGLProfile();");
             output.println("  }");
@@ -870,9 +866,9 @@ public class BuildComposablePipeline {
             output.println("        case GL_INVALID_ENUM: buf.append(\"GL_INVALID_ENUM \"); break;");
             output.println("        case GL_INVALID_VALUE: buf.append(\"GL_INVALID_VALUE \"); break;");
             output.println("        case GL_INVALID_OPERATION: buf.append(\"GL_INVALID_OPERATION \"); break;");
-            if (hasStackOverflow) {
-                output.println("        case GL_STACK_OVERFLOW: buf.append(\"GL_STACK_OVERFLOW \"); break;");
-                output.println("        case GL_STACK_UNDERFLOW: buf.append(\"GL_STACK_UNDERFLOW \"); break;");
+            if (hasGL2ES1StackOverflow) {
+                output.println("        case GL2ES1.GL_STACK_OVERFLOW: buf.append(\"GL_STACK_OVERFLOW \"); break;");
+                output.println("        case GL2ES1.GL_STACK_UNDERFLOW: buf.append(\"GL_STACK_UNDERFLOW \"); break;");
             }
             output.println("        case GL_OUT_OF_MEMORY: buf.append(\"GL_OUT_OF_MEMORY \"); break;");
             output.println("        case GL_NO_ERROR: throw new InternalError(\"Should not be treating GL_NO_ERROR as error\");");
diff --git a/src/jogl/classes/com/jogamp/gluegen/opengl/BuildStaticGLInfo.java b/src/jogl/classes/com/jogamp/gluegen/opengl/BuildStaticGLInfo.java
index 482d35cae..5298cc357 100644
--- a/src/jogl/classes/com/jogamp/gluegen/opengl/BuildStaticGLInfo.java
+++ b/src/jogl/classes/com/jogamp/gluegen/opengl/BuildStaticGLInfo.java
@@ -106,14 +106,21 @@ import java.util.regex.Pattern;
 public class BuildStaticGLInfo {
 
   // Handles function pointer 
-  protected static int funcIdentifierGroup = 10;
+  protected static final int funcIdentifierGroup = 9;
   protected static Pattern funcPattern =
-    Pattern.compile("^(GLAPI|GL_API|GL_APICALL|EGLAPI|extern)?(\\s*)((unsigned|const)\\s+)?(\\w+)(\\s*\\*)?(\\s+)(GLAPIENTRY|GL_APIENTRY|APIENTRY|EGLAPIENTRY|WINAPI)?(\\s*)([ew]?gl\\w+)\\s?(\\(.*)");
+    Pattern.compile("^(GLAPI|GL_API|GL_APICALL|EGLAPI|extern)?(\\s*)((unsigned|const)\\s+)?(\\w+)(\\s+\\*\\s*|\\s*\\*\\s+|\\s+)?(GLAPIENTRY|GL_APIENTRY|APIENTRY|EGLAPIENTRY|WINAPI)?(\\s*)([ew]?gl\\w+)\\s?(\\(.*)");
 
   protected static Pattern associationPattern =
     Pattern.compile("\\#ifndef ([CEW]?GL[XU]?_[A-Za-z0-9_]+)(.*)");
 
-  protected static int defineIdentifierGroup = 1;
+  protected static Pattern ifPattern =
+    Pattern.compile("\\#if(.*)");
+  protected static Pattern elsePattern =
+    Pattern.compile("\\#(elif|else)(.*)");
+  protected static Pattern endifPattern =
+    Pattern.compile("\\#endif(.*)");
+  
+  protected static final int defineIdentifierGroup = 1;
   protected static Pattern definePattern =
     Pattern.compile("\\#define ([CEW]?GL[XU]?_[A-Za-z0-9_]+)\\s*([A-Za-z0-9_]+)(.*)");
 
@@ -194,38 +201,62 @@ public class BuildStaticGLInfo {
         BufferedReader reader = new BufferedReader(new FileReader(cHeaderFilePath));
         String line, activeAssociation = null;
         Matcher m = null;
+        int block = 0;
         while ((line = reader.readLine()) != null) {
-            int type = 0; // 1-define, 2-function
-            // see if we're inside a #ifndef GL_XXX block and matching a function
-            if (activeAssociation != null) {
+            int type = 0; // 1-define, 2-function            
+            if ( 0 < block ) { // inside a #ifndef GL_XXX block and matching a function, if block > 0
                 String identifier = null;
-                if ((m = funcPattern.matcher(line)).matches()) {
-                    identifier = m.group(funcIdentifierGroup).trim();
-                    type = 2;
-                } else if ((m = definePattern.matcher(line)).matches()) {
-                    identifier = m.group(defineIdentifierGroup).trim();
-                    type = 1;
-                } else if (line.startsWith("#endif")) {
-                    if (DEBUG) {
-                        System.err.println("END ASSOCIATION BLOCK: <" + activeAssociation + ">");
+                if( 2 >= block ) {  // not within sub-blocks > 2, i.e. further typedefs
+                    if ((m = funcPattern.matcher(line)).matches()) {
+                        identifier = m.group(funcIdentifierGroup).trim();
+                        type = 2;
+                    } else if ((m = definePattern.matcher(line)).matches()) {
+                        identifier = m.group(defineIdentifierGroup).trim();
+                        type = 1;
                     }
-                    activeAssociation = null;
                 }
-                if ((identifier != null)
-                        && (activeAssociation != null)
-                        && // Handles #ifndef GL_... #define GL_...
-                        !identifier.equals(activeAssociation)) {
+                if ( identifier != null &&
+                     activeAssociation != null &&                     
+                     !identifier.equals(activeAssociation) // Handles #ifndef GL_... #define GL_... 
+                   ) 
+                {
                     addAssociation(identifier, activeAssociation);
                     if (DEBUG) {
-                        System.err.println("  ADDING ASSOCIATION: <" + identifier + "> <" + activeAssociation + "> ; type " + type);
+                        System.err.println("<"+block+">   ADDING ASSOCIATION: <" + identifier + "> <" + activeAssociation + "> ; type " + type);
+                    }
+                } else {
+                    if ((m = ifPattern.matcher(line)).matches()) {
+                        final String comment = m.group(1).trim();
+                        block++;
+                        if (DEBUG) {
+                            System.err.println("<"+block+"> BEGIN IF BLOCK: <" + comment + ">");
+                        }
+                    } else if ((m = elsePattern.matcher(line)).matches()) {
+                        final String comment = m.group(1).trim();
+                        if (DEBUG) {
+                            System.err.println("<"+block+"> ELSE BLOCK: <" + comment + ">");
+                        }
+                    } else if ((m = endifPattern.matcher(line)).matches()) {
+                        final String comment = m.group(1).trim();
+                        block--;
+                        if( 0 == block ) {
+                            if (DEBUG) {
+                                System.err.println("<"+block+"> END ASSOCIATION BLOCK: <" + activeAssociation + " <-> " + comment + ">");
+                            }
+                            activeAssociation = null;                
+                        } else {
+                            if (DEBUG) {
+                                System.err.println("<"+block+"> END IF BLOCK: <" + comment + ">");
+                            }
+                        }
                     }
                 }
-            } else if ((m = associationPattern.matcher(line)).matches()) {
+            } else if ((m = associationPattern.matcher(line)).matches()) {                
                 // found a new #ifndef GL_XXX block
                 activeAssociation = m.group(1).trim();
-
+                block++;
                 if (DEBUG) {
-                    System.err.println("BEGIN ASSOCIATION BLOCK: <" + activeAssociation + ">");
+                    System.err.println("<"+block+"> BEGIN ASSOCIATION BLOCK: <" + activeAssociation + ">");
                 }
             }
         }
diff --git a/src/jogl/classes/com/jogamp/gluegen/opengl/GLConfiguration.java b/src/jogl/classes/com/jogamp/gluegen/opengl/GLConfiguration.java
index ba025e18c..d4dca715b 100644
--- a/src/jogl/classes/com/jogamp/gluegen/opengl/GLConfiguration.java
+++ b/src/jogl/classes/com/jogamp/gluegen/opengl/GLConfiguration.java
@@ -61,6 +61,7 @@ public class GLConfiguration extends ProcAddressConfiguration {
     // The following data members support ignoring an entire extension at a time
     private List<String> glHeaders = new ArrayList<String>();
     private Set<String> ignoredExtensions = new HashSet<String>();
+    private Set<String> forcedExtensions = new HashSet<String>();
     private Set<String> extensionsRenamedIntoCore = new HashSet<String>();
     private BuildStaticGLInfo glInfo;
 
@@ -90,6 +91,9 @@ public class GLConfiguration extends ProcAddressConfiguration {
         if (cmd.equalsIgnoreCase("IgnoreExtension")) {
             String sym = readString("IgnoreExtension", tok, filename, lineNo);
             ignoredExtensions.add(sym);
+        } else if (cmd.equalsIgnoreCase("ForceExtension")) {
+            String sym = readString("ForceExtension", tok, filename, lineNo);
+            forcedExtensions.add(sym);
         } else if (cmd.equalsIgnoreCase("RenameExtensionIntoCore")) {
             String sym = readString("RenameExtensionIntoCore", tok, filename, lineNo);
             extensionsRenamedIntoCore.add(sym);
@@ -202,16 +206,21 @@ public class GLConfiguration extends ProcAddressConfiguration {
         for (String str : ignoredExtensions) {
             System.err.println("\t" + str);
         }
+        System.err.println("GL Forced extensions: ");
+        for (String str : forcedExtensions) {
+            System.err.println("\t" + str);
+        }
         super.dumpIgnores();
     }
 
     protected boolean shouldIgnoreExtension(String symbol, boolean criteria) {
         if (criteria && glInfo != null) {
-            Set<String> extensionNames = glInfo.getExtension(symbol);
-            if(null!=extensionNames) {
-                for(Iterator<String> i=extensionNames.iterator(); i.hasNext(); ) {
-                    String extensionName = i.next();
-                    if (extensionName != null && ignoredExtensions.contains(extensionName)) {
+            final Set<String> extensionNames = glInfo.getExtension(symbol);
+            if( null != extensionNames ) {
+                boolean ignoredExtension = false;
+                for(Iterator<String> i=extensionNames.iterator(); !ignoredExtension && i.hasNext(); ) {
+                    final String extensionName = i.next();
+                    if ( extensionName != null && ignoredExtensions.contains(extensionName) ) {
                         if (DEBUG_IGNORES) {
                             System.err.print("Ignore symbol <" + symbol + "> of extension <" + extensionName + ">");
                             if(extensionNames.size()==1) {
@@ -220,9 +229,26 @@ public class GLConfiguration extends ProcAddressConfiguration {
                                 System.err.println(", WARNING MULTIPLE OCCURENCE: "+extensionNames);
                             }
                         }
-                        return true;
+                        ignoredExtension = true;
+                    }
+                }
+                if( ignoredExtension ) {
+                    ignoredExtension = !shouldForceExtension( symbol, true, symbol );                        
+                    if( ignoredExtension ) {
+                        final Set<String> origSymbols = getRenamedJavaSymbols( symbol );
+                        if(null != origSymbols) {
+                            for(String origSymbol : origSymbols) {
+                                if( shouldForceExtension( origSymbol, true, symbol ) ) {
+                                    ignoredExtension = false;
+                                    break;
+                                }
+                            }
+                        }                    
                     }
                 }
+                if( ignoredExtension ) {
+                    return true;
+                }
             }
             boolean isGLEnum = GLNameResolver.isGLEnumeration(symbol);
             boolean isGLFunc = GLNameResolver.isGLFunction(symbol);
@@ -240,6 +266,29 @@ public class GLConfiguration extends ProcAddressConfiguration {
         }
         return false;
     }
+    
+    public boolean shouldForceExtension(final String symbol, final boolean criteria, final String renamedSymbol) {
+        if (criteria && glInfo != null) {
+            final Set<String> extensionNames = glInfo.getExtension(symbol);
+            if( null != extensionNames ) {
+                for(Iterator<String> i=extensionNames.iterator(); i.hasNext(); ) {
+                    final String extensionName = i.next();
+                    if ( extensionName != null && forcedExtensions.contains(extensionName) ) {
+                        if (DEBUG_IGNORES) {
+                            System.err.print("Not Ignore symbol <" + symbol + " -> " + renamedSymbol + "> of extension <" + extensionName + ">");
+                            if(extensionNames.size()==1) {
+                                System.err.println(", single .");
+                            } else {
+                                System.err.println(", WARNING MULTIPLE OCCURENCE: "+extensionNames);
+                            }
+                        }
+                        return true;
+                    }
+                }            
+            }
+        }
+        return false;
+    }
 
     @Override
     public boolean shouldIgnoreInInterface(String symbol) {
diff --git a/src/jogl/classes/com/jogamp/gluegen/opengl/GLJavaMethodBindingEmitter.java b/src/jogl/classes/com/jogamp/gluegen/opengl/GLJavaMethodBindingEmitter.java
index 016674338..fdfaee8a6 100644
--- a/src/jogl/classes/com/jogamp/gluegen/opengl/GLJavaMethodBindingEmitter.java
+++ b/src/jogl/classes/com/jogamp/gluegen/opengl/GLJavaMethodBindingEmitter.java
@@ -43,6 +43,7 @@ import com.jogamp.gluegen.CommentEmitter;
 import com.jogamp.gluegen.JavaEmitter;
 import com.jogamp.gluegen.JavaMethodBindingEmitter;
 import com.jogamp.gluegen.MethodBinding;
+import com.jogamp.gluegen.cgram.types.FunctionSymbol;
 import com.jogamp.gluegen.cgram.types.Type;
 import com.jogamp.gluegen.procaddress.ProcAddressJavaMethodBindingEmitter;
 
@@ -103,11 +104,14 @@ public class GLJavaMethodBindingEmitter extends ProcAddressJavaMethodBindingEmit
         @Override
         protected void emitBindingCSignature(MethodBinding binding, PrintWriter writer) {
 
-            super.emitBindingCSignature(binding, writer);
-
             String symbolRenamed = binding.getName();
             StringBuilder newComment = new StringBuilder();
 
+            final FunctionSymbol funcSym = binding.getCSymbol();
+            writer.print("<code> ");
+            writer.print(funcSym.getType().toString(symbolRenamed, tagNativeBinding));
+            writer.print(" </code> ");
+            
             newComment.append("<br>Part of ");
             if (0 == glEmitter.addExtensionsOfSymbols2Buffer(newComment, ", ", "; ", symbolRenamed, binding.getAliasedNames())) {
                 if (glEmitter.getGLConfig().getAllowNonGLExtensions()) {
diff --git a/src/jogl/classes/com/jogamp/opengl/GLExtensions.java b/src/jogl/classes/com/jogamp/opengl/GLExtensions.java
index c0666d153..14f4be96a 100644
--- a/src/jogl/classes/com/jogamp/opengl/GLExtensions.java
+++ b/src/jogl/classes/com/jogamp/opengl/GLExtensions.java
@@ -51,6 +51,7 @@ public class GLExtensions {
   public static final String NV_fbo_color_attachments        = "GL_NV_fbo_color_attachments";
   
   public static final String ARB_ES2_compatibility           = "GL_ARB_ES2_compatibility";
+  public static final String ARB_ES3_compatibility           = "GL_ARB_ES3_compatibility";
   
   public static final String EXT_abgr                        = "GL_EXT_abgr";
   public static final String OES_rgb8_rgba8                  = "GL_OES_rgb8_rgba8";
@@ -69,7 +70,7 @@ public class GLExtensions {
   public static final String NV_texture_compression_vtc      = "GL_NV_texture_compression_vtc";
   public static final String SGIS_generate_mipmap            = "GL_SGIS_generate_mipmap";
   public static final String OES_read_format                 = "GL_OES_read_format";
-  
+  public static final String OES_single_precision            = "GL_OES_single_precision";
   public static final String OES_EGL_image_external          = "GL_OES_EGL_image_external";
   
   public static final String ARB_gpu_shader_fp64             = "GL_ARB_gpu_shader_fp64";
diff --git a/src/jogl/classes/javax/media/opengl/GLBase.java b/src/jogl/classes/javax/media/opengl/GLBase.java
index 74c1b9609..49c5bf72d 100644
--- a/src/jogl/classes/javax/media/opengl/GLBase.java
+++ b/src/jogl/classes/javax/media/opengl/GLBase.java
@@ -131,6 +131,16 @@ public interface GLBase {
   public boolean isGLES2();
 
   /**
+   * Indicates whether this GL object conforms to the OpenGL ES2 &ge; 3.0 profile.
+   * <p>
+   * Remark: ES3 compatible desktop profiles are not included.
+   * To query whether core ES3 functionality is provided, use {@link #isGLES3Compatible()}.
+   * </p> 
+   * @see #isGLES3Compatible()
+   */
+  public boolean isGLES3();
+  
+  /**
    * Indicates whether this GL object conforms to one of the OpenGL ES profiles,
    * see {@link #isGLES1()} and {@link #isGLES2()}.
    */
@@ -147,6 +157,21 @@ public interface GLBase {
   public boolean isGL2ES2();
 
   /**
+   * Indicates whether this GL object conforms to a GL3ES3 compatible profile.
+   */
+  public boolean isGL3ES3();
+
+  /**
+   * Indicates whether this GL object conforms to a GL4ES3 compatible profile.
+   */
+  public boolean isGL4ES3();
+
+  /**
+   * Indicates whether this GL object conforms to a GL2GL3 compatible profile.
+   */
+  public boolean isGL2GL3();
+
+  /**
    * Indicates whether this GL object is compatible with the core OpenGL ES2 functionality.
    * @return true if this context is an ES2 context or implements 
    *         the extension <code>GL_ARB_ES2_compatibility</code>, otherwise false 
@@ -154,9 +179,11 @@ public interface GLBase {
   public boolean isGLES2Compatible();
 
   /**
-   * Indicates whether this GL object conforms to a GL2GL3 compatible profile.
+   * Indicates whether this GL object is compatible with the core OpenGL ES3 functionality.
+   * @return true if this context is an ES3 context or implements 
+   *         the extension <code>GL_ARB_ES3_compatibility</code>, otherwise false 
    */
-  public boolean isGL2GL3();
+  public boolean isGLES3Compatible();
 
   /** Indicates whether this GL object supports GLSL. */
   public boolean hasGLSL();
@@ -210,6 +237,12 @@ public interface GLBase {
   public GLES2 getGLES2() throws GLException;
 
   /**
+   * Casts this object to the GLES3 interface.
+   * @throws GLException if this GLObject is not a GLES3 implementation
+   */
+  public GLES3 getGLES3() throws GLException;
+
+  /**
    * Casts this object to the GL2ES1 interface.
    * @throws GLException if this GLObject is not a GL2ES1 implementation
    */
@@ -222,6 +255,18 @@ public interface GLBase {
   public GL2ES2 getGL2ES2() throws GLException;
 
   /**
+   * Casts this object to the GL3ES3 interface.
+   * @throws GLException if this GLObject is not a GL3ES3 implementation
+   */
+  public GL3ES3 getGL3ES3() throws GLException;
+
+  /**
+   * Casts this object to the GL4ES3 interface.
+   * @throws GLException if this GLObject is not a GL3ES3 implementation
+   */
+  public GL4ES3 getGL4ES3() throws GLException;
+
+  /**
    * Casts this object to the GL2GL3 interface.
    * @throws GLException if this GLObject is not a GL2GL3 implementation
    */
diff --git a/src/jogl/classes/javax/media/opengl/GLContext.java b/src/jogl/classes/javax/media/opengl/GLContext.java
index daede5ac0..b27db18af 100644
--- a/src/jogl/classes/javax/media/opengl/GLContext.java
+++ b/src/jogl/classes/javax/media/opengl/GLContext.java
@@ -142,6 +142,13 @@ public abstract class GLContext {
   
   protected static final VersionNumber Version800 = new VersionNumber(8, 0, 0);
 
+  //
+  // Cached keys, bits [0..15]
+  //
+  
+  /** Cached bit mask covering bits [0..15], i.e. {@value}. */
+  protected static final int CTX_IMPL_CACHE_MASK = 0x0000FFFF;
+  
   /** <code>ARB_create_context</code> related: created via ARB_create_context. Cache key value. See {@link #getAvailableContextProperties(AbstractGraphicsDevice, GLProfile)}. */
   protected static final int CTX_IS_ARB_CREATED  = 1 <<  0;
   /** <code>ARB_create_context</code> related: desktop compatibility profile. Cache key value. See {@link #isGLCompatibilityProfile()}, {@link #getAvailableContextProperties(AbstractGraphicsDevice, GLProfile)}. */
@@ -154,20 +161,36 @@ public abstract class GLContext {
   protected static final int CTX_OPTION_FORWARD  = 1 <<  4;
   /** <code>ARB_create_context</code> related: flag debug. Cache key value. See {@link #setContextCreationFlags(int)}, {@link GLAutoDrawable#setContextCreationFlags(int)}, {@link #getAvailableContextProperties(AbstractGraphicsDevice, GLProfile)}. */
   public static final int CTX_OPTION_DEBUG       = 1 <<  5;
+  /** Context uses software rasterizer, otherwise hardware rasterizer. Cache key value. See {@link #isHardwareRasterizer()}, {@link #getAvailableContextProperties(AbstractGraphicsDevice, GLProfile)}. */
+  protected static final int CTX_IMPL_ACCEL_SOFT = 1 <<  6;
 
+  //
+  // Non cached keys, bits [16..31]
+  //
+  
   /** <code>GL_ARB_ES2_compatibility</code> implementation related: Context is compatible w/ ES2. Not a cache key. See {@link #isGLES2Compatible()}, {@link #getAvailableContextProperties(AbstractGraphicsDevice, GLProfile)}. */
-  protected static final int CTX_IMPL_ES2_COMPAT = 1 <<  8;
+  protected static final int CTX_IMPL_ES2_COMPAT = 1 << 16;
 
-  /** Context supports basic FBO, details see {@link #hasBasicFBOSupport()}.
+  /** <code>GL_ARB_ES3_compatibility</code> implementation related: Context is compatible w/ ES3. Not a cache key. See {@link #isGLES3Compatible()}, {@link #getAvailableContextProperties(AbstractGraphicsDevice, GLProfile)}. */
+  protected static final int CTX_IMPL_ES3_COMPAT = 1 << 17;
+  
+  /** 
+   * Context supports basic FBO, details see {@link #hasBasicFBOSupport()}.
    * Not a cache key.
    * @see #hasBasicFBOSupport()
    * @see #getAvailableContextProperties(AbstractGraphicsDevice, GLProfile)
    */
-  protected static final int CTX_IMPL_FBO        = 1 <<  9;
-
-  /** Context uses software rasterizer, otherwise hardware rasterizer. Cache key value. See {@link #isHardwareRasterizer()}, {@link #getAvailableContextProperties(AbstractGraphicsDevice, GLProfile)}. */
-  protected static final int CTX_IMPL_ACCEL_SOFT = 1 << 15;
+  protected static final int CTX_IMPL_FBO        = 1 << 18;
 
+  /** 
+   * Context supports <code>OES_single_precision</code>, fp32, fixed function point (FFP) compatibility entry points, 
+   * see {@link #hasFP32CompatAPI()}.
+   * Not a cache key.
+   * @see #hasFP32CompatAPI()
+   * @see #getAvailableContextProperties(AbstractGraphicsDevice, GLProfile)
+   */
+  protected static final int CTX_IMPL_FP32_COMPAT_API = 1 << 19;
+  
   private static final ThreadLocal<GLContext> currentContext = new ThreadLocal<GLContext>();
 
   private final HashMap<String, Object> attachedObjects = new HashMap<String, Object>();
@@ -778,10 +801,18 @@ public abstract class GLContext {
   
   /**
    * @return true if this context is an ES2 context or implements
-   *         the extension <code>GL_ARB_ES2_compatibility</code>, otherwise false
+   *         the extension <code>GL_ARB_ES3_compatibility</code> or <code>GL_ARB_ES2_compatibility</code>, otherwise false
    */
   public final boolean isGLES2Compatible() {
-      return 0 != ( ctxOptions & CTX_IMPL_ES2_COMPAT ) ;
+      return 0 != ( ctxOptions & ( CTX_IMPL_ES3_COMPAT | CTX_IMPL_ES2_COMPAT ) ) ;
+  }
+
+  /**
+   * @return true if this context is an ES3 context or implements
+   *         the extension <code>GL_ARB_ES3_compatibility</code>, otherwise false
+   */
+  public final boolean isGLES3Compatible() {
+      return 0 != ( ctxOptions & CTX_IMPL_ES3_COMPAT ) ;
   }
 
   /** 
@@ -820,6 +851,15 @@ public abstract class GLContext {
   }
 
   /** 
+   * Returns <code>true</code> if <code>OES_single_precision</code>, fp32, fixed function point (FFP) compatibility entry points available, 
+   * otherwise <code>false</code>.
+   * @see #CTX_IMPL_FP32_COMPAT_API
+   */
+  public final boolean hasFP32CompatAPI() {
+      return 0 != ( ctxOptions & CTX_IMPL_FP32_COMPAT_API ) ;
+  }
+  
+  /** 
    * Returns <code>true</code> if full FBO support is available, otherwise <code>false</code>.
    * <p>
    * Full FBO is supported if the context is either GL >= core 3.0 or implements the extensions
@@ -895,28 +935,30 @@ public abstract class GLContext {
   
   /** @see GLProfile#isGL3bc() */
   public final boolean isGL3bc() {
-      return ctxVersion.compareTo(Version310) >= 0
-             && 0 != (ctxOptions & CTX_IS_ARB_CREATED)
-             && 0 != (ctxOptions & CTX_PROFILE_COMPAT);
+      return 0 != (ctxOptions & CTX_IS_ARB_CREATED) &&
+             0 != (ctxOptions & CTX_PROFILE_COMPAT) &&
+             ctxVersion.compareTo(Version310) >= 0 ;
   }
 
   /** @see GLProfile#isGL3() */
   public final boolean isGL3() {
-      return ctxVersion.compareTo(Version310) >= 0
-             && 0 != (ctxOptions & CTX_IS_ARB_CREATED)
-             && 0 != (ctxOptions & (CTX_PROFILE_COMPAT|CTX_PROFILE_CORE));
+      return 0 != (ctxOptions & CTX_IS_ARB_CREATED) &&
+             0 != (ctxOptions & (CTX_PROFILE_COMPAT|CTX_PROFILE_CORE)) &&
+             ctxVersion.compareTo(Version310) >= 0 ;
   }
   
-  /** Indicates whether this profile is capable of GL3 (core only). GL3 starts w/ OpenGL 3.1 <p>Includes [ GL4, GL3 ].</p> */
+  /** Indicates whether this profile is capable of GL3 (core only). GL3 starts w/ OpenGL 3.1 <p>Includes [ GL4, GL3, GLES3 ].</p> */
   public final boolean isGL3core() {
-      return ctxVersion.compareTo(Version310) >= 0
-             && 0 != (ctxOptions & CTX_IS_ARB_CREATED)
-             && 0 != (ctxOptions & CTX_PROFILE_CORE);
+      return ( 0 != ( ctxOptions & CTX_PROFILE_ES ) && ctxVersion.getMajor() >= 3 ) ||
+             ( 0 != ( ctxOptions & CTX_IS_ARB_CREATED ) &&
+               0 != ( ctxOptions & CTX_PROFILE_CORE ) &&
+               ctxVersion.compareTo(Version310) >= 0
+             ) ;
   }
   
   /** @see GLProfile#isGL2() */
   public final boolean isGL2() {
-      return ctxVersion.getMajor()>=1 && 0!=(ctxOptions & CTX_PROFILE_COMPAT);
+      return 0 != ( ctxOptions & CTX_PROFILE_COMPAT ) && ctxVersion.getMajor()>=1 ;
   }
 
   /** @see GLProfile#isGL2GL3() */  
@@ -926,12 +968,17 @@ public abstract class GLContext {
 
   /** @see GLProfile#isGLES1() */
   public final boolean isGLES1() {
-      return ctxVersion.getMajor() == 1 && 0 != ( ctxOptions & CTX_PROFILE_ES ) ;
+      return 0 != ( ctxOptions & CTX_PROFILE_ES ) && ctxVersion.getMajor() == 1 ;
   }
 
   /** @see GLProfile#isGLES2() */
   public final boolean isGLES2() {
-      return ctxVersion.getMajor() == 2 && 0 != ( ctxOptions & CTX_PROFILE_ES ) ;
+      return 0 != ( ctxOptions & CTX_PROFILE_ES ) && ctxVersion.getMajor() >= 2 ;
+  }
+
+  /** @see GLProfile#isGLES3() */
+  public final boolean isGLES3() {
+      return 0 != ( ctxOptions & CTX_PROFILE_ES ) && ctxVersion.getMajor() >= 3 ;
   }
 
   /** @see GLProfile#isGLES() */
@@ -941,12 +988,22 @@ public abstract class GLContext {
 
   /** @see GLProfile#isGL2ES1() */
   public final boolean isGL2ES1() {
-      return isGL2() || isGLES1() ;
+      return isGLES1() || isGL2();
   }
 
   /** @see GLProfile#isGL2ES2() */
   public final boolean isGL2ES2() {
-      return isGL2GL3() || isGLES2() ;
+      return isGLES2() || isGL2GL3();
+  }
+
+  /** @see GLProfile#isGL3ES3() */
+  public final boolean isGL3ES3() {
+      return isGL4ES3() || isGL3();
+  }
+
+  /** @see GLProfile#isGL4ES3() */
+  public final boolean isGL4ES3() {
+      return isGL4() || isGLES3() ;
   }
 
   /**
@@ -1157,45 +1214,73 @@ public abstract class GLContext {
       /* 1.*/ { 0, 1, 2, 3, 4, 5 },
       /* 2.*/ { 0, 1 },
       /* 3.*/ { 0, 1, 2, 3 },
-      /* 4.*/ { 0, 1, 2 } }; // FIXME add 4.3 !
+      /* 4.*/ { 0, 1, 2, 3 } };
 
-  private static final int GL_VERSIONS_VALID[][] = {
+  public static final int ES_VERSIONS[][] = {
       /* 0.*/ { -1 },
-      /* 1.*/ { 0, 1, 2, 3, 4, 5 },
-      /* 2.*/ { 0, 1 },
-      /* 3.*/ { 0, 1, 2, 3 },
-      /* 4.*/ { 0, 1, 2, 3, 4 } }; // 4.4 coming up soon ?
+      /* 1.*/ { 0, 1 },
+      /* 2.*/ { 0 },
+      /* 3.*/ { 0 } };
 
-  public static final int getMaxMajor() {
-      return GL_VERSIONS.length-1;
+  public static final int getMaxMajor(int ctxProfile) {
+      return ( 0 != ( CTX_PROFILE_ES & ctxProfile ) ) ? ES_VERSIONS.length-1 : GL_VERSIONS.length-1;
   }
 
-  public static final int getMaxMinor(int major) {
-      if(1>major || major>=GL_VERSIONS.length) return -1;
-      return GL_VERSIONS[major].length-1;
+  public static final int getMaxMinor(int ctxProfile, int major) {
+      if( 1>major ) {
+          return -1;
+      }
+      if( ( 0 != ( CTX_PROFILE_ES & ctxProfile ) ) ) {
+          if( major>=ES_VERSIONS.length ) return -1;
+          return ES_VERSIONS[major].length-1;
+      } else {
+          if( major>=GL_VERSIONS.length ) return -1;
+          return GL_VERSIONS[major].length-1;
+      }
   }
 
-  public static final boolean isValidGLVersion(int major, int minor) {
-      if(1>major || major>=GL_VERSIONS_VALID.length) return false;
-      if(0>minor || minor>=GL_VERSIONS_VALID[major].length) return false;
+  public static final boolean isValidGLVersion(int ctxProfile, int major, int minor) {
+      if( 1>major || 0>minor ) {
+          return false;
+      }
+      if( ( 0 != ( CTX_PROFILE_ES & ctxProfile ) ) ) {
+          if( major>=ES_VERSIONS.length) return false;
+          if( minor>=ES_VERSIONS[major].length) return false;
+      } else {
+          if( major>=GL_VERSIONS.length) return false;
+          if( minor>=GL_VERSIONS[major].length) return false;
+      }
       return true;
   }
 
-  public static final boolean decrementGLVersion(int major[], int minor[]) {
+  public static final boolean decrementGLVersion(int ctxProfile, int major[], int minor[]) {
       if(null==major || major.length<1 ||null==minor || minor.length<1) {
           throw new GLException("invalid array arguments");
       }
       int m = major[0];
       int n = minor[0];
-      if(!isValidGLVersion(m, n)) return false;
+      if( !isValidGLVersion(ctxProfile, m, n) ) {
+          return false;
+      }
 
       // decrement ..
       n -= 1;
       if(n < 0) {
-          m -= 1;
-          n = GL_VERSIONS[m].length-1;
+          if( ( 0 != ( CTX_PROFILE_ES & ctxProfile ) ) ) {
+              if( m >= 3) {
+                  m -= 1;
+              } else {
+                  m = 0; // major decr [1,2] -> 0
+              }
+              n = ES_VERSIONS[m].length-1;
+          } else {
+              m -= 1;
+              n = GL_VERSIONS[m].length-1;
+          }
+      }
+      if( !isValidGLVersion(ctxProfile, m, n) ) {
+          return false;
       }
-      if(!isValidGLVersion(m, n)) return false;
       major[0]=m;
       minor[0]=n;
 
@@ -1299,9 +1384,9 @@ public abstract class GLContext {
     }
   }
 
-  protected static StringBuffer dumpAvailableGLVersions(StringBuffer sb) {
+  protected static StringBuilder dumpAvailableGLVersions(StringBuilder sb) {
     if(null == sb) {
-        sb = new StringBuffer();
+        sb = new StringBuilder();
     }
     synchronized(deviceVersionAvailable) {
         final Set<String> keys = deviceVersionAvailable.keySet();
@@ -1524,6 +1609,10 @@ public abstract class GLContext {
       return isGLVersionAvailable(device, 2, GLContext.CTX_PROFILE_ES, isHardware);
   }
 
+  public static boolean isGLES3Available(AbstractGraphicsDevice device, boolean isHardware[]) {
+      return isGLVersionAvailable(device, 3, GLContext.CTX_PROFILE_ES, isHardware);
+  }
+
   public static boolean isGL4bcAvailable(AbstractGraphicsDevice device, boolean isHardware[]) {
       return isGLVersionAvailable(device, 4, CTX_PROFILE_COMPAT, isHardware);
   }
@@ -1552,13 +1641,15 @@ public abstract class GLContext {
     sb.append(minor);
     sb.append(" (");
     needColon = appendString(sb, "ES profile",            needColon, 0 != ( CTX_PROFILE_ES & ctp ));
-    needColon = appendString(sb, "Compatibility profile", needColon, 0 != ( CTX_PROFILE_COMPAT & ctp ));
+    needColon = appendString(sb, "Compat profile",        needColon, 0 != ( CTX_PROFILE_COMPAT & ctp ));
     needColon = appendString(sb, "Core profile",          needColon, 0 != ( CTX_PROFILE_CORE & ctp ));
     needColon = appendString(sb, "forward",               needColon, 0 != ( CTX_OPTION_FORWARD & ctp ));
     needColon = appendString(sb, "arb",                   needColon, 0 != ( CTX_IS_ARB_CREATED & ctp ));
     needColon = appendString(sb, "debug",                 needColon, 0 != ( CTX_OPTION_DEBUG & ctp ));
-    needColon = appendString(sb, "ES2 compatible",        needColon, 0 != ( CTX_IMPL_ES2_COMPAT & ctp ));
+    needColon = appendString(sb, "ES2 compat",            needColon, 0 != ( CTX_IMPL_ES2_COMPAT & ctp ));
+    needColon = appendString(sb, "ES3 compat",            needColon, 0 != ( CTX_IMPL_ES3_COMPAT & ctp ));
     needColon = appendString(sb, "FBO",                   needColon, 0 != ( CTX_IMPL_FBO & ctp ));
+    needColon = appendString(sb, "FP32 compat-api",       needColon, 0 != ( CTX_IMPL_FP32_COMPAT_API & ctp ));
     if( 0 != ( CTX_IMPL_ACCEL_SOFT & ctp ) ) {
         needColon = appendString(sb, "software",          needColon, true);
     } else {
diff --git a/src/jogl/classes/javax/media/opengl/GLDebugMessage.java b/src/jogl/classes/javax/media/opengl/GLDebugMessage.java
index 3ab0683c6..f8959e653 100644
--- a/src/jogl/classes/javax/media/opengl/GLDebugMessage.java
+++ b/src/jogl/classes/javax/media/opengl/GLDebugMessage.java
@@ -73,8 +73,8 @@ public class GLDebugMessage {
         // AMD category == ARB source/type
         switch(amdDbgCategory) {
             case GL2GL3.GL_DEBUG_CATEGORY_API_ERROR_AMD: 
-                dbgSource = GL2GL3.GL_DEBUG_SOURCE_API_ARB;
-                dbgType = GL2GL3.GL_DEBUG_TYPE_ERROR_ARB; 
+                dbgSource = GL2GL3.GL_DEBUG_SOURCE_API;
+                dbgType = GL2GL3.GL_DEBUG_TYPE_ERROR; 
                 break;
 
             //
@@ -82,18 +82,18 @@ public class GLDebugMessage {
             //
                 
             case GL2GL3.GL_DEBUG_CATEGORY_WINDOW_SYSTEM_AMD: 
-                dbgSource = GL2GL3.GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB;
-                dbgType = GL2GL3.GL_DEBUG_TYPE_OTHER_ARB; 
+                dbgSource = GL2GL3.GL_DEBUG_SOURCE_WINDOW_SYSTEM;
+                dbgType = GL2GL3.GL_DEBUG_TYPE_OTHER; 
                 break;
                 
             case GL2GL3.GL_DEBUG_CATEGORY_SHADER_COMPILER_AMD:
-                dbgSource = GL2GL3.GL_DEBUG_SOURCE_SHADER_COMPILER_ARB;
-                dbgType = GL2GL3.GL_DEBUG_TYPE_OTHER_ARB; 
+                dbgSource = GL2GL3.GL_DEBUG_SOURCE_SHADER_COMPILER;
+                dbgType = GL2GL3.GL_DEBUG_TYPE_OTHER; 
                 break;
                 
             case GL2GL3.GL_DEBUG_CATEGORY_APPLICATION_AMD:
-                dbgSource = GL2GL3.GL_DEBUG_SOURCE_APPLICATION_ARB;
-                dbgType = GL2GL3.GL_DEBUG_TYPE_OTHER_ARB;
+                dbgSource = GL2GL3.GL_DEBUG_SOURCE_APPLICATION;
+                dbgType = GL2GL3.GL_DEBUG_TYPE_OTHER;
                 break;
                 
                 
@@ -102,24 +102,24 @@ public class GLDebugMessage {
             //
                 
             case GL2GL3.GL_DEBUG_CATEGORY_DEPRECATION_AMD:
-                dbgSource = GL2GL3.GL_DEBUG_SOURCE_OTHER_ARB;
-                dbgType = GL2GL3.GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB; 
+                dbgSource = GL2GL3.GL_DEBUG_SOURCE_OTHER;
+                dbgType = GL2GL3.GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR; 
                 break;
                 
             case GL2GL3.GL_DEBUG_CATEGORY_UNDEFINED_BEHAVIOR_AMD:
-                dbgSource = GL2GL3.GL_DEBUG_SOURCE_OTHER_ARB;
-                dbgType = GL2GL3.GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB; 
+                dbgSource = GL2GL3.GL_DEBUG_SOURCE_OTHER;
+                dbgType = GL2GL3.GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR; 
                 break;
                 
             case GL2GL3.GL_DEBUG_CATEGORY_PERFORMANCE_AMD:
-                dbgSource = GL2GL3.GL_DEBUG_SOURCE_OTHER_ARB;
-                dbgType = GL2GL3.GL_DEBUG_TYPE_PERFORMANCE_ARB; 
+                dbgSource = GL2GL3.GL_DEBUG_SOURCE_OTHER;
+                dbgType = GL2GL3.GL_DEBUG_TYPE_PERFORMANCE; 
                 break;
                 
             case GL2GL3.GL_DEBUG_CATEGORY_OTHER_AMD: 
             default:
-                dbgSource = GL2GL3.GL_DEBUG_SOURCE_OTHER_ARB;
-                dbgType = GL2GL3.GL_DEBUG_TYPE_OTHER_ARB;
+                dbgSource = GL2GL3.GL_DEBUG_SOURCE_OTHER;
+                dbgType = GL2GL3.GL_DEBUG_TYPE_OTHER;
         }
         
         return new GLDebugMessage(source, when, dbgSource, dbgType, dbgId, dbgSeverity, dbgMsg);        
@@ -127,24 +127,24 @@ public class GLDebugMessage {
 
     public static int translateARB2AMDCategory(int dbgSource, int dbgType) {
         switch (dbgSource) {
-            case GL2GL3.GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB:
+            case GL2GL3.GL_DEBUG_SOURCE_WINDOW_SYSTEM:
                 return GL2GL3.GL_DEBUG_CATEGORY_WINDOW_SYSTEM_AMD; 
                 
-            case GL2GL3.GL_DEBUG_SOURCE_SHADER_COMPILER_ARB:
+            case GL2GL3.GL_DEBUG_SOURCE_SHADER_COMPILER:
                 return GL2GL3.GL_DEBUG_CATEGORY_SHADER_COMPILER_AMD;
                 
-            case GL2GL3.GL_DEBUG_SOURCE_APPLICATION_ARB:
+            case GL2GL3.GL_DEBUG_SOURCE_APPLICATION:
                 return GL2GL3.GL_DEBUG_CATEGORY_APPLICATION_AMD;
         }
         
         switch(dbgType) {
-            case GL2GL3.GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB:
+            case GL2GL3.GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR:
                 return GL2GL3.GL_DEBUG_CATEGORY_DEPRECATION_AMD;
                 
-            case GL2GL3.GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB:
+            case GL2GL3.GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR:
                 return GL2GL3.GL_DEBUG_CATEGORY_UNDEFINED_BEHAVIOR_AMD;
                 
-            case GL2GL3.GL_DEBUG_TYPE_PERFORMANCE_ARB: 
+            case GL2GL3.GL_DEBUG_TYPE_PERFORMANCE: 
                 return GL2GL3.GL_DEBUG_CATEGORY_PERFORMANCE_AMD;
         }
                 
@@ -204,33 +204,33 @@ public class GLDebugMessage {
         
     public static String getDbgSourceString(int dbgSource) {
         switch(dbgSource) {
-            case GL2GL3.GL_DEBUG_SOURCE_API_ARB: return "GL API";
-            case GL2GL3.GL_DEBUG_SOURCE_SHADER_COMPILER_ARB: return "GLSL or extension compiler";                                          
-            case GL2GL3.GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB: return "Native Windowing binding";                                          
-            case GL2GL3.GL_DEBUG_SOURCE_THIRD_PARTY_ARB: return "Third party";
-            case GL2GL3.GL_DEBUG_SOURCE_APPLICATION_ARB: return "Application";
-            case GL2GL3.GL_DEBUG_SOURCE_OTHER_ARB: return "generic";
+            case GL2GL3.GL_DEBUG_SOURCE_API: return "GL API";
+            case GL2GL3.GL_DEBUG_SOURCE_SHADER_COMPILER: return "GLSL or extension compiler";                                          
+            case GL2GL3.GL_DEBUG_SOURCE_WINDOW_SYSTEM: return "Native Windowing binding";                                          
+            case GL2GL3.GL_DEBUG_SOURCE_THIRD_PARTY: return "Third party";
+            case GL2GL3.GL_DEBUG_SOURCE_APPLICATION: return "Application";
+            case GL2GL3.GL_DEBUG_SOURCE_OTHER: return "generic";
             default: return "Unknown (" + toHexString(dbgSource) + ")";
         }
     }
     
     public static String getDbgTypeString(int dbgType) {
         switch(dbgType) {
-            case GL2GL3.GL_DEBUG_TYPE_ERROR_ARB: return "Error";
-            case GL2GL3.GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB: return "Warning: marked for deprecation";                                            
-            case GL2GL3.GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB: return "Warning: undefined behavior";
-            case GL2GL3.GL_DEBUG_TYPE_PERFORMANCE_ARB: return "Warning: implementation dependent performance";   
-            case GL2GL3.GL_DEBUG_TYPE_PORTABILITY_ARB: return "Warning: vendor-specific extension use";   
-            case GL2GL3.GL_DEBUG_TYPE_OTHER_ARB: return "Warning: generic";            
+            case GL2GL3.GL_DEBUG_TYPE_ERROR: return "Error";
+            case GL2GL3.GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR: return "Warning: marked for deprecation";                                            
+            case GL2GL3.GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR: return "Warning: undefined behavior";
+            case GL2GL3.GL_DEBUG_TYPE_PERFORMANCE: return "Warning: implementation dependent performance";   
+            case GL2GL3.GL_DEBUG_TYPE_PORTABILITY: return "Warning: vendor-specific extension use";   
+            case GL2GL3.GL_DEBUG_TYPE_OTHER: return "Warning: generic";            
             default: return "Unknown (" + toHexString(dbgType) + ")";
         }
     }
     
     public static String getDbgSeverityString(int dbgSeverity) {
         switch(dbgSeverity) {
-            case GL2GL3.GL_DEBUG_SEVERITY_HIGH_ARB: return "High: dangerous undefined behavior";                                          
-            case GL2GL3.GL_DEBUG_SEVERITY_MEDIUM_ARB: return "Medium: Severe performance/deprecation/other warnings";    
-            case GL2GL3.GL_DEBUG_SEVERITY_LOW_ARB: return "Low: Performance warnings (redundancy/undefined)";        
+            case GL2GL3.GL_DEBUG_SEVERITY_HIGH: return "High: dangerous undefined behavior";                                          
+            case GL2GL3.GL_DEBUG_SEVERITY_MEDIUM: return "Medium: Severe performance/deprecation/other warnings";    
+            case GL2GL3.GL_DEBUG_SEVERITY_LOW: return "Low: Performance warnings (redundancy/undefined)";        
             default: return "Unknown (" + toHexString(dbgSeverity) + ")";
         }
     }
diff --git a/src/jogl/classes/javax/media/opengl/GLProfile.java b/src/jogl/classes/javax/media/opengl/GLProfile.java
index 1b6af22d4..17d9019da 100644
--- a/src/jogl/classes/javax/media/opengl/GLProfile.java
+++ b/src/jogl/classes/javax/media/opengl/GLProfile.java
@@ -132,7 +132,7 @@ public class GLProfile {
                                   ReflectionUtil.createInstance(getGLImplBaseClassName(GL4bc)+"Impl", new Class[] { GLProfile.class, GLContextImpl.class }, new Object[] { null, null }, cl);
                               } catch (Throwable t) {}
                               try {
-                                  ReflectionUtil.createInstance(getGLImplBaseClassName(GLES2)+"Impl", new Class[] { GLProfile.class, GLContextImpl.class }, new Object[] { null, null }, cl);              
+                                  ReflectionUtil.createInstance(getGLImplBaseClassName(GLES3)+"Impl", new Class[] { GLProfile.class, GLContextImpl.class }, new Object[] { null, null }, cl);              
                               } catch (Throwable t) {}
                               try {
                                   ReflectionUtil.createInstance(getGLImplBaseClassName(GLES1)+"Impl", new Class[] { GLProfile.class, GLContextImpl.class }, new Object[] { null, null }, cl);              
@@ -165,7 +165,7 @@ public class GLProfile {
             initLock.unlock();
         }
         if(DEBUG) {
-            if( justInitialized && ( hasGL234Impl || hasGLES1Impl || hasGLES2Impl ) ) {
+            if( justInitialized && ( hasGL234Impl || hasGLES1Impl || hasGLES3Impl ) ) {
                 System.err.println(JoglVersion.getDefaultOpenGLInfo(defaultDevice, null, true));
             }
         }        
@@ -299,6 +299,24 @@ public class GLProfile {
         }
 
         if(useIndent) {
+            doIndent(sb.append(Platform.getNewline()), indent, indentCount).append("GL4ES3").append(indent);
+        } else {
+            sb.append(", GL4ES3 ");
+        }
+        sb.append(isAvailableImpl(map, GL4ES3));
+        
+        if(useIndent) {
+            doIndent(sb.append(Platform.getNewline()), indent, indentCount).append("GLES3").append(indent);
+        } else {
+            sb.append(", GLES3 ");
+        }
+        avail=isAvailableImpl(map, GLES3);
+        sb.append(avail);
+        if(avail) {
+            glAvailabilityToString(device, sb.append(" "), 3, GLContext.CTX_PROFILE_ES);
+        }
+
+        if(useIndent) {
             doIndent(sb.append(Platform.getNewline()), indent, indentCount).append("GL3bc").append(indent);
         } else {
             sb.append(", GL3bc ");
@@ -332,39 +350,39 @@ public class GLProfile {
         }
 
         if(useIndent) {
-            doIndent(sb.append(Platform.getNewline()), indent, indentCount).append("GL2ES1").append(indent);
+            doIndent(sb.append(Platform.getNewline()), indent, indentCount).append("GL2ES2").append(indent);
         } else {
-            sb.append(", GL2ES1 ");
+            sb.append(", GL2ES2 ");
         }
-        sb.append(isAvailableImpl(map, GL2ES1));
+        sb.append(isAvailableImpl(map, GL2ES2));
 
         if(useIndent) {
-            doIndent(sb.append(Platform.getNewline()), indent, indentCount).append("GLES1").append(indent);
+            doIndent(sb.append(Platform.getNewline()), indent, indentCount).append("GLES2").append(indent);
         } else {
-            sb.append(", GLES1 ");
+            sb.append(", GLES2 ");
         }
-        avail=isAvailableImpl(map, GLES1);
+        avail=isAvailableImpl(map, GLES2);
         sb.append(avail);
         if(avail) {
-            glAvailabilityToString(device, sb.append(" "), 1, GLContext.CTX_PROFILE_ES);
+            glAvailabilityToString(device, sb.append(" "), 2, GLContext.CTX_PROFILE_ES);
         }
 
         if(useIndent) {
-            doIndent(sb.append(Platform.getNewline()), indent, indentCount).append("GL2ES2").append(indent);
+            doIndent(sb.append(Platform.getNewline()), indent, indentCount).append("GL2ES1").append(indent);
         } else {
-            sb.append(", GL2ES2 ");
+            sb.append(", GL2ES1 ");
         }
-        sb.append(isAvailableImpl(map, GL2ES2));
+        sb.append(isAvailableImpl(map, GL2ES1));
 
         if(useIndent) {
-            doIndent(sb.append(Platform.getNewline()), indent, indentCount).append("GLES2").append(indent);
+            doIndent(sb.append(Platform.getNewline()), indent, indentCount).append("GLES1").append(indent);
         } else {
-            sb.append(", GLES2 ");
+            sb.append(", GLES1 ");
         }
-        avail=isAvailableImpl(map, GLES2);
+        avail=isAvailableImpl(map, GLES1);
         sb.append(avail);
         if(avail) {
-            glAvailabilityToString(device, sb.append(" "), 2, GLContext.CTX_PROFILE_ES);
+            glAvailabilityToString(device, sb.append(" "), 1, GLContext.CTX_PROFILE_ES);
         }
 
         if(useIndent) {
@@ -437,6 +455,9 @@ public class GLProfile {
     /** The embedded OpenGL profile ES 2.x, with x >= 0 */
     public static final String GLES2 = "GLES2";
 
+    /** The embedded OpenGL profile ES 3.x, with x >= 0 */
+    public static final String GLES3 = "GLES3";
+
     /** The intersection of the desktop GL2 and embedded ES1 profile */
     public static final String GL2ES1 = "GL2ES1";
 
@@ -446,6 +467,9 @@ public class GLProfile {
     /** The intersection of the desktop GL3 and GL2 profile */
     public static final String GL2GL3 = "GL2GL3";
 
+    /** The intersection of the desktop GL4 and ES3 profile */
+    public static final String GL4ES3 = "GL4ES3";
+    
     /** The default profile, used for the device default profile map  */
     private static final String GL_DEFAULT = "GL_DEFAULT";
 
@@ -456,62 +480,66 @@ public class GLProfile {
      * <p> This includes the generic subset profiles GL2GL3, GL2ES2 and GL2ES1.</p>
      *
      * <ul>
-     *  <li> GL4bc
-     *  <li> GL3bc
-     *  <li> GL2
-     *  <li> GL4
-     *  <li> GL3
-     *  <li> GL2GL3
-     *  <li> GLES2
-     *  <li> GL2ES2
-     *  <li> GLES1
-     *  <li> GL2ES1
+     *  <li> GL4bc </li>
+     *  <li> GL3bc </li>
+     *  <li> GL2 </li>
+     *  <li> GL4 </li>
+     *  <li> GL3 </li>
+     *  <li> GLES3 </li>
+     *  <li> GL4ES3 </li>
+     *  <li> GL2GL3 </li>
+     *  <li> GLES2 </li>
+     *  <li> GL2ES2 </li>
+     *  <li> GLES1 </li>
+     *  <li> GL2ES1 </li>
      * </ul>
      *
      */
-    public static final String[] GL_PROFILE_LIST_ALL = new String[] { GL4bc, GL3bc, GL2, GL4, GL3, GL2GL3, GLES2, GL2ES2, GLES1, GL2ES1 };
-
+    public static final String[] GL_PROFILE_LIST_ALL = new String[] { GL4bc, GL3bc, GL2, GL4, GL3, GLES3, GL4ES3, GL2GL3, GLES2, GL2ES2, GLES1, GL2ES1 };
+    
     /**
      * Order of maximum profiles.
      *
      * <ul>
-     *  <li> GL4bc
-     *  <li> GL4
-     *  <li> GL3bc
-     *  <li> GL3
-     *  <li> GL2
-     *  <li> GLES2
-     *  <li> GLES1
+     *  <li> GL4bc </li>
+     *  <li> GL4 </li>
+     *  <li> GL3bc </li>
+     *  <li> GL3 </li>
+     *  <li> GLES3 </li>
+     *  <li> GL2 </li>
+     *  <li> GLES2 </li>
+     *  <li> GLES1 </li>
      * </ul>
      *
      */
-    public static final String[] GL_PROFILE_LIST_MAX = new String[] { GL4bc, GL4, GL3bc, GL3, GL2, GLES2, GLES1 };
+    public static final String[] GL_PROFILE_LIST_MAX = new String[] { GL4bc, GL4, GL3bc, GL3, GLES3, GL2, GLES2, GLES1 };
 
     /**
      * Order of minimum profiles.
      *
      * <ul>
-     *  <li> GLES1
-     *  <li> GLES2
-     *  <li> GL2
-     *  <li> GL3
-     *  <li> GL3bc
-     *  <li> GL4
-     *  <li> GL4bc
+     *  <li> GLES1 </li>
+     *  <li> GLES2 </li>
+     *  <li> GL2 </li>
+     *  <li> GLES3 </li>
+     *  <li> GL3 </li>
+     *  <li> GL3bc </li>
+     *  <li> GL4 </li>
+     *  <li> GL4bc </li>
      * </ul>
      *
      */
-    public static final String[] GL_PROFILE_LIST_MIN = new String[] { GLES1, GLES2, GL2, GL3, GL3bc, GL4, GL4bc };
+    public static final String[] GL_PROFILE_LIST_MIN = new String[] { GLES1, GLES2, GL2, GLES3, GL3, GL3bc, GL4, GL4bc };
     
     /**
      * Order of minimum original desktop profiles.
      *
      * <ul>
-     *  <li> GL2
-     *  <li> GL3bc
-     *  <li> GL4bc
-     *  <li> GL3
-     *  <li> GL4
+     *  <li> GL2 </li>
+     *  <li> GL3bc </li>
+     *  <li> GL4bc </li>
+     *  <li> GL3 </li>
+     *  <li> GL4 </li>
      * </ul>
      *
      */
@@ -521,10 +549,10 @@ public class GLProfile {
      * Order of maximum fixed function profiles
      *
      * <ul>
-     *  <li> GL4bc
-     *  <li> GL3bc
-     *  <li> GL2
-     *  <li> GLES1
+     *  <li> GL4bc </li>
+     *  <li> GL3bc </li>
+     *  <li> GL2 </li>
+     *  <li> GLES1 </li>
      * </ul>
      *
      */
@@ -534,28 +562,30 @@ public class GLProfile {
      * Order of maximum programmable shader profiles
      *
      * <ul>
-     *  <li> GL4bc
-     *  <li> GL4
-     *  <li> GL3bc
-     *  <li> GL3
-     *  <li> GL2
-     *  <li> GLES2
+     *  <li> GL4bc </li>
+     *  <li> GL4 </li>
+     *  <li> GL3bc </li>
+     *  <li> GL3 </li>
+     *  <li> GLES3 </li>
+     *  <li> GL2 </li>
+     *  <li> GLES2 </li>
      * </ul>
      *
      */
-    public static final String[] GL_PROFILE_LIST_MAX_PROGSHADER = new String[] { GL4bc, GL4, GL3bc, GL3, GL2, GLES2 };
+    public static final String[] GL_PROFILE_LIST_MAX_PROGSHADER = new String[] { GL4bc, GL4, GL3bc, GL3, GLES3, GL2, GLES2 };
 
     /**
      * Order of maximum programmable shader <i>core only</i> profiles
      *
      * <ul>
-     *  <li> GL4
-     *  <li> GL3
-     *  <li> GLES2
+     *  <li> GL4 </li>
+     *  <li> GL3 </li>
+     *  <li> GLES3 </li>
+     *  <li> GLES2 </li>
      * </ul>
      *
      */
-    public static final String[] GL_PROFILE_LIST_MAX_PROGSHADER_CORE = new String[] { GL4, GL3, GLES2 };
+    public static final String[] GL_PROFILE_LIST_MAX_PROGSHADER_CORE = new String[] { GL4, GL3, GLES3, GLES2 };
     
     /** Returns a default GLProfile object, reflecting the best for the running platform.
      * It selects the first of the set {@link GLProfile#GL_PROFILE_LIST_ALL}
@@ -755,6 +785,36 @@ public class GLProfile {
     }
 
     /** 
+     * Returns the GL4ES3 profile implementation, hence compatible w/ GL4ES3.<br/>
+     * It returns:
+     * <pre>
+     *   GLProfile.get(device, GLProfile.GL4ES3).getImpl());
+     * </pre>
+     * <p>Selection favors hardware rasterizer.</p>
+     *
+     * @throws GLException if no GL4ES3 compatible profile is available for the default device.
+     * @see #isGL4ES3()
+     * @see #get(AbstractGraphicsDevice, String)
+     * @see #getImpl()
+     */
+    public static GLProfile getGL4ES3(AbstractGraphicsDevice device)
+        throws GLException
+    {
+        return get(device, GL4ES3).getImpl();
+    }
+
+    /** 
+     * Calls {@link #getGL4ES3(AbstractGraphicsDevice)} using the default device. 
+     * <p>Selection favors hardware rasterizer.</p>
+     * @see #getGL4ES3(AbstractGraphicsDevice)
+     */
+    public static GLProfile getGL4ES3()
+        throws GLException
+    {
+        return get(defaultDevice, GL4ES3).getImpl();
+    }
+
+    /** 
      * Returns the GL2GL3 profile implementation, hence compatible w/ GL2GL3.<br/>
      * It returns:
      * <pre>
@@ -872,13 +932,20 @@ public class GLProfile {
         return GLES1.equals(profileImpl);
     }
 
-    /** Indicates whether the native OpenGL ES2 profile is in use. 
-     * This requires an EGL or ES2 compatible interface.
+    /** Indicates whether the native OpenGL ES3 or ES2 profile is in use. 
+     * This requires an EGL, ES3 or ES2 compatible interface.
      */
     public static boolean usesNativeGLES2(String profileImpl) {
-        return GLES2.equals(profileImpl);
+        return GLES3.equals(profileImpl) || GLES2.equals(profileImpl);
     }
 
+    /** Indicates whether the native OpenGL ES2 profile is in use. 
+     * This requires an EGL, ES3 compatible interface.
+     */
+    public static boolean usesNativeGLES3(String profileImpl) {
+        return GLES3.equals(profileImpl);
+    }
+    
     /** Indicates whether either of the native OpenGL ES profiles are in use. */
     public static boolean usesNativeGLES(String profileImpl) {
         return usesNativeGLES2(profileImpl) || usesNativeGLES1(profileImpl);
@@ -937,8 +1004,8 @@ public class GLProfile {
     }
 
     private static final String getGLImplBaseClassName(String profileImpl) {
-        if( GLES2 == profileImpl ) {
-            return "jogamp.opengl.es2.GLES2";
+        if( GLES2 == profileImpl || GLES3 == profileImpl ) {
+            return "jogamp.opengl.es3.GLES3";
         } else if( GLES1 == profileImpl ) {
             return "jogamp.opengl.es1.GLES1";
         } else if ( GL4bc == profileImpl ||
@@ -1035,14 +1102,19 @@ public class GLProfile {
         return GLES1 == profile;
     }
 
-    /** Indicates whether this profile is capable of GLES2.  <p>Includes [ GLES2 ].</p> */
+    /** Indicates whether this profile is capable of GLES2.  <p>Includes [ GLES3, GLES2 ].</p> */
     public final boolean isGLES2() {
-        return GLES2 == profile;
+        return GLES3 == profile || GLES2 == profile;
     }
     
-    /** Indicates whether this profile is capable of GLES.  <p>Includes [ GLES1, GLES2 ].</p> */
+    /** Indicates whether this profile is capable of GLES3.  <p>Includes [ GLES3 ].</p> */
+    public final boolean isGLES3() {
+        return GLES3 == profile;
+    }
+    
+    /** Indicates whether this profile is capable of GLES.  <p>Includes [ GLES3, GLES1, GLES2 ].</p> */
     public final boolean isGLES() {
-        return GLES2 == profile || GLES1 == profile;
+        return GLES3 == profile || GLES2 == profile || GLES1 == profile;
     }
 
     /** Indicates whether this profile is capable of GL2ES1. <p>Includes [ GL4bc, GL3bc, GL2, GLES1, GL2ES1 ].</p> */
@@ -1050,17 +1122,27 @@ public class GLProfile {
         return GL2ES1 == profile || isGLES1() || isGL2();
     }
 
-    /** Indicates whether this profile is capable os GL2GL3. <p>Includes [ GL4bc, GL4, GL3bc, GL3, GL2, GL2GL3 ].</p> */
+    /** Indicates whether this profile is capable of GL2GL3. <p>Includes [ GL4bc, GL4, GL3bc, GL3, GL2, GL2GL3 ].</p> */
     public final boolean isGL2GL3() {
         return GL2GL3 == profile || isGL3() || isGL2();
     }
-
-    /** Indicates whether this profile is capable os GL2ES2. <p>Includes [ GL4bc, GL4, GL3bc, GL3, GL2, GL2GL3, GL2ES2, GLES2 ].</p> */
+    
+    /** Indicates whether this profile is capable of GL2ES2. <p>Includes [ GL4bc, GL4, GL3bc, GL3, GLES3, GL2, GL2GL3, GL2ES2, GLES2 ].</p> */
     public final boolean isGL2ES2() {
         return GL2ES2 == profile || isGLES2() || isGL2GL3();
     }
 
-    /** Indicates whether this profile supports GLSL, ie. {@link #isGL2ES2()}. */
+    /** Indicates whether this profile is capable of GL3ES3. <p>Includes [ GL4bc, GL4, GL3bc, GL3, GLES3 ].</p> */
+    public final boolean isGL3ES3() {
+        return isGL4ES3() || isGL3();
+    }
+
+    /** Indicates whether this profile is capable of GL4ES3. <p>Includes [ GL4bc, GL4, GLES3 ].</p> */
+    public final boolean isGL4ES3() {
+        return GL4ES3 == profile || isGLES3() || isGL4();
+    }
+
+    /** Indicates whether this profile supports GLSL, i.e. {@link #isGL2ES2()}. */
     public final boolean hasGLSL() {
         return isGL2ES2() ;
     }
@@ -1072,7 +1154,12 @@ public class GLProfile {
 
     /** Indicates whether this profile uses the native OpenGL ES2 implementations. */
     public final boolean usesNativeGLES2() {
-        return GLES2 == getImplName();
+        return GLES3 == getImplName() || GLES2 == getImplName();
+    }
+
+    /** Indicates whether this profile uses the native OpenGL ES2 implementations. */
+    public final boolean usesNativeGLES3() {
+        return GLES3 == getImplName();
     }
 
     /** Indicates whether this profile uses either of the native OpenGL ES implementations. */
@@ -1117,8 +1204,8 @@ public class GLProfile {
     
     public boolean isValidArrayDataType(int index, int comps, int type, 
                                         boolean isVertexAttribPointer, boolean throwException) {
-        String arrayName = getGLArrayName(index);
-        if(isGLES1()) {
+        final String arrayName = getGLArrayName(index);
+        if( isGLES1() ) {
             if(isVertexAttribPointer) {
                 if(throwException) {
                     throw new GLException("Illegal array type for "+arrayName+" on profile GLES1: VertexAttribPointer");
@@ -1201,7 +1288,7 @@ public class GLProfile {
                     }
                     break;
             }
-        } else if(isGLES2()) {
+        } else if( isGLES2() ) {
             // simply ignore !isVertexAttribPointer case, since it is simulated anyway ..
             switch(type) {
                 case GL.GL_UNSIGNED_BYTE:
@@ -1386,7 +1473,7 @@ public class GLProfile {
     private static /*final*/ boolean hasDesktopGLFactory;    
     private static /*final*/ boolean hasGL234Impl;
     private static /*final*/ boolean hasEGLFactory;
-    private static /*final*/ boolean hasGLES2Impl;
+    private static /*final*/ boolean hasGLES3Impl;
     private static /*final*/ boolean hasGLES1Impl;
 
     private static /*final*/ GLDrawableFactoryImpl eglFactory = null;
@@ -1419,7 +1506,7 @@ public class GLProfile {
         
         // depends on hasEGLFactory
         hasGLES1Impl   = ReflectionUtil.isClassAvailable("jogamp.opengl.es1.GLES1Impl", classloader);
-        hasGLES2Impl   = ReflectionUtil.isClassAvailable("jogamp.opengl.es2.GLES2Impl", classloader);
+        hasGLES3Impl   = ReflectionUtil.isClassAvailable("jogamp.opengl.es3.GLES3Impl", classloader);
         
         //
         // Iteration of desktop GL availability detection
@@ -1471,8 +1558,8 @@ public class GLProfile {
                 eglFactory = (GLDrawableFactoryImpl) GLDrawableFactory.getFactoryImpl(GLES2);
                 if(null != eglFactory) {
                     hasEGLFactory = true;
-                    // update hasGLES1Impl, hasGLES2Impl based on EGL
-                    hasGLES2Impl = null!=eglFactory.getGLDynamicLookupHelper(2) && hasGLES2Impl;
+                    // update hasGLES1Impl, hasGLES3Impl based on EGL
+                    hasGLES3Impl = null!=eglFactory.getGLDynamicLookupHelper(2) && hasGLES3Impl;
                     hasGLES1Impl = null!=eglFactory.getGLDynamicLookupHelper(1) && hasGLES1Impl;
                 }
             } catch (LinkageError le) {
@@ -1493,7 +1580,7 @@ public class GLProfile {
 
         final AbstractGraphicsDevice defaultEGLDevice;
         if(null == eglFactory) {
-            hasGLES2Impl     = false;
+            hasGLES3Impl     = false;
             hasGLES1Impl     = false;
             defaultEGLDevice = null;
             if(DEBUG) {
@@ -1532,7 +1619,7 @@ public class GLProfile {
             System.err.println("GLProfile.init hasGL234Impl          "+hasGL234Impl);
             System.err.println("GLProfile.init hasEGLFactory         "+hasEGLFactory);
             System.err.println("GLProfile.init hasGLES1Impl          "+hasGLES1Impl);
-            System.err.println("GLProfile.init hasGLES2Impl          "+hasGLES2Impl);
+            System.err.println("GLProfile.init hasGLES3Impl          "+hasGLES3Impl);
             System.err.println("GLProfile.init defaultDevice         "+defaultDevice);
             System.err.println("GLProfile.init defaultDevice Desktop "+defaultDesktopDevice);
             System.err.println("GLProfile.init defaultDevice EGL     "+defaultEGLDevice);
@@ -1609,8 +1696,8 @@ public class GLProfile {
         
         final boolean deviceIsEGLCompatible = hasEGLFactory && eglFactory.getIsDeviceCompatible(device);
         
-        // also test GLES1 and GLES2 on desktop, since we have implementations / emulations available.
-        if( deviceIsEGLCompatible && ( hasGLES2Impl || hasGLES1Impl ) ) {
+        // also test GLES1, GLES2 and GLES3 on desktop, since we have implementations / emulations available.
+        if( deviceIsEGLCompatible && ( hasGLES3Impl || hasGLES1Impl ) ) {
             // 1st pretend we have all EGL profiles ..
             computeProfileMap(device, false /* desktopCtxUndef*/, true /* esCtxUndef */);
 
@@ -1629,7 +1716,7 @@ public class GLProfile {
                 // but it seems even EGL.eglInitialize(eglDisplay, null, null) 
                 // fails in some scenarios (eg VirtualBox 4.1.6) w/ EGL error 0x3001 (EGL_NOT_INITIALIZED).
                 hasEGLFactory = false;
-                hasGLES2Impl = false;
+                hasGLES3Impl = false;
                 hasGLES1Impl = false;
             }
             if (DEBUG) {
@@ -1647,7 +1734,7 @@ public class GLProfile {
                 System.err.println("GLProfile: desktoplFactory      "+desktopFactory);
                 System.err.println("GLProfile: eglFactory           "+eglFactory);
                 System.err.println("GLProfile: hasGLES1Impl         "+hasGLES1Impl);
-                System.err.println("GLProfile: hasGLES2Impl         "+hasGLES2Impl);
+                System.err.println("GLProfile: hasGLES3Impl         "+hasGLES3Impl);
             }
         }
 
@@ -1725,18 +1812,18 @@ public class GLProfile {
         final boolean isHardwareRasterizer[] = new boolean[1];
         GLProfile defaultGLProfileAny = null;
         GLProfile defaultGLProfileHW = null;
-        HashMap<String, GLProfile> _mappedProfiles = new HashMap<String, GLProfile>(GL_PROFILE_LIST_ALL.length + 1 /* default */);
+        final HashMap<String, GLProfile> _mappedProfiles = new HashMap<String, GLProfile>(GL_PROFILE_LIST_ALL.length + 1 /* default */);
         for(int i=0; i<GL_PROFILE_LIST_ALL.length; i++) {
-            String profile = GL_PROFILE_LIST_ALL[i];
-            String profileImpl = computeProfileImpl(device, profile, desktopCtxUndef, esCtxUndef, isHardwareRasterizer);
-            if(null!=profileImpl) {
+            final String profile = GL_PROFILE_LIST_ALL[i];
+            final String profileImpl = computeProfileImpl(device, profile, desktopCtxUndef, esCtxUndef, isHardwareRasterizer);
+            if( null != profileImpl ) {
                 final GLProfile glProfile;
-                if(profile.equals(profileImpl)) {
+                if( profile.equals( profileImpl ) ) {
                     glProfile = new GLProfile(profile, null, isHardwareRasterizer[0]);
                 } else {
-                    final GLProfile _mglp = _mappedProfiles.get(profileImpl);
-                    if(null == _mglp) {
-                        throw new InternalError("XXX0");
+                    final GLProfile _mglp = _mappedProfiles.get( profileImpl );
+                    if( null == _mglp ) {
+                        throw new InternalError("XXX0 profile["+i+"]: "+profile+" -> profileImpl "+profileImpl+" !!! not mapped ");
                     }
                     glProfile = new GLProfile(profile, _mglp, isHardwareRasterizer[0]);
                 }
@@ -1744,12 +1831,12 @@ public class GLProfile {
                 if (DEBUG) {
                     System.err.println("GLProfile.init map "+glProfile+" on device "+device.getConnection());
                 }
-                if(null==defaultGLProfileHW && isHardwareRasterizer[0]) {
+                if( null == defaultGLProfileHW && isHardwareRasterizer[0] ) {
                     defaultGLProfileHW=glProfile;
                     if (DEBUG) {
                         System.err.println("GLProfile.init map defaultHW "+glProfile+" on device "+device.getConnection());
                     }
-                } else if(null==defaultGLProfileAny) {
+                } else if( null == defaultGLProfileAny ) {
                     defaultGLProfileAny=glProfile;
                     if (DEBUG) {
                         System.err.println("GLProfile.init map defaultAny "+glProfile+" on device "+device.getConnection());
@@ -1761,9 +1848,9 @@ public class GLProfile {
                 }
             }
         }
-        if(null!=defaultGLProfileHW) {
+        if( null != defaultGLProfileHW ) {
             _mappedProfiles.put(GL_DEFAULT, defaultGLProfileHW);
-        } else if(null!=defaultGLProfileAny) {
+        } else if( null != defaultGLProfileAny ) {
             _mappedProfiles.put(GL_DEFAULT, defaultGLProfileAny);
         }
         setProfileMap(device, _mappedProfiles);
@@ -1805,23 +1892,18 @@ public class GLProfile {
             }
         } else if (GL2ES2.equals(profile)) {
             final boolean es2HardwareRasterizer[] = new boolean[1];
-            final boolean gles2Available = hasGLES2Impl && ( esCtxUndef || GLContext.isGLES2Available(device, es2HardwareRasterizer) );
+            final boolean gles2Available = hasGLES3Impl && ( esCtxUndef || GLContext.isGLES2Available(device, es2HardwareRasterizer) );
             final boolean gles2HWAvailable = gles2Available && es2HardwareRasterizer[0] ;
             if(hasGL234Impl) {
                 if(!isOSX) {
-                    if(GLContext.isGL4bcAvailable(device, isHardwareRasterizer)) {
-                        if(!gles2HWAvailable || isHardwareRasterizer[0]) {
-                            return GL4bc;
-                        }
-                    }
                     if(GLContext.isGL4Available(device, isHardwareRasterizer)) {
                         if(!gles2HWAvailable || isHardwareRasterizer[0]) {
                             return GL4;
                         }
                     }
-                    if(GLContext.isGL3bcAvailable(device, isHardwareRasterizer)) {
+                    if(GLContext.isGL4bcAvailable(device, isHardwareRasterizer)) {
                         if(!gles2HWAvailable || isHardwareRasterizer[0]) {
-                            return GL3bc;
+                            return GL4bc;
                         }
                     }
                     if(GLContext.isGL3Available(device, isHardwareRasterizer)) {
@@ -1829,6 +1911,11 @@ public class GLProfile {
                             return GL3;
                         }
                     }
+                    if(GLContext.isGL3bcAvailable(device, isHardwareRasterizer)) {
+                        if(!gles2HWAvailable || isHardwareRasterizer[0]) {
+                            return GL3bc;
+                        }
+                    }
                 }
                 if(desktopCtxUndef || GLContext.isGL2Available(device, isHardwareRasterizer)) {
                     if(!gles2HWAvailable || isHardwareRasterizer[0]) {
@@ -1840,6 +1927,26 @@ public class GLProfile {
                 isHardwareRasterizer[0] = es2HardwareRasterizer[0];
                 return GLES2;
             }
+        } else if (GL4ES3.equals(profile)) {
+            final boolean es3HardwareRasterizer[] = new boolean[1];
+            final boolean gles3Available = hasGLES3Impl && ( esCtxUndef || GLContext.isGLES3Available(device, es3HardwareRasterizer) );
+            final boolean gles3HWAvailable = gles3Available && es3HardwareRasterizer[0] ;
+            if(hasGL234Impl) {
+                if(GLContext.isGL4Available(device, isHardwareRasterizer)) {
+                    if(!gles3HWAvailable || isHardwareRasterizer[0]) {
+                        return GL4;
+                    }
+                }
+                if(GLContext.isGL4bcAvailable(device, isHardwareRasterizer)) {
+                    if(!gles3HWAvailable || isHardwareRasterizer[0]) {
+                        return GL4bc;
+                    }
+                }
+            }
+            if(gles3Available) {
+                isHardwareRasterizer[0] = es3HardwareRasterizer[0];
+                return GLES3;
+            }
         } else if(GL2GL3.equals(profile)) {
             if(hasGL234Impl) {
                 if(!isOSX && GLContext.isGL4bcAvailable(device, isHardwareRasterizer)) {
@@ -1864,7 +1971,9 @@ public class GLProfile {
             return GL3;
         } else if(GL2.equals(profile) && hasGL234Impl && ( desktopCtxUndef || GLContext.isGL2Available(device, isHardwareRasterizer))) {
             return GL2;
-        } else if(GLES2.equals(profile) && hasGLES2Impl && ( esCtxUndef || GLContext.isGLES2Available(device, isHardwareRasterizer))) {
+        } else if(GLES3.equals(profile) && hasGLES3Impl && ( esCtxUndef || GLContext.isGLES3Available(device, isHardwareRasterizer))) {
+            return GLES3;
+        } else if(GLES2.equals(profile) && hasGLES3Impl && ( esCtxUndef || GLContext.isGLES2Available(device, isHardwareRasterizer))) {
             return GLES2;
         } else if(GLES1.equals(profile) && hasGLES1Impl && ( esCtxUndef || GLContext.isGLES1Available(device, isHardwareRasterizer))) {
             return GLES1;
diff --git a/src/jogl/classes/jogamp/opengl/ExtensionAvailabilityCache.java b/src/jogl/classes/jogamp/opengl/ExtensionAvailabilityCache.java
index 7c7ea1508..94acf93b0 100644
--- a/src/jogl/classes/jogamp/opengl/ExtensionAvailabilityCache.java
+++ b/src/jogl/classes/jogamp/opengl/ExtensionAvailabilityCache.java
@@ -219,17 +219,17 @@ final class ExtensionAvailabilityCache {
           System.err.println(getThreadName() + ":ExtensionAvailabilityCache: ALL EXTENSIONS: "+availableExtensionCache.size());
       }
 
-      if(!context.isGLES()) {
-          final VersionNumber version = context.getGLVersionNumber();
-          int major[] = new int[] { version.getMajor() };
-          int minor[] = new int[] { version.getMinor() };
-          while (GLContext.isValidGLVersion(major[0], minor[0])) {
-              availableExtensionCache.add("GL_VERSION_" + major[0] + "_" + minor[0]);
-              if (DEBUG) {
-                  System.err.println(getThreadName() + ":ExtensionAvailabilityCache: Added GL_VERSION_" + major[0] + "_" + minor[0] + " to known extensions");
-              }
-              if(!GLContext.decrementGLVersion(major, minor)) break;
+      final int ctxOptions = context.getCtxOptions();
+      final VersionNumber version = context.getGLVersionNumber();
+      int major[] = new int[] { version.getMajor() };
+      int minor[] = new int[] { version.getMinor() };          
+      while (GLContext.isValidGLVersion(ctxOptions, major[0], minor[0])) {
+          final String GL_XX_VERSION = ( context.isGLES() ? "GL_ES_VERSION_" : "GL_VERSION_" ) + major[0] + "_" + minor[0];
+          availableExtensionCache.add(GL_XX_VERSION);
+          if (DEBUG) {
+              System.err.println(getThreadName() + ":ExtensionAvailabilityCache: Added "+GL_XX_VERSION+" to known extensions");
           }
+          if(!GLContext.decrementGLVersion(ctxOptions, major, minor)) break;
       }
 
       // put a dummy var in here so that the cache is no longer empty even if
diff --git a/src/jogl/classes/jogamp/opengl/GLContextImpl.java b/src/jogl/classes/jogamp/opengl/GLContextImpl.java
index f896c95ee..18e136815 100644
--- a/src/jogl/classes/jogamp/opengl/GLContextImpl.java
+++ b/src/jogl/classes/jogamp/opengl/GLContextImpl.java
@@ -40,6 +40,7 @@
 
 package jogamp.opengl;
 
+import java.lang.reflect.Method;
 import java.nio.ByteBuffer;
 import java.nio.IntBuffer;
 import java.security.AccessController;
@@ -66,6 +67,7 @@ import javax.media.nativewindow.NativeSurface;
 import javax.media.nativewindow.NativeWindowFactory;
 import javax.media.opengl.GL;
 import javax.media.opengl.GL2ES2;
+import javax.media.opengl.GL2ES3;
 import javax.media.opengl.GL2GL3;
 import javax.media.opengl.GLCapabilitiesImmutable;
 import javax.media.opengl.GLContext;
@@ -396,9 +398,10 @@ public abstract class GLContextImpl extends GLContext {
                       associateDrawableException = t;
                   }
                   if ( 0 != defaultVAO ) {
-                      int[] tmp = new int[] { defaultVAO };
-                      gl.getGL2GL3().glBindVertexArray(0);
-                      gl.getGL2GL3().glDeleteVertexArrays(1, tmp, 0);
+                      final int[] tmp = new int[] { defaultVAO };
+                      final GL2ES3 gl3es3 = gl.getGL3ES3(); 
+                      gl3es3.glBindVertexArray(0);
+                      gl3es3.glDeleteVertexArrays(1, tmp, 0);
                       defaultVAO = 0;
                   }
                   glDebugHandler.enable(false);
@@ -640,9 +643,10 @@ public abstract class GLContextImpl extends GLContext {
                 // to avoid INVALID_OPERATION at VertexAttribPointer. 
                 // More clear is GL 4.3 core spec: 10.4 (p 307).
                 final int[] tmp = new int[1];
-                gl.getGL2GL3().glGenVertexArrays(1, tmp, 0);
+                final GL2ES3 gl3es3 = gl.getGL3ES3();
+                gl3es3.glGenVertexArrays(1, tmp, 0);
                 defaultVAO = tmp[0];
-                gl.getGL2GL3().glBindVertexArray(defaultVAO);
+                gl3es3.glBindVertexArray(defaultVAO);
             }
         } finally {
             if (null != shareWith) {
@@ -836,6 +840,7 @@ public abstract class GLContextImpl extends GLContext {
         boolean hasGL2   = false;
         boolean hasGL4   = false;
         boolean hasGL3   = false;
+        boolean hasES3   = false;
         
         // Even w/ PROFILE_ALIASING, try to use true core GL profiles
         // ensuring proper user behavior across platforms due to different feature sets!
@@ -904,6 +909,13 @@ public abstract class GLContextImpl extends GLContext {
                 resetStates(); // clean this context states, since creation was temporary                
             }
         }
+        if(!hasES3) {
+            hasES3   = createContextARBMapVersionsAvailable(3, CTX_PROFILE_ES);  // ES3
+            success |= hasES3;
+            if(hasES3) {
+                resetStates(); // clean this context states, since creation was temporary                
+            }
+        }
         if(success) {
             // only claim GL versions set [and hence detected] if ARB context creation was successful
             GLContext.setAvailableGLVersionsSet(device);
@@ -925,12 +937,7 @@ public abstract class GLContextImpl extends GLContext {
    **/
   private final boolean createContextARBMapVersionsAvailable(int reqMajor, int reqProfile) {
     long _context;
-    int ctp = CTX_IS_ARB_CREATED;
-    if(CTX_PROFILE_COMPAT == reqProfile) {
-        ctp |= CTX_PROFILE_COMPAT ;
-    } else {
-        ctp |= CTX_PROFILE_CORE ;
-    }
+    int ctp = CTX_IS_ARB_CREATED | reqProfile;
 
     // To ensure GL profile compatibility within the JOGL application
     // we always try to map against the highest GL version,
@@ -940,10 +947,10 @@ public abstract class GLContextImpl extends GLContext {
     int major[] = new int[1];
     int minor[] = new int[1];
     if( 4 == reqMajor ) {
-        majorMax=4; minorMax=GLContext.getMaxMinor(majorMax);
+        majorMax=4; minorMax=GLContext.getMaxMinor(ctp, majorMax);
         majorMin=4; minorMin=0;
     } else if( 3 == reqMajor ) {
-        majorMax=3; minorMax=GLContext.getMaxMinor(majorMax);
+        majorMax=3; minorMax=GLContext.getMaxMinor(ctp, majorMax);
         majorMin=3; minorMin=1;
     } else /* if( glp.isGL2() ) */ {
         // our minimum desktop OpenGL runtime requirements are 1.1,
@@ -1003,7 +1010,7 @@ public abstract class GLContextImpl extends GLContext {
     minor[0]=minorMax;
     long _context=0;
 
-    while ( GLContext.isValidGLVersion(major[0], minor[0]) &&
+    while ( GLContext.isValidGLVersion(ctxOptionFlags, major[0], minor[0]) &&
             ( major[0]>majorMin || major[0]==majorMin && minor[0] >=minorMin ) ) {
         if (DEBUG) {
             System.err.println(getThreadName() + ": createContextARBVersions: share "+share+", direct "+direct+", version "+major[0]+"."+minor[0]);
@@ -1019,7 +1026,7 @@ public abstract class GLContextImpl extends GLContext {
             }
         }
 
-        if(!GLContext.decrementGLVersion(major, minor)) {
+        if(!GLContext.decrementGLVersion(ctxOptionFlags, major, minor)) {
             break;
         }
     }
@@ -1040,11 +1047,11 @@ public abstract class GLContextImpl extends GLContext {
         throw new GLException("Invalid GL Version "+major+"."+minor+", ctp "+toHexString(ctp));
       }
       
-      if (!GLContext.isValidGLVersion(major, minor)) {
+      if (!GLContext.isValidGLVersion(ctp, major, minor)) {
         throw new GLException("Invalid GL Version "+major+"."+minor+", ctp "+toHexString(ctp));
       }
       ctxVersion = new VersionNumber(major, minor, 0);
-      ctxVersionString = getGLVersion(major, minor, ctxOptions, glVersion);
+      ctxVersionString = getGLVersion(major, minor, ctp, glVersion);
       ctxVendorVersion = glVendorVersion;
       ctxOptions = ctp;
       if(useGL) {
@@ -1087,6 +1094,27 @@ public abstract class GLContextImpl extends GLContext {
     */
     return gl;
   }
+  
+  /** 
+   * Finalizes GL instance initialization after this context has been initialized.
+   * <p>
+   * Method calls 'void finalizeInit()' of instance 'gl' as retrieved by reflection, if exist.
+   * </p>
+   */
+  private void finalizeInit(GL gl) {
+      Method finalizeInit = null;
+      try {
+          finalizeInit = ReflectionUtil.getMethod(gl.getClass(), "finalizeInit", new Class<?>[]{ });
+      } catch ( Throwable t ) {
+          if(DEBUG) {
+              System.err.println("Catched "+t.getClass().getName()+": "+t.getMessage());
+              t.printStackTrace();
+          }
+      }
+      if( null != finalizeInit ) {
+          ReflectionUtil.callMethod(gl, finalizeInit, new Object[]{ });
+      }
+  }
 
   public final ProcAddressTable getGLProcAddressTable() {
     return glProcAddressTable;
@@ -1097,8 +1125,24 @@ public abstract class GLContextImpl extends GLContext {
    * ie for GLXExt, EGLExt, ..
    */
   public abstract ProcAddressTable getPlatformExtProcAddressTable();
+  
+  /**
+   * Part of <code>GL_NV_vertex_array_range</code>.
+   * <p>
+   * Provides platform-independent access to the <code>wglAllocateMemoryNV</code> /
+   * <code>glXAllocateMemoryNV</code>.
+   * </p>
+   */
+  public abstract ByteBuffer glAllocateMemoryNV(int size, float readFrequency, float writeFrequency, float priority);
 
-  public abstract ByteBuffer glAllocateMemoryNV(int arg0, float arg1, float arg2, float arg3);
+  /**
+   * Part of <code>GL_NV_vertex_array_range</code>.
+   * <p>
+   * Provides platform-independent access to the <code>wglFreeMemoryNV</code> /
+   * <code>glXFreeMemoryNV</code>.
+   * </p>
+   */  
+  public abstract void glFreeMemoryNV(ByteBuffer pointer);
 
   /** Maps the given "platform-independent" function name to a real function
       name. Currently this is only used to map "glAllocateMemoryNV" and
@@ -1208,7 +1252,7 @@ public abstract class GLContextImpl extends GLContext {
               int[] major = new int[] { version.getMajor() };
               int[] minor = new int[] { version.getMinor() };
               limitNonARBContextVersion(major, minor, ctp);
-              if ( GLContext.isValidGLVersion(major[0], minor[0]) ) {
+              if ( GLContext.isValidGLVersion(ctp, major[0], minor[0]) ) {
                   return new VersionNumber(major[0], minor[0], 0);
               }
           }
@@ -1244,6 +1288,11 @@ public abstract class GLContextImpl extends GLContext {
     }
   }
   
+  protected final int getCtxOptions() {
+      return ctxOptions;
+  }
+
+  
   /**
    * Sets the OpenGL implementation class and
    * the cache of which GL functions are available for calling through this
@@ -1275,7 +1324,7 @@ public abstract class GLContextImpl extends GLContext {
         return true; // already done and not forced
     }
 
-    if ( 0 < major && !GLContext.isValidGLVersion(major, minor) ) {
+    if ( 0 < major && !GLContext.isValidGLVersion(ctxProfileBits, major, minor) ) {
         throw new GLException("Invalid GL Version Request "+GLContext.getGLVersion(major, minor, ctxProfileBits, null));
     }
     
@@ -1336,7 +1385,7 @@ public abstract class GLContextImpl extends GLContext {
         }
         
         // Only validate if a valid int version was fetched, otherwise cont. w/ version-string method -> 3.0 > Version || Version > MAX!
-        if ( GLContext.isValidGLVersion(glIntMajor[0], glIntMinor[0]) ) {
+        if ( GLContext.isValidGLVersion(ctxProfileBits, glIntMajor[0], glIntMinor[0]) ) {
             if( glIntMajor[0]<major || ( glIntMajor[0]==major && glIntMinor[0]<minor ) || 0 == major ) {        
                 if( strictMatch && 2 < major ) { // relaxed match for versions major < 3 requests, last resort!
                     if(DEBUG) {
@@ -1391,8 +1440,8 @@ public abstract class GLContextImpl extends GLContext {
         System.err.println(getThreadName() + ": GLContext.setGLFuncAvail: post version verification "+GLContext.getGLVersion(major, minor, ctxProfileBits, null)+", strictMatch "+strictMatch+", versionValidated "+versionValidated+", versionGL3IntFailed "+versionGL3IntFailed);
     }
     
-    if( 2 > major ) { // there is no ES2-compat for a profile w/ major < 2
-        ctxProfileBits &= ~GLContext.CTX_IMPL_ES2_COMPAT;
+    if( 2 > major ) { // there is no ES2/3-compat for a profile w/ major < 2
+        ctxProfileBits &= ~ ( GLContext.CTX_IMPL_ES2_COMPAT | GLContext.CTX_IMPL_ES3_COMPAT ) ;
     }
     
     final VersionNumberString vendorVersion = GLVersionNumber.createVendorVersion(glVersion);
@@ -1468,13 +1517,28 @@ public abstract class GLContextImpl extends GLContext {
         }
     }
     
-    if( ( 0 != ( CTX_PROFILE_ES & ctxProfileBits ) && major >= 2 ) || isExtensionAvailable(GLExtensions.ARB_ES2_compatibility) ) {
+    if( 0 != ( CTX_PROFILE_ES & ctxProfileBits ) ) {
+        if( major >= 3 ) {
+            ctxProfileBits |= CTX_IMPL_ES3_COMPAT | CTX_IMPL_ES2_COMPAT ;
+            ctxProfileBits |= CTX_IMPL_FBO;
+        } else if( major >= 2 ) {
+            ctxProfileBits |= CTX_IMPL_ES2_COMPAT;
+            ctxProfileBits |= CTX_IMPL_FBO;
+        }
+    } else if( isExtensionAvailable( GLExtensions.ARB_ES3_compatibility ) ) {
+        ctxProfileBits |= CTX_IMPL_ES3_COMPAT | CTX_IMPL_ES2_COMPAT ;
+        ctxProfileBits |= CTX_IMPL_FBO;
+    } else if( isExtensionAvailable( GLExtensions.ARB_ES2_compatibility ) ) {
         ctxProfileBits |= CTX_IMPL_ES2_COMPAT;
         ctxProfileBits |= CTX_IMPL_FBO;
     } else if( hasFBOImpl(major, ctxProfileBits, extensionAvailability) ) {
         ctxProfileBits |= CTX_IMPL_FBO;
     }
     
+    if( ( 0 != ( CTX_PROFILE_ES & ctxProfileBits ) && major == 1 ) ||  isExtensionAvailable(GLExtensions.OES_single_precision) ) {
+        ctxProfileBits |= CTX_IMPL_FP32_COMPAT_API;
+    }
+    
     if(FORCE_NO_FBO_SUPPORT) {
         ctxProfileBits &= ~CTX_IMPL_FBO ;
     }      
@@ -1484,6 +1548,8 @@ public abstract class GLContextImpl extends GLContext {
     //
     setContextVersion(major, minor, ctxProfileBits, vendorVersion, true);
     
+    finalizeInit(gl);
+    
     setDefaultSwapInterval();
     
     final int glErrX = gl.glGetError(); // clear GL error, maybe caused by above operations
@@ -1813,7 +1879,7 @@ public abstract class GLContextImpl extends GLContext {
 
   protected static String getContextFQN(AbstractGraphicsDevice device, int major, int minor, int ctxProfileBits) {
       // remove non-key values
-      ctxProfileBits &= ~( GLContext.CTX_IMPL_ES2_COMPAT | GLContext.CTX_IMPL_FBO ) ;
+      ctxProfileBits &= CTX_IMPL_CACHE_MASK;
 
       return device.getUniqueID() + "-" + toHexString(composeBits(major, minor, ctxProfileBits));
   }
@@ -1998,7 +2064,7 @@ public abstract class GLContextImpl extends GLContext {
   public final int getContextCreationFlags() {
       return additionalCtxCreationFlags;
   }
-
+  
   @Override
   public final void setContextCreationFlags(int flags) {
       if(!isCreated()) {
@@ -2041,7 +2107,7 @@ public abstract class GLContextImpl extends GLContext {
   @Override
   public final void glDebugMessageControl(int source, int type, int severity, int count, IntBuffer ids, boolean enabled) {
       if(glDebugHandler.isExtensionARB()) {
-          gl.getGL2GL3().glDebugMessageControlARB(source, type, severity, count, ids, enabled);
+          gl.getGL2GL3().glDebugMessageControl(source, type, severity, count, ids, enabled);
       } else if(glDebugHandler.isExtensionAMD()) {
           gl.getGL2GL3().glDebugMessageEnableAMD(GLDebugMessage.translateARB2AMDCategory(source, type), severity, count, ids, enabled);
       }
@@ -2050,7 +2116,7 @@ public abstract class GLContextImpl extends GLContext {
   @Override
   public final void glDebugMessageControl(int source, int type, int severity, int count, int[] ids, int ids_offset, boolean enabled) {
       if(glDebugHandler.isExtensionARB()) {
-          gl.getGL2GL3().glDebugMessageControlARB(source, type, severity, count, ids, ids_offset, enabled);
+          gl.getGL2GL3().glDebugMessageControl(source, type, severity, count, ids, ids_offset, enabled);
       } else if(glDebugHandler.isExtensionAMD()) {
           gl.getGL2GL3().glDebugMessageEnableAMD(GLDebugMessage.translateARB2AMDCategory(source, type), severity, count, ids, ids_offset, enabled);
       }
@@ -2060,7 +2126,7 @@ public abstract class GLContextImpl extends GLContext {
   public final void glDebugMessageInsert(int source, int type, int id, int severity, String buf) {
       final int len = (null != buf) ? buf.length() : 0;
       if(glDebugHandler.isExtensionARB()) {
-          gl.getGL2GL3().glDebugMessageInsertARB(source, type, id, severity, len, buf);
+          gl.getGL2GL3().glDebugMessageInsert(source, type, id, severity, len, buf);
       } else if(glDebugHandler.isExtensionAMD()) {
           gl.getGL2GL3().glDebugMessageInsertAMD(GLDebugMessage.translateARB2AMDCategory(source, type), severity, id, len, buf);
       }
diff --git a/src/jogl/classes/jogamp/opengl/GLDebugMessageHandler.java b/src/jogl/classes/jogamp/opengl/GLDebugMessageHandler.java
index 10cdd512e..9ecaca75d 100644
--- a/src/jogl/classes/jogamp/opengl/GLDebugMessageHandler.java
+++ b/src/jogl/classes/jogamp/opengl/GLDebugMessageHandler.java
@@ -224,9 +224,9 @@ public class GLDebugMessageHandler {
     private final void setSynchronousImpl() {
         if(isExtensionARB()) {
             if(synchronous) {
-                ctx.getGL().glEnable(GL2GL3.GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB);
+                ctx.getGL().glEnable(GL2GL3.GL_DEBUG_OUTPUT_SYNCHRONOUS);
             } else {
-                ctx.getGL().glDisable(GL2GL3.GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB);
+                ctx.getGL().glDisable(GL2GL3.GL_DEBUG_OUTPUT_SYNCHRONOUS);
             }        
             if(DEBUG) {
                 System.err.println("GLDebugMessageHandler: synchronous "+synchronous);
diff --git a/src/jogl/classes/jogamp/opengl/egl/EGLContext.java b/src/jogl/classes/jogamp/opengl/egl/EGLContext.java
index b54ed6599..e7977e3fb 100644
--- a/src/jogl/classes/jogamp/opengl/egl/EGLContext.java
+++ b/src/jogl/classes/jogamp/opengl/egl/EGLContext.java
@@ -171,7 +171,7 @@ public class EGLContext extends GLContextImpl {
 
         try {
             // might be unavailable on EGL < 1.2
-            if(!EGL.eglBindAPI(EGL.EGL_OPENGL_ES_API)) {
+            if( !EGL.eglBindAPI(EGL.EGL_OPENGL_ES_API) ) {
                 throw new GLException("Catched: eglBindAPI to ES failed , error "+toHexString(EGL.eglGetError()));
             }
         } catch (GLException glex) {
@@ -188,18 +188,21 @@ public class EGLContext extends GLContextImpl {
         }
 
         final IntBuffer contextAttrsNIO;
+        final int contextVersionReq, contextVersionAttr;
         {
-            final int[] contextAttrs = new int[] {
-                    EGL.EGL_CONTEXT_CLIENT_VERSION, -1,
-                    EGL.EGL_NONE
-            };
-            if (glProfile.usesNativeGLES2()) {
-                contextAttrs[1] = 2;
-            } else if (glProfile.usesNativeGLES1()) {
-                contextAttrs[1] = 1;
+            if ( glProfile.usesNativeGLES3() ) {
+                contextVersionReq = 3;
+                contextVersionAttr = 2;
+            } else if ( glProfile.usesNativeGLES2() ) {
+                contextVersionReq = 2;
+                contextVersionAttr = 2;
+            } else if ( glProfile.usesNativeGLES1() ) {
+                contextVersionReq = 1;
+                contextVersionAttr = 1;
             } else {
                 throw new GLException("Error creating OpenGL context - invalid GLProfile: "+glProfile);
             }
+            final int[] contextAttrs = new int[] { EGL.EGL_CONTEXT_CLIENT_VERSION, contextVersionAttr, EGL.EGL_NONE };
             contextAttrsNIO = Buffers.newDirectIntBuffer(contextAttrs);
         }
         contextHandle = EGL.eglCreateContext(eglDisplay, eglConfig, shareWithHandle, contextAttrsNIO);
@@ -219,8 +222,7 @@ public class EGLContext extends GLContextImpl {
             throw new GLException("Error making context " +
                                   toHexString(contextHandle) + " current: error code " + toHexString(EGL.eglGetError()));
         }
-        setGLFunctionAvailability(true, glProfile.usesNativeGLES2() ? 2 : 1, 0, CTX_PROFILE_ES, false);
-        return true;
+        return setGLFunctionAvailability(true, contextVersionReq, 0, CTX_PROFILE_ES, contextVersionReq>=3); // strict match for es >= 3
     }
 
     @Override
@@ -292,16 +294,25 @@ public class EGLContext extends GLContextImpl {
         final GLProfile glp = caps.getGLProfile();
         final int[] reqMajorCTP = new int[2];
         GLContext.getRequestMajorAndCompat(glp, reqMajorCTP);
-        if(glp.isGLES() && reqMajorCTP[0] >= 2) {
-            reqMajorCTP[1] |= GLContext.CTX_IMPL_ES2_COMPAT | GLContext.CTX_IMPL_FBO ;
+        if( glp.isGLES() ) {
+            if( reqMajorCTP[0] >= 3 ) {
+                reqMajorCTP[1] |= GLContext.CTX_IMPL_ES3_COMPAT | GLContext.CTX_IMPL_ES2_COMPAT | GLContext.CTX_IMPL_FBO ;
+            } else if( reqMajorCTP[0] >= 2 ) {
+                reqMajorCTP[1] |= GLContext.CTX_IMPL_ES2_COMPAT | GLContext.CTX_IMPL_FBO ;
+            }
         }
-        if(!caps.getHardwareAccelerated()) {
+        if( !caps.getHardwareAccelerated() ) {
             reqMajorCTP[1] |= GLContext.CTX_IMPL_ACCEL_SOFT;
         }
         mapStaticGLVersion(device, reqMajorCTP[0], 0, reqMajorCTP[1]);
     }    
-    /* pp */ static void mapStaticGLESVersion(AbstractGraphicsDevice device, int major) {
-        int ctp = ( 2 == major ) ? ( GLContext.CTX_PROFILE_ES | GLContext.CTX_IMPL_ES2_COMPAT | GLContext.CTX_IMPL_FBO ) : ( GLContext.CTX_PROFILE_ES );  
+    /* pp */ static void mapStaticGLESVersion(AbstractGraphicsDevice device, final int major) {
+        int ctp = GLContext.CTX_PROFILE_ES;
+        if( major >= 3 ) {
+            ctp |= GLContext.CTX_IMPL_ES3_COMPAT | GLContext.CTX_IMPL_ES2_COMPAT | GLContext.CTX_IMPL_FBO ;
+        } else if( major >= 2 ) {
+            ctp |= GLContext.CTX_IMPL_ES2_COMPAT | GLContext.CTX_IMPL_FBO ;
+        }
         mapStaticGLVersion(device, major, 0, ctp);
     }
     /* pp */ static void mapStaticGLVersion(AbstractGraphicsDevice device, int major, int minor, int ctp) {
@@ -343,9 +354,13 @@ public class EGLContext extends GLContextImpl {
         throw new GLException("Not yet implemented");
     }
 
-
     @Override
-    public ByteBuffer glAllocateMemoryNV(int arg0, float arg1, float arg2, float arg3) {
+    public final ByteBuffer glAllocateMemoryNV(int size, float readFrequency, float writeFrequency, float priority) {
+        throw new GLException("Should not call this");
+    }
+    
+    @Override
+    public final void glFreeMemoryNV(ByteBuffer pointer) {
         throw new GLException("Should not call this");
     }
 }
diff --git a/src/jogl/classes/jogamp/opengl/egl/EGLDrawableFactory.java b/src/jogl/classes/jogamp/opengl/egl/EGLDrawableFactory.java
index 79d1fad62..465c8fa80 100644
--- a/src/jogl/classes/jogamp/opengl/egl/EGLDrawableFactory.java
+++ b/src/jogl/classes/jogamp/opengl/egl/EGLDrawableFactory.java
@@ -91,10 +91,9 @@ public class EGLDrawableFactory extends GLDrawableFactoryImpl {
 
     private static final boolean isANGLE(GLDynamicLookupHelper dl) {
         if(Platform.OSType.WINDOWS == Platform.OS_TYPE) {
-            final boolean r = dl.isFunctionAvailable("eglQuerySurfacePointerANGLE") ||
-                              dl.isFunctionAvailable("glBlitFramebufferANGLE") ||
-                              dl.isFunctionAvailable("glRenderbufferStorageMultisampleANGLE");
-            return r;
+            return dl.isFunctionAvailable("eglQuerySurfacePointerANGLE") ||
+                   dl.isFunctionAvailable("glBlitFramebufferANGLE") ||
+                   dl.isFunctionAvailable("glRenderbufferStorageMultisampleANGLE");
         } else {
             return false;
         }
@@ -253,8 +252,8 @@ public class EGLDrawableFactory extends GLDrawableFactoryImpl {
                 String key = keyI.next();
                 SharedResource sr = sharedMap.get(key);
                 System.err.println("EGLDrawableFactory.map["+i+"] "+key+" -> "+sr.getDevice()+", "+
-                                   "es1 [avail "+sr.wasES1ContextCreated+", pbuffer "+sr.hasPBufferES1+", quirks "+sr.rendererQuirksES1+", ctp "+EGLContext.getGLVersion(1, 0, sr.ctpES1, null)+"], "+
-                                   "es2 [avail "+sr.wasES2ContextCreated+", pbuffer "+sr.hasPBufferES2+", quirks "+sr.rendererQuirksES2+", ctp "+EGLContext.getGLVersion(2, 0, sr.ctpES2, null)+"]");
+                                   "es1   [avail "+sr.wasES1ContextCreated+", pbuffer "+sr.hasPBufferES1+", quirks "+sr.rendererQuirksES1+", ctp "+EGLContext.getGLVersion(1, 0, sr.ctpES1, null)+"], "+
+                                   "es2/3 [es2 "+sr.wasES2ContextCreated+", es3 "+sr.wasES3ContextCreated+", [pbuffer "+sr.hasPBufferES3ES2+", quirks "+sr.rendererQuirksES3ES2+", ctp "+EGLContext.getGLVersion(2, 0, sr.ctpES3ES2, null)+"]]");
             }
             ;
         }
@@ -271,38 +270,45 @@ public class EGLDrawableFactory extends GLDrawableFactoryImpl {
       private final EGLGraphicsDevice device;
       // private final EGLContext contextES1;
       // private final EGLContext contextES2;
-      private final GLRendererQuirks rendererQuirksES1;
-      private final GLRendererQuirks rendererQuirksES2;
-      private final int ctpES1;
-      private final int ctpES2;
+      // private final EGLContext contextES3;
       private final boolean wasES1ContextCreated;
       private final boolean wasES2ContextCreated;
+      private final boolean wasES3ContextCreated;
+      private final GLRendererQuirks rendererQuirksES1;
+      private final GLRendererQuirks rendererQuirksES3ES2;
+      private final int ctpES1;
+      private final int ctpES3ES2;
       private final boolean hasPBufferES1;
-      private final boolean hasPBufferES2;
+      private final boolean hasPBufferES3ES2;
 
       SharedResource(EGLGraphicsDevice dev, 
                      boolean wasContextES1Created, boolean hasPBufferES1, GLRendererQuirks rendererQuirksES1, int ctpES1,  
-                     boolean wasContextES2Created, boolean hasPBufferES2, GLRendererQuirks rendererQuirksES2, int ctpES2) {
+                     boolean wasContextES2Created, boolean wasContextES3Created, 
+                     boolean hasPBufferES3ES2, GLRendererQuirks rendererQuirksES3ES2, int ctpES3ES2) {
           this.device = dev;
           // this.contextES1 = ctxES1;
-          // this.contextES2 = ctxES2;
+          this.wasES1ContextCreated = wasContextES1Created;
+          this.hasPBufferES1= hasPBufferES1;
           this.rendererQuirksES1 = rendererQuirksES1;
-          this.rendererQuirksES2 = rendererQuirksES2;
           this.ctpES1 = ctpES1;
-          this.ctpES2 = ctpES2;
-          this.wasES1ContextCreated = wasContextES1Created;
+          
+          // this.contextES2 = ctxES2;
+          // this.contextES3 = ctxES3;
           this.wasES2ContextCreated = wasContextES2Created;
-          this.hasPBufferES1= hasPBufferES1;
-          this.hasPBufferES2= hasPBufferES2;
+          this.wasES3ContextCreated = wasContextES3Created;
+          this.hasPBufferES3ES2= hasPBufferES3ES2;
+          this.rendererQuirksES3ES2 = rendererQuirksES3ES2;
+          this.ctpES3ES2 = ctpES3ES2;
       }
       @Override
       public final boolean isValid() {
-          return wasES1ContextCreated || wasES2ContextCreated;
+          return wasES1ContextCreated || wasES2ContextCreated || wasES3ContextCreated;
       }
       @Override
       public final EGLGraphicsDevice getDevice() { return device; }
       // final EGLContext getContextES1() { return contextES1; }
       // final EGLContext getContextES2() { return contextES2; }
+      // final EGLContext getContextES3() { return contextES3; }
       
       @Override
       public AbstractGraphicsScreen getScreen() {
@@ -318,7 +324,7 @@ public class EGLDrawableFactory extends GLDrawableFactoryImpl {
       }
       @Override
       public GLRendererQuirks getRendererQuirks() {
-          return null != rendererQuirksES2 ? rendererQuirksES2 : rendererQuirksES1 ;      
+          return null != rendererQuirksES3ES2 ? rendererQuirksES3ES2 : rendererQuirksES1 ;      
       }
     }
 
@@ -353,18 +359,30 @@ public class EGLDrawableFactory extends GLDrawableFactoryImpl {
                                             boolean[] hasPBuffer, GLRendererQuirks[] rendererQuirks, int[] ctp) {
         final String profileString;
         switch( esProfile ) {
+            case 3:
+                profileString = GLProfile.GLES3; break; 
+            case 2:
+                profileString = GLProfile.GLES2; break; 
             case 1: 
                 profileString = GLProfile.GLES1; break;
-            case 2: 
             default: 
-                profileString = GLProfile.GLES2; break; 
+                throw new GLException("Invalid ES profile number "+esProfile);
         }
         if ( !GLProfile.isAvailable(adevice, profileString) ) {
+            if( DEBUG ) {
+                System.err.println("EGLDrawableFactory.mapAvailableEGLESConfig: "+profileString+" n/a on "+adevice);
+            }
             return false;
         }
         final GLProfile glp = GLProfile.get(adevice, profileString) ;
         final GLDrawableFactoryImpl desktopFactory = (GLDrawableFactoryImpl) GLDrawableFactory.getDesktopFactory();
         final boolean mapsADeviceToDefaultDevice = !QUERY_EGL_ES_NATIVE_TK || null == desktopFactory || adevice instanceof EGLGraphicsDevice ;
+        if( DEBUG ) {
+            System.err.println("EGLDrawableFactory.mapAvailableEGLESConfig: "+profileString+" ( "+esProfile+" ), "+
+                               "defaultSharedResourceSet "+(null!=defaultSharedResource)+", mapsADeviceToDefaultDevice "+mapsADeviceToDefaultDevice+
+                               " (QUERY_EGL_ES_NATIVE_TK "+QUERY_EGL_ES_NATIVE_TK+", hasDesktopFactory "+(null != desktopFactory)+
+                               ", isEGLGraphicsDevice "+(adevice instanceof EGLGraphicsDevice)+")");
+        }
 
         EGLGraphicsDevice eglDevice = null;
         NativeSurface surface = null;
@@ -387,16 +405,29 @@ public class EGLDrawableFactory extends GLDrawableFactoryImpl {
                 if( adevice != defaultDevice ) {
                     if(null == defaultSharedResource) {
                         return false;
-                    }
+                    }                    
                     switch(esProfile) {
+                        case 3:
+                            if( !defaultSharedResource.wasES3ContextCreated ) {
+                                return false;
+                            }
+                            rendererQuirks[0] = defaultSharedResource.rendererQuirksES3ES2;
+                            ctp[0] = defaultSharedResource.ctpES3ES2;
+                            break;
+                        case 2: 
+                            if( !defaultSharedResource.wasES2ContextCreated ) {
+                                return false;
+                            }
+                            rendererQuirks[0] = defaultSharedResource.rendererQuirksES3ES2;
+                            ctp[0] = defaultSharedResource.ctpES3ES2;
+                            break;
                         case 1: 
+                            if( !defaultSharedResource.wasES1ContextCreated ) {
+                                return false;
+                            }
                             rendererQuirks[0] = defaultSharedResource.rendererQuirksES1;
                             ctp[0] = defaultSharedResource.ctpES1;
                             break;
-                        case 2: 
-                            rendererQuirks[0] = defaultSharedResource.rendererQuirksES2;
-                            ctp[0] = defaultSharedResource.ctpES2;
-                            break;
                     }
                     EGLContext.mapStaticGLVersion(adevice, esProfile, 0, ctp[0]);
                     return true;
@@ -421,7 +452,7 @@ public class EGLDrawableFactory extends GLDrawableFactoryImpl {
                         success = true;
                     }
                     if(DEBUG) {
-                        System.err.println("EGLDrawableFactory.isEGLContextAvailable() no pbuffer config available, detected !pbuffer config: "+success);
+                        System.err.println("EGLDrawableFactory.mapAvailableEGLESConfig() no pbuffer config available, detected !pbuffer config: "+success);
                         EGLGraphicsConfigurationFactory.printCaps("!PBufferCaps", capsAnyL, System.err);
                     }                    
                 }                
@@ -457,13 +488,13 @@ public class EGLDrawableFactory extends GLDrawableFactoryImpl {
                             } else {
                                 // Oops .. something is wrong
                                 if(DEBUG) {
-                                    System.err.println("EGLDrawableFactory.isEGLContextAvailable: "+eglDevice+", "+context.getGLVersion()+" - VERSION is null, dropping availability!");                                
+                                    System.err.println("EGLDrawableFactory.mapAvailableEGLESConfig: "+eglDevice+", "+context.getGLVersion()+" - VERSION is null, dropping availability!");                                
                                 }
                             }
                         }
                     } catch (GLException gle) {
                         if (DEBUG) {
-                            System.err.println("EGLDrawableFactory.createShared: INFO: context create/makeCurrent failed");
+                            System.err.println("EGLDrawableFactory.mapAvailableEGLESConfig: INFO: context create/makeCurrent failed");
                             gle.printStackTrace();
                         }
                     } finally {
@@ -557,14 +588,15 @@ public class EGLDrawableFactory extends GLDrawableFactoryImpl {
     private SharedResource createEGLSharedResourceImpl(AbstractGraphicsDevice adevice) {
         final boolean madeCurrentES1;            
         final boolean madeCurrentES2;
+        final boolean madeCurrentES3;
         boolean[] hasPBufferES1 = new boolean[] { false };
-        boolean[] hasPBufferES2 = new boolean[] { false };
+        boolean[] hasPBufferES3ES2 = new boolean[] { false };
         // EGLContext[] eglCtxES1 = new EGLContext[] { null };
         // EGLContext[] eglCtxES2 = new EGLContext[] { null };
         GLRendererQuirks[] rendererQuirksES1 = new GLRendererQuirks[] { null };
-        GLRendererQuirks[] rendererQuirksES2 = new GLRendererQuirks[] { null };
+        GLRendererQuirks[] rendererQuirksES3ES2 = new GLRendererQuirks[] { null };
         int[] ctpES1 = new int[] { -1 };
-        int[] ctpES2 = new int[] { -1 };
+        int[] ctpES3ES2 = new int[] { -1 };
         
         
         if (DEBUG) {
@@ -577,9 +609,16 @@ public class EGLDrawableFactory extends GLDrawableFactoryImpl {
             madeCurrentES1 = false;
         }
         if( null != eglES2DynamicLookupHelper ) {
-            madeCurrentES2 = mapAvailableEGLESConfig(adevice, 2, hasPBufferES2, rendererQuirksES2, ctpES2);
+            madeCurrentES3 = mapAvailableEGLESConfig(adevice, 3, hasPBufferES3ES2, rendererQuirksES3ES2, ctpES3ES2);
+            if( madeCurrentES3 ) {
+                madeCurrentES2 = true;
+                EGLContext.mapStaticGLVersion(adevice, 2, 0, ctpES3ES2[0]);
+            } else {
+                madeCurrentES2 = mapAvailableEGLESConfig(adevice, 2, hasPBufferES3ES2, rendererQuirksES3ES2, ctpES3ES2);
+            }
         } else {
             madeCurrentES2 = false;
+            madeCurrentES3 = false;
         }
         
         if( !EGLContext.getAvailableGLVersionsSet(adevice) ) {
@@ -589,10 +628,10 @@ public class EGLDrawableFactory extends GLDrawableFactoryImpl {
         }
         if( hasX11 ) {
             handleDontCloseX11DisplayQuirk(rendererQuirksES1[0]);
-            handleDontCloseX11DisplayQuirk(rendererQuirksES2[0]);
+            handleDontCloseX11DisplayQuirk(rendererQuirksES3ES2[0]);
         }
         final SharedResource sr = new SharedResource(defaultDevice, madeCurrentES1, hasPBufferES1[0], rendererQuirksES1[0], ctpES1[0],
-                                                                    madeCurrentES2, hasPBufferES2[0], rendererQuirksES2[0], ctpES2[0]);
+                                                                    madeCurrentES2, madeCurrentES3, hasPBufferES3ES2[0], rendererQuirksES3ES2[0], ctpES3ES2[0]);
         
         synchronized(sharedMap) {
             sharedMap.put(adevice.getUniqueID(), sr);
@@ -600,7 +639,8 @@ public class EGLDrawableFactory extends GLDrawableFactoryImpl {
         if (DEBUG) {
             System.err.println("EGLDrawableFactory.createShared: devices: queried nativeTK "+QUERY_EGL_ES_NATIVE_TK+", adevice " + adevice + ", defaultDevice " + defaultDevice);
             System.err.println("EGLDrawableFactory.createShared: context ES1: " + madeCurrentES1 + ", hasPBuffer "+hasPBufferES1[0]);
-            System.err.println("EGLDrawableFactory.createShared: context ES2: " + madeCurrentES2 + ", hasPBuffer "+hasPBufferES2[0]);
+            System.err.println("EGLDrawableFactory.createShared: context ES2: " + madeCurrentES2 + ", hasPBuffer "+hasPBufferES3ES2[0]);
+            System.err.println("EGLDrawableFactory.createShared: context ES3: " + madeCurrentES3 + ", hasPBuffer "+hasPBufferES3ES2[0]);
             dumpMap();
         }
         return sr;
diff --git a/src/jogl/classes/jogamp/opengl/egl/EGLDynamicLibraryBundleInfo.java b/src/jogl/classes/jogamp/opengl/egl/EGLDynamicLibraryBundleInfo.java
index 9f4a4d2c2..778f0cb38 100644
--- a/src/jogl/classes/jogamp/opengl/egl/EGLDynamicLibraryBundleInfo.java
+++ b/src/jogl/classes/jogamp/opengl/egl/EGLDynamicLibraryBundleInfo.java
@@ -39,7 +39,7 @@ import jogamp.opengl.*;
  * Abstract implementation of the DynamicLookupHelper for EGL,
  * which decouples it's dependencies to EGLDrawable.
  *
- * Currently two implementations exist, one for ES1 and one for ES2.
+ * Currently two implementations exist, one for ES1 and one for ES3 and ES2.
  */
 public abstract class EGLDynamicLibraryBundleInfo extends GLDynamicLibraryBundleInfo {
     static final List<String> glueLibNames;
diff --git a/src/jogl/classes/jogamp/opengl/egl/EGLES2DynamicLibraryBundleInfo.java b/src/jogl/classes/jogamp/opengl/egl/EGLES2DynamicLibraryBundleInfo.java
index d83acdb6b..0d20fd4e8 100644
--- a/src/jogl/classes/jogamp/opengl/egl/EGLES2DynamicLibraryBundleInfo.java
+++ b/src/jogl/classes/jogamp/opengl/egl/EGLES2DynamicLibraryBundleInfo.java
@@ -30,6 +30,11 @@ package jogamp.opengl.egl;
 
 import java.util.*;
 
+/** 
+ * <p>
+ * Covering ES3 and ES2.
+ * </p>
+ */
 public final class EGLES2DynamicLibraryBundleInfo extends EGLDynamicLibraryBundleInfo {
     protected EGLES2DynamicLibraryBundleInfo() {
         super();
@@ -40,18 +45,33 @@ public final class EGLES2DynamicLibraryBundleInfo extends EGLDynamicLibraryBundl
         {
             final List<String> libsGL = new ArrayList<String>();
             
-            // this is the default lib name, according to the spec 
+            // ES3: This is the default lib name, according to the spec            
+            libsGL.add("libGLESv3.so.3");
+            
+            // ES3: Try these as well, if spec fails
+            libsGL.add("libGLESv3.so");            
+            libsGL.add("GLESv3");
+
+            // ES3: Alternative names
+            libsGL.add("GLES30");
+
+            // ES3: For windows distributions using the 'unlike' lib prefix
+            // where our tool does not add it.
+            libsGL.add("libGLESv3");
+            libsGL.add("libGLES30");
+            
+            // ES2: This is the default lib name, according to the spec            
             libsGL.add("libGLESv2.so.2");
             
-            // try these as well, if spec fails
+            // ES2: Try these as well, if spec fails
             libsGL.add("libGLESv2.so");            
             libsGL.add("GLESv2");
 
-            // alternative names
+            // ES2: Alternative names
             libsGL.add("GLES20");
             libsGL.add("GLESv2_CM");
 
-            // for windows distributions using the 'unlike' lib prefix
+            // ES2: For windows distributions using the 'unlike' lib prefix
             // where our tool does not add it.
             libsGL.add("libGLESv2");
             libsGL.add("libGLESv2_CM");
diff --git a/src/jogl/classes/jogamp/opengl/egl/EGLGLCapabilities.java b/src/jogl/classes/jogamp/opengl/egl/EGLGLCapabilities.java
index f857c6b5c..b61624d79 100644
--- a/src/jogl/classes/jogamp/opengl/egl/EGLGLCapabilities.java
+++ b/src/jogl/classes/jogamp/opengl/egl/EGLGLCapabilities.java
@@ -101,12 +101,16 @@ public class EGLGLCapabilities extends GLCapabilities {
     if(null == glp) {
         return true;
     }
-    if(0 != (renderableType & EGL.EGL_OPENGL_ES_BIT) && glp.usesNativeGLES1()) {
+    /** FIXME: EGLExt.EGL_OPENGL_ES3_BIT_KHR OK ? */
+    if(0 != (renderableType & EGLExt.EGL_OPENGL_ES3_BIT_KHR) && glp.usesNativeGLES3()) {
         return true;
     }
     if(0 != (renderableType & EGL.EGL_OPENGL_ES2_BIT) && glp.usesNativeGLES2()) {
         return true;
     }
+    if(0 != (renderableType & EGL.EGL_OPENGL_ES_BIT) && glp.usesNativeGLES1()) {
+        return true;
+    }
     if(0 != (renderableType & EGL.EGL_OPENGL_BIT) && !glp.usesNativeGLES()) {
         return true;
     }
diff --git a/src/jogl/classes/jogamp/opengl/macosx/cgl/MacOSXCGLContext.java b/src/jogl/classes/jogamp/opengl/macosx/cgl/MacOSXCGLContext.java
index 6b086ce44..9b163ae5b 100644
--- a/src/jogl/classes/jogamp/opengl/macosx/cgl/MacOSXCGLContext.java
+++ b/src/jogl/classes/jogamp/opengl/macosx/cgl/MacOSXCGLContext.java
@@ -52,7 +52,7 @@ import javax.media.nativewindow.OffscreenLayerSurface;
 import javax.media.nativewindow.ProxySurface;
 import javax.media.opengl.GL;
 import javax.media.opengl.GL2ES2;
-import javax.media.opengl.GL3;
+import javax.media.opengl.GL3ES3;
 import javax.media.opengl.GLCapabilities;
 import javax.media.opengl.GLCapabilitiesImmutable;
 import javax.media.opengl.GLContext;
@@ -142,7 +142,7 @@ public class MacOSXCGLContext extends GLContextImpl
 
   private static final String shaderBasename = "texture01_xxx";
   
-  private static ShaderProgram createCALayerShader(GL3 gl) {
+  private static ShaderProgram createCALayerShader(GL3ES3 gl) {
       // Create & Link the shader program
       final ShaderProgram sp = new ShaderProgram();
       final ShaderCode vp = ShaderCode.create(gl, GL2ES2.GL_VERTEX_SHADER, MacOSXCGLContext.class, 
@@ -420,12 +420,18 @@ public class MacOSXCGLContext extends GLContextImpl
   }
 
   @Override
-  public ByteBuffer glAllocateMemoryNV(int arg0, float arg1, float arg2, float arg3) {
+  public final ByteBuffer glAllocateMemoryNV(int size, float readFrequency, float writeFrequency, float priority) {
     // FIXME: apparently the Apple extension doesn't require a custom memory allocator
     throw new GLException("Not yet implemented");
   }
 
   @Override
+  public final void glFreeMemoryNV(ByteBuffer pointer) {
+    // FIXME: apparently the Apple extension doesn't require a custom memory allocator
+    throw new GLException("Not yet implemented");
+  }
+  
+  @Override
   protected final void updateGLXProcAddressTable() {
     final AbstractGraphicsConfiguration aconfig = drawable.getNativeSurface().getGraphicsConfiguration();
     final AbstractGraphicsDevice adevice = aconfig.getScreen().getDevice();
@@ -846,7 +852,7 @@ public class MacOSXCGLContext extends GLContextImpl
                   }
                   if( MacOSXCGLContext.this.isGL3core() ) {
                       if( null == gl3ShaderProgram) {
-                          gl3ShaderProgram = createCALayerShader(MacOSXCGLContext.this.gl.getGL3());
+                          gl3ShaderProgram = createCALayerShader(MacOSXCGLContext.this.gl.getGL3ES3());
                       }
                       gl3ShaderProgramName = gl3ShaderProgram.program();
                   } else {
diff --git a/src/jogl/classes/jogamp/opengl/windows/wgl/WindowsWGLContext.java b/src/jogl/classes/jogamp/opengl/windows/wgl/WindowsWGLContext.java
index 94153d96d..b8979c91e 100644
--- a/src/jogl/classes/jogamp/opengl/windows/wgl/WindowsWGLContext.java
+++ b/src/jogl/classes/jogamp/opengl/windows/wgl/WindowsWGLContext.java
@@ -563,7 +563,13 @@ public class WindowsWGLContext extends GLContextImpl {
   }
 
   @Override
-  public ByteBuffer glAllocateMemoryNV(int arg0, float arg1, float arg2, float arg3) {
-    return getWGLExt().wglAllocateMemoryNV(arg0, arg1, arg2, arg3);
+  public final ByteBuffer glAllocateMemoryNV(int size, float readFrequency, float writeFrequency, float priority) {  
+    return getWGLExt().wglAllocateMemoryNV(size, readFrequency, writeFrequency, priority);
   }
+  
+  @Override
+  public final void glFreeMemoryNV(ByteBuffer pointer) {
+    getWGLExt().wglFreeMemoryNV(pointer);
+  }
+  
 }
diff --git a/src/jogl/classes/jogamp/opengl/x11/glx/X11GLXContext.java b/src/jogl/classes/jogamp/opengl/x11/glx/X11GLXContext.java
index c37bcee50..5536ecd6a 100644
--- a/src/jogl/classes/jogamp/opengl/x11/glx/X11GLXContext.java
+++ b/src/jogl/classes/jogamp/opengl/x11/glx/X11GLXContext.java
@@ -633,11 +633,16 @@ public class X11GLXContext extends GLContextImpl {
   }
 
   @Override
-  public ByteBuffer glAllocateMemoryNV(int arg0, float arg1, float arg2, float arg3) {
-    return getGLXExt().glXAllocateMemoryNV(arg0, arg1, arg2, arg3);
+  public final ByteBuffer glAllocateMemoryNV(int size, float readFrequency, float writeFrequency, float priority) {  
+    return getGLXExt().glXAllocateMemoryNV(size, readFrequency, writeFrequency, priority);
   }
 
   @Override
+  public final void glFreeMemoryNV(ByteBuffer pointer) {
+    getGLXExt().glXFreeMemoryNV(pointer);
+  }
+    
+  @Override
   public String toString() {
     StringBuilder sb = new StringBuilder();
     sb.append(getClass().getSimpleName());
diff --git a/src/jogl/native/GLDebugMessageHandler.c b/src/jogl/native/GLDebugMessageHandler.c
index fea9d90ce..2e9d6033a 100644
--- a/src/jogl/native/GLDebugMessageHandler.c
+++ b/src/jogl/native/GLDebugMessageHandler.c
@@ -21,11 +21,11 @@
 static jmethodID glDebugMessageARB = NULL; // int source, int type, int id, int severity, String msg
 static jmethodID glDebugMessageAMD = NULL; // int id, int category, int severity, String msg
 
-typedef void (GLAPIENTRY* _local_PFNGLDEBUGMESSAGECALLBACKARBPROC) (GLDEBUGPROCARB callback, const GLvoid *userParam);
-typedef void (GLAPIENTRY* _local_GLDEBUGPROCARB)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,GLvoid *userParam);
+typedef void (APIENTRY* _local_PFNGLDEBUGMESSAGECALLBACKARBPROC) (GLDEBUGPROCARB callback, const GLvoid *userParam);
+typedef void (APIENTRY* _local_GLDEBUGPROCARB)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,GLvoid *userParam);
 
-typedef void (GLAPIENTRY* _local_PFNGLDEBUGMESSAGECALLBACKAMDPROC) (GLDEBUGPROCAMD callback, const GLvoid *userParam);
-typedef void (GLAPIENTRY* _local_GLDEBUGPROCAMD)(GLuint id,GLenum category,GLenum severity,GLsizei length,const GLchar *message,GLvoid *userParam);
+typedef void (APIENTRY* _local_PFNGLDEBUGMESSAGECALLBACKAMDPROC) (GLDEBUGPROCAMD callback, const GLvoid *userParam);
+typedef void (APIENTRY* _local_GLDEBUGPROCAMD)(GLuint id,GLenum category,GLenum severity,GLsizei length,const GLchar *message,GLvoid *userParam);
 
 /*
  * Class:     jogamp_opengl_GLDebugMessageHandler