In a Nutshell: History of OpenGL

This blog post will briefly detail the history of OpenGL, a cross-platform graphics API used to create stunning visuals in 2D/3D applications. Before delving into the history of OpenGL and its profiles, it will briefly define what a graphics API is and talk about the group responsible for creating and maintaining OpenGL.

Graphics APIs

Application programming interfaces define how applications interact with the hardware components of a computer. They define a set of subroutines, protocols and tools for building application software. The main goal of an API is to abstract the underlying implementation of software and hardware and provide the developer the tools to interact with them. Graphics APIs are implemented by driver software that is written by graphics hardware vendors specifically for each hardware. They are the medium with which developers can control the dedicated graphics hardware by issuing various implementation-agnostic, higher-level commands to the software driver who in turn translates them to lower level commands for each specific hardware. The next sections of this post will talk about OpenGL, the group that created it, its history and its design philosophies.

The Khronos Group

The Khronos Group is an American, non-profit, member founded consortium of companies working together to define royalty free standards for APIs in many different fields of the industry like 3D graphics, virtual and augmented reality, parallel computing neural networks and vision processing on a wide variety of devices and platforms. Khronos was founded in 2000 by ATI Technologies, Discreet, Evans & Sutherland, Intel Corporation, NVIDIA, Silicon Graphics (SGI) and Sun Microsystems. The group now has over 100 industry-leading members across the globe including Samsung, Google, Microsoft, LG, PIXAR, hardware manufacturers like Intel, ARM, Qualcomm, AMD, NVIDIA and many gaming companies like EPIC Games, Sony Interactive Entertainment, Activision Blizzard and Nintendo. Khronos members can contribute to the development of API specifications, cast their vote at various stages before deployment of these APIs to the public and have the chance to accelerate the process of delivering those APIs to their platforms and applications by having access to early specification drafts and conformance tests.

OpenGL

The Open Graphics Library (OpenGL) is a graphics application programming interface designed to provide access to various features of the underlying graphics hardware. It is essentially a software library which provides 500 distinct commands used to specify objects, images and operations needed to create 3D graphics applications. OpenGL’s interface design aims to be streamlined and hardware-independent providing the capability of being implemented for various graphics hardware systems or, if they are not present, entirely in software while being independent of the operating system’s windowing system. Being windowing system agnostic, OpenGL does not provide any functionality to create or manage windows. Additionally, it does not provide functionality to define three-dimensional models or load image files. These functionalities fall into the responsibility of the application using OpenGL. Instead, OpenGL allows the application to define three-dimensional objects using primitives like points, lines, triangles and patches.

The History of OpenGL

OpenGL originates from Silicon Graphics Inc. (SGI) and is the evolution of SGIs proprietary graphics API named IRIS GL (Integrated Raster Imaging System Graphics Library). Silicon Graphics was a manufacturer of high-end graphics workstations. These workstations were extremely expensive and the fact that IRIS GL was a proprietary API was not helping with consumer adoption. Other companies provided less expensive solutions running on competing APIs that often offered more compatibility between workstations. SGI, in the early 1990s realized the importance of portability and decided to remove the system specific parts of IRIS GL and release it as an open standard that could be implemented by anyone with no monetary requirement. This open standard was named OpenGL and was released on June 1992 and the first version was marked as OpenGL 1.0. The same year, SGI played an instrumental role in the creation of the OpenGL Architectural Review Board (ARB), whose original members included companies like Compaq, DEC, IBM, Intel and Microsoft. As time passed, more companies joined the ARB such as Hewlett-Packard, Sun Microsystems, Evans & Sutherland and Intergraph. The OpenGL ARB is the responsible for standardizing, designing and producing the OpenGL specification and is now a part of the Khronos Group. Some of these members no longer exist and some of them have gone their own way, some exist under a new name. At the time of writing, there have been 20 OpenGL specifications released by the Khronos group.

Version	Publication Date
OpenGL 1.0	January 1992
OpenGL 1.1	January 1997
OpenGL 1.2	March 1998
OpenGL 1.2.1	October 1998
OpenGL 1.3	August 2001
OpenGL 1.4	July 2002
OpenGL 1.5	July 2003
OpenGL 2.0	September 2004
OpenGL 2.1	July 2006
OpenGL 3.0	August 2008
OpenGL 3.1	March 2009
OpenGL 3.2	August 2009
OpenGL 3.3	March 2010
OpenGL 4.0	March 2010 (simultaneous release)
OpenGL 4.1	July 2010
OpenGL 4.2	August 2011
OpenGL 4.3	August 2012
OpenGL 4.4	July 2013
OpenGL 4.5	August 2014
OpenGL 4.6	July 2017

OpenGL Profiles

OpenGL has been developed for over 26 years and that is a significant amount of time in the development of cutting-edge technology. Back in 1992 the best Intel CPU was the 80486 and math coprocessors were an optional component. Apple computers were using Motorola 68K-derived processors and PowerPC processors were not available until the second half of 1992. Home personal computers did not have any kind of high-performance hardware graphics acceleration. The only way to access this rare luxury and be able to use OpenGL was through an expensive workstation. The state of the art in graphics was using software rendering. The best that could be achieved without hardware acceleration was a small amount of simple colored, filled polygons.

As time passed, the prices of graphics hardware declined, and their performance increased. Furthermore, new features were added to the now low-cost graphics processors which in turn were added to the OpenGL specifications as well. Those extra features were initially added to OpenGL as extensions which were proposed by members of the OpenGL ARB. Some of these extensions interacted well with each other and with already existing feature of OpenGL and some did not. Moreover, as newer ways of taking advantage of the GPU were invented they were added in OpenGL as well, resulting in having multiple ways available to do the same thing.

Backwards compatibility was and is important and strongly supported by the OpenGL ARB, however, it comes at a significant cost. The best practices in the field of computer graphics have changed and what may have worked well in the past doesn’t always fit the modern GPU architecture. Defining how new features and techniques must interact with legacy features is hard and many times defining new features cleanly and adding them to OpenGL is almost impossible. On the implementation side, drivers tend to have more bugs than they should, and this costs graphics hardware manufacturers lots of valuable time and energy to maintain support for legacy features that do not help advance or innovate the field of computer graphics. For all the above reasons, in 2008, the OpenGL ARB decided to separate the OpenGL specification into two profiles, core and compatibility. The core profile is the modern profile of OpenGL. It removes many legacy features keeping only those that are truly accelerated by the current GPUs. As a result, the core profile’s specification is significantly smaller than its counterpart’s, the compatibility profile.

The compatibility profile’s purpose and reason of existence is to allow developers to maintain legacy graphics applications and improve them by adding features without having to discard years of work by using a new API. At the same time the compatibility profile makes those legacy applications run with greatly increased performance when compiled for a modern GPU. Despite this fact, OpenGL experts suggest using the modern core profile to develop new graphics applications. On some platforms the newer features of OpenGL are available only if the core profile is used. On other occasions, the application will run faster by using the core profile than requesting the compatibility profile and using only core profile features. The removal of features from the core profile is backed by viable reasons. It is logical for these features to be considered deprecated and avoid their use.

References

• Kessenich, J., Sellers, G. & Shreiner, D., 2016. OpenGL Programming Guide, The official Guide to Learning OpenGL, Version 4.5 with SPIR-V. 9th ed. s.l.:Addison-Wesley Professional.

• Sellers, G., Wright, R. S. & Haemel, N., 2015. OpenGL Superbible, Comprehensive Tutorial and Reference. 7th ed. s.l.:Addison-Wesley Professional.

• Samsung Electronics, 2018. What Is a Graphics API?

• Wikipedia, 2018. Application programming interface.