What is the differences between OpenGL ES 2.0 and

Question

I want to know what is the differences between OpenGL ES 2.0 and OpenGL ES 3.0.

What is the main advantage of OpenGL ES 3.0?

Answer 1

I think it would be best to read section "Version 3.0 and Before -> New Features" on the official specs

And it is backward compatible with ES 2.0.

Answer 2

Overall the changes increase flexibility with bigger buffers, more formats, more uniforms, etc. Additional features such as instanced rendering, pixel buffer objects, and occlusion queries, provide opportunities for optimization. Depending on your platform it could be revolutionary, however many of the key features were already extensions on platforms such as iOS.

For my work personally, the most significant changes are:

• vertex array objects
• instanced rendering
• ETC2/EAC texture compression formats (Previously on Android each card manufacturer only supported their own texture formats)

Here is a listing of changes described in the spec linked to by Alexey:

New features in OpenGL ES 3.0 include:

• OpenGL Shading Language ES 3.00
• transform feedback 1 and 2 (with restrictions)
• uniform buffer objects including block arrays
• vertex array objects
• sampler objects
• sync objects and fences
• pixel buffer objects
• buffer subrange mapping
• buffer object to buffer object copies 314
• boolean occlusion queries, including conservative mode
• instanced rendering, via shader variable and/or vertex attribute divisor
• multiple render targets
• 2D array and 3D textures
• simplified texture storage specification
• R and RG textures
• texture swizzles
• seamless cube maps
• non-power-of-two textures with full wrap mode support and mipmapping
• texture LOD clamps and mipmap level base offset and max clamp
• at least 32 textures, at least 16 each for fragment and vertex shaders
• 16-bit (with filtering) and 32-bit (without filtering) floating-point textures
• 32-bit, 16-bit, and 8-bit signed and unsigned integer renderbuffers, textures, and vertex attributes
• 8-bit sRGB textures and framebuffers (without mixed RGB/sRGB rendering)
• 11/11/10 floating-point RGB textures
• shared exponent RGB 9/9/9/5 textures
• 10/10/10/2 unsigned normalized and unnormalized integer textures
• 10/10/10/2 signed and unsigned normalized vertex attributes
• 16-bit floating-point vertex attributes
• 8-bit-per-component signed normalized textures
• ETC2/EAC texture compression formats
• sized internal texture formats with minimum precision guarantees
• multisample renderbuffers
• 8-bit unsigned normalized renderbuffers
• depth textures and shadow comparison
• 24-bit depth renderbuffers and textures
• 24/8 depth/stencil renderbuffers and textures
• 32-bit depth and 32F/8 depth/stencil renderbuffers and textures
• stretch blits (with restrictions)
• framebuffer invalidation hints
• primitive restart with fixed index
• unsigned integer element indices with at least 24 usable bits
• draw command allowing specification of range of accessed elements
• ability to attach any mipmap level to a framebuffer object
• minimum/maximum blend equations
• program binaries, including querying binaries from linked GLSL programs
• mandatory online compiler
• non-square and transposable uniform matrices
• additional pixel store state
• indexed extension string queries

Answer 3

Straight from Wikipedia:

The OpenGL ES 3.0 specification was publicly released in August 2012. OpenGL ES 3.0 is backwards compatible with OpenGL ES 2.0, enabling applications to incrementally add new visual features to applications.

New functionality in the OpenGL ES 3.0 specification includes:

• multiple enhancements to the rendering pipeline to enable acceleration of advanced visual effects including: occlusion queries, transform feedback, instanced rendering and support for four or more rendering targets,
• high quality ETC2 / EAC texture compression as a standard feature, eliminating the need for a different set of textures for each platform,
• a new version of the GLSL ES shading language with full support for integer and 32-bit floating point operations;
• greatly enhanced texturing functionality including guaranteed support for floating point textures, 3D textures, depth textures, vertex textures, NPOT textures, R/RG textures, immutable textures, 2D array textures, swizzles, LOD and mip level clamps, seamless cube maps and sampler objects,
• an extensive set of required, explicitly sized texture and render-buffer formats, reducing implementation variability and making it much easier to write portable applications.