OpengGL ES version 2 goes a long way into changing the development paradigm that was established with OpenGL ES 1.x. You have shaders which you can chain together to apply varios effects/transforms to your elements, the projection and transformation matrices work completly different etc. I've seen a lot of online tutorials and blogs that simply say "ditch version 1.x, use version 2, that's the way to go". Even on Android's documentation it sais to "use version 2 as it may prove faster than 1.x".

Now, I've also read a book on OpenGL ES (which was rather good, but I'm not gonna mention here because I don't want to give the impression that I'm trying to make hidden publicity). The guy there treated only OpenGL ES 1.x for 80% of the book, and then at the end only listed the differences in version 2 and said something like "if OpenGL ES 1 does what you need, there's no need to switch to version 2, as it's only gonna over complicate your code. Version 2 was changed a lot to facillitate newer, fancier stuff, but if you don't need it, version 1.x is fine".

My question is then, is the last statement right? Should I always use Open GL ES version 1.x if I don't need version 2 only stuff? I'd sure like to do that, because I find coding in version 1.x A LOT simpler than version 2 but I'm afraid that my apps might get obsolete faster for using an older version.


5 Answers 5


Yes, also this is a common scenario for both desktop and mobile users, with OpenGL the fixed pipeline approach is just deprecated and when using old code on modern devices you are just guessing, because any GPU maker that wants to stick with a modern OpenGL approach is not forced to support old functions and the old approach for the pipeline.

These days you get OpenGL ES 2 capable devices from the low end market up to the high end, and the OpenGL ES 3 will come soon, adopting OpenGL ES 1.x is just an old and deprecated approach for the market of today.

OpenGL ES 2 introduces the programmable pipeline on mobile devices discarding the old fixed-pipeline approach; probably for this reason you find it more difficult to use, but just a change of mindset and some hours passed on coding will make you change your idea about this.


I disagree with user827992's answer. If you don't want or need the added complexity of OpenGL ES 2, stick with GL 1.1. When checking the facts you will see that all phones in today's market support OpenGL ES 1.1, and about 90 % support OpenGL ES 2.

Here's what Google has to say about choosing OpenGL version:
(I removed a point about compatibility as I linked to it above)

OpenGL ES API version 1.0 (and the 1.1 extensions) and version 2.0 both provide high performance graphics interfaces for creating 3D games, visualizations and user interfaces. Graphics programming for the OpenGL ES 1.0/1.1 API versus ES 2.0 differs significantly, and so developers should carefully consider the following factors before starting development with either API:

  • Performance - In general, OpenGL ES 2.0 provides faster graphics performance than the ES 1.0/1.1 APIs. However, the performance difference can vary depending on the Android device your OpenGL application is running on, due to differences in the implementation of the OpenGL graphics pipeline.
  • Coding Convenience - The OpenGL ES 1.0/1.1 API provides a fixed function pipeline and convenience functions which are not available
    in the ES 2.0 API. Developers who are new to OpenGL may find coding
    for OpenGL ES 1.0/1.1 faster and more convenient.
  • Graphics Control - The OpenGL ES 2.0 API provides a higher degree of control by providing a fully programmable pipeline through the use of shaders. With more direct control of the graphics processing pipeline, developers can create effects that would be very difficult to generate using the 1.0/1.1 API.

While performance, compatibility, convenience, control and other factors may influence your decision, you should pick an OpenGL API version based on what you think provides the best experience for your users.

So while I agree that ES 2+ is the future, there's nothing wrong about still using ES 1.1 if it fits your needs.

  • 1
    \$\begingroup\$ +1 thanks for your input. I've seen the above page myself. I think you and user827992 are both right. While OpenGL ES 1.x is not obsolete per-se, it will be, and the new version is not backwards compatible. So while I can perfectlly well use it for some short term stuff (like a game I'm planning to release in 5 months), it's bad to use it for long term projects (like if I want to make a game engine or some kind of framework on top of OpenGL ES). \$\endgroup\$ Aug 31, 2012 at 8:58
  • \$\begingroup\$ @ShivanDragon I think that's a good conclusion. :) \$\endgroup\$
    – Matsemann
    Aug 31, 2012 at 9:01

If a device supports both OpenGL ES 1.x and 2.x, it is very unlikely that there's any actual ES 1.x hardware. Which means that your ES 1.x code generates ES 2.x calls, shaders included - and the shaders most likely do stuff you don't actually need.

On the other hand, if what you're doing doesn't require a lot of performance, using ES 1.x may let you write your applications faster.

In the long term, I'd recommend using ES 2.x though.

  • \$\begingroup\$ Yes. I heard that ES 1.1 on newer devices is really executing as ES 2... thus the es 1 calls are being simulated. Meaning an abstraction layer that will slow you game down even more. It's high time to just learn es 2. :) \$\endgroup\$
    – badweasel
    Apr 28, 2013 at 0:27

Actually, the right question is: Which OpenGL ES best fits for my application needs ?

If your application just needs nice 3D graphics, without fancy and expensive effects, then OpenGL 1.1 is just enough for you. No shaders to bother! In other hand, If you need lots of special, and sometimes expensive, effects, only available through shaders, then you must go for OpenGL ES 2.0.

One drawback often omitted on the use of OpenGL ES 2.0 / 3.0 is that the lack of FFP (see below) requires the programmer to rewrite some fixed functions on shaders, as well some plain code for management. This way, developing using OpenGL ES 2.0 put a lot of pressure about developing good shaders, alongside application's 3D graphic engine. In a nutshell, to have the same visual effect, you have double work. Nevertheless, GLES 2.0 still is cool and fun.

*Fixed Function Pipeline - a set of functions used to create and manage transformations, lighting and material. Available on OpenGL ES 1.x and on desktop OpenGL 1.0 through 3.1 (today). FFP is not available on OpenGL ES 2.0 and higher.


Ha hah. I know the book you are referring to. Yes. He blabs about ES 1.1 for 80% of the book, then tries to pass off ES 2.0 as a lesser version. Sorry, but 1.1 is dead, Jim. He's wasted your time. I reckon he wrote it as a 1.1 book and when 2.0 came out he tacked it on the end. 1.1 is lower performance is depreciated. You should not be writing new code with it. If you are a new coder use 2.0.

  • \$\begingroup\$ Worst answer I've seen \$\endgroup\$
    – c_str
    May 16, 2016 at 2:01

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .