| OpenGL | |
|---|---|
 | |
 A diagram of howvideo games onLinux outsource real-time rendering calculations to aGPU using OpenGL. | |
| Original author | Silicon Graphics |
| Developers | Khronos Group (formerlyARB) |
| Initial release | June 30, 1992; 33 years ago (1992-06-30) |
| Stable release | |
| Written in | C[2] |
| Successor | Vulkan |
| Type | 3D graphicsAPI |
| License |
|
| Website | opengl.org |
OpenGL (Open Graphics Library[4]) is across-language,cross-platformapplication programming interface (API) for rendering2D and3Dvector graphics. The API is typically used to interact with agraphics processing unit (GPU), to achievehardware-acceleratedrendering.
Silicon Graphics, Inc. (SGI) began developing OpenGL in 1991 and released it on June 30, 1992.[5][6] It is used for a variety of applications, includingcomputer-aided design (CAD),video games,scientific visualization,virtual reality, andflight simulation. Since 2006, OpenGL has been managed by thenon-profit technologyconsortiumKhronos Group.[7]
The OpenGL specification describes an abstractapplication programming interface (API) for drawing 2D and 3D graphics. It is designed to be implemented mostly or entirely usinghardware acceleration such as aGPU, although it is possible for the API to be implemented entirely in software running on aCPU.
The API is defined as a set offunctions which may be called by the client program, alongside a set ofnamed integer constants (for example, the constant GL_TEXTURE_2D, which corresponds to thedecimal number 3553). Although the function definitions are superficially similar to those of the programming languageC, they are language-independent. As such, OpenGL has manylanguage bindings, some of the most noteworthy being theJavaScript bindingWebGL (API, based onOpenGL ES 2.0, for 3D rendering from within aweb browser); the C bindingsWGL,GLX andCGL; the C binding provided byiOS; and theJava and C bindings provided byAndroid.
In addition to being language-independent, OpenGL is also cross-platform. The specification says nothing on the subject of obtaining and managing an OpenGL context, leaving this as a detail of the underlyingwindowing system. For the same reason, OpenGL is purely concerned with rendering, providing no APIs related to input, audio, or windowing.
New versions of the OpenGL specifications are released by the Khronos Group, each of which extends the API to support various new features. The details of each version are decided by consensus between the Group's members, including graphics card manufacturers, operating system designers, and general technology companies such asMozilla andGoogle.[8]
In addition to the features required by the core API,graphics processing unit (GPU) vendors may provide additional functionality in the form ofextensions. Extensions may introduce new functions and new constants, and may relax or remove restrictions on existing OpenGL functions. Vendors can use extensions to expose custom APIs without needing support from other vendors or the Khronos Group as a whole, which greatly increases the flexibility of OpenGL. All extensions are collected in, and defined by, the OpenGL Registry.[9]
The features introduced by each new version of OpenGL are typically formed from the combined features of several widely implemented extensions, especially extensions of type ARB or EXT.[citation needed]
OpenGL is no longer in active development; whereas between 2001 and 2014, OpenGL specification was updated mostly on a yearly basis, with two releases (3.1 and 3.2) taking place in 2009 and three (3.3, 4.0 and 4.1) in 2010. The latest OpenGL specification 4.6 was released in 2017 after a three-year break, and was limited to inclusion of eleven existing ARB and EXT[a] extensions into the core profile.[11]
Active development of OpenGL was dropped in favor of theVulkan API, released in 2016, and codenamed glNext during initial development. In 2017,Khronos Group announced that OpenGL ES would not have new versions[12][13] and has since concentrated on development of Vulkan and other technologies.[14][15] As a result, certain capabilities offered by modern GPUs, e.g.ray tracing, are not supported by the OpenGL standard. However, support for newer features might be provided through the vendor-specific OpenGL extensions.[16][17]
The OpenGL Architecture Review Board released a series of manuals along with the specification which have been updated to track changes in the API. These are commonly referred to by the colors of their covers:
Historic books (pre-OpenGL 2.0):
OpenGL's documentation is also accessible via its official webpage.[18]
The earliest versions of OpenGL were released with a companion library called theOpenGL Utility Library (GLU). It provided simple, useful features which were unlikely to be supported in contemporary hardware, such astessellating, and generatingmipmaps andprimitive shapes. The GLU specification was last updated in 1998 and depends on OpenGL features which are nowdeprecated.
Given that creating an OpenGL context is quite a complex process, and given that it varies betweenoperating systems, automatic OpenGL context creation has become a common feature of several game-development and user-interfacelibraries, includingSDL,Allegro,SFML,FLTK, andQt. A few libraries have been designed solely to produce an OpenGL-capable window. The first such library wasOpenGL Utility Toolkit (GLUT), later superseded byfreeglut.GLFW is a newer alternative.[19]
Given the high workload involved in identifying and loading OpenGL extensions, a few libraries have been designed which load all available extensions and functions automatically. Examples include OpenGL Easy Extension library (GLEE), OpenGL Extension Wrangler Library (GLEW) andglbinding. Extensions are also loaded automatically by most language bindings, such asJava OpenGL, PyOpenGL andWebGL.[citation needed]
glxinfo, showing information of Mesa implementation of OpenGL on a system andglxgears, a program to test OpenGL implementation on a systemMesa 3D is anopen-source implementation of OpenGL. It can do pure software rendering, and it may also use hardware acceleration onBSD,Linux, and other platforms by taking advantage of theDirect Rendering Infrastructure. As of version 20.0, it implements version 4.6 of the OpenGL standard.[citation needed]
In the 1980s, developing software that could function with a wide range of graphics hardware was a challenge without a cross-platform library. Software developers wrote custom interfaces and drivers for each piece of hardware. This was expensive and resulted in multiplication of effort.[citation needed]
By the early 1990s,Silicon Graphics (SGI) was a leader in 3D graphics for workstations. TheirIRIS GL API[21][22] became the industry standard, as IRIS GL was considered easier to use,[by whom?] and it supportedimmediate mode rendering, therefore being faster[23] than competitors likePHIGS.
SGI's competitors (includingSun Microsystems,Hewlett-Packard andIBM) were also able to bring to market 3D hardware supported by extensions made to the PHIGS standard, which pressured SGI to open source a version of IRIS GL as a public standard calledOpenGL.
However, SGI had many customers for whom the change from IRIS GL to OpenGL would demand significant investment. Moreover, IRIS GL had API functions that were irrelevant to 3D graphics. For example, it included a windowing, keyboard and mouse API, in part because it was developed before theX Window System and Sun'sNeWS.[24] IRIS GL libraries were heavily tied into SGI's proprietary graphics hardware and could not be open sourced as-is due to hardware patents and trade secrets. These factors required SGI to continue to support the advanced and proprietaryIris Inventor andIris Performer programming APIs while market support for OpenGL matured.
One of the restrictions of IRIS GL was that it only provided access to features supported by the underlying hardware. If the graphics hardware did not support a feature natively, then the application could not use it. OpenGL overcame this problem by providing software implementations of features unsupported by hardware, allowing applications to use advanced graphics on relatively low-powered systems. OpenGL standardized access to hardware, pushed the development responsibility of hardware interface programs (device drivers) to hardware manufacturers, and delegated windowing functions to the underlying operating system. With so many different kinds of graphics hardware, getting them all to speak the same language in this way had a remarkable impact by giving software developers a higher-level platform for 3D-software development.
In 1992,[25] SGI led the creation of theOpenGL Architecture Review Board (OpenGL ARB), the group of companies that would maintain and expand the OpenGL specification in the future. Two years later, they also played with the idea of releasing something called "OpenGL++" which included elements such as a scene-graph API (presumably based on theirPerformer technology). The specification was circulated among a few interested parties – but never turned into a product.[26]
Released in 1996,Microsoft'sDirect3D eventually became the main competitor of OpenGL. Over 50 game developers signed anopen letter to Microsoft, released on June 12, 1997, calling on the company to actively support OpenGL.[27] On December 17, 1997,[28] Microsoft and SGI initiated theFahrenheit project, which was a joint effort with the goal of unifying the OpenGL and Direct3D interfaces (and adding a scene-graph API too). In 1998, Hewlett-Packard joined the project.[29] It initially showed some promise of bringing order to the world of interactive 3D computer graphics APIs, but on account of financial constraints at SGI, strategic reasons at Microsoft, and a general lack of industry support, it was abandoned in 1999.[30]
In July 2006, the OpenGL Architecture Review Board voted to transfer control of the OpenGL API standard to the Khronos Group.[31][32]
![[icon]](/mt/?noimg=&dark=on&url=http%3a%2f%2fen.m.wikipedia.org%2fwiki%2fFile%3aWiki_letter_w_cropped.svg) | This sectionneeds expansion with: more historical background when support was being added. You can help byadding missing information.(January 2023) |
Despite the emergence of newer graphics APIs like its successor Vulkan or Metal, OpenGL continues to be a widely used standard. This continued relevance is supported by several factors: ongoing development with new extensions and driver optimizations, its cross-platform compatibility, and the availability of compatibility layers likeANGLE and Zink. These layers allow OpenGL to run efficiently on top of Vulkan and Metal, offering a pathway for continued use or gradual transitions for developers.[33][34][better source needed]
However, the graphics API landscape has been shifting, where some companies are moving away from OpenGL. Back in June 2018,Apple has deprecated OpenGL APIs on all of their platforms (iOS,macOS andtvOS), strongly encouraging developers to use their proprietaryMetal API, which was introduced in 2014.[35]
Game developers have also begun to adopt newer APIs.id Software, who has been using OpenGL in their games since the late 1990s in games such asGLQuake[36] or some games of theDoom franchise,[37] transitioned away to its successor Vulkan in itsid Tech 7 engine in 2016.[38] They first supported Vulkan in an update for theirid Tech 6 engine. The company's first licensed use of OpenGL was in itsQuake II engine, also known asid Tech 2.[39] In March 2023,Valve removed OpenGL support fromDota 2 in favor of Vulkan.[40] Atypical Games, with support from Samsung, updated their game engine to use Vulkan, rather than OpenGL, across all non-Apple platforms.[41]
TheKhronos Group, the consortium responsible for OpenGL's development, has stopped updating OpenGL with the last release made in 2017.[42] It has not received a number of modern graphics technologies, such as hardware acceleratedRay Tracing, on-GPU video decoding, and advancedanti-aliasingalgorithmslikeNvidia DLSS[43] andAMD FSR[44] In 2025 a cross-vendor OpenGLMesh Shader Extension was released, which was motivated partly by the Nividum project.[45][46][47]
Google'sFuchsia OS, while using Vulkan natively and requiring a Vulkan-conformant GPU, still intends to support OpenGL on top of Vulkan via the ANGLE translation layer.[48]
The first version of OpenGL, version 1.0, was released on June 30, 1992, by Mark Segal andKurt Akeley. Since then, OpenGL has occasionally been extended by releasing a new version of the specification. Such releases define a baseline set of features which all conforming graphics cards must support, and against which new extensions can more easily be written. Each new version of OpenGL tends to incorporate several extensions which have widespread support among graphics-card vendors, although the details of those extensions may be changed.
| Version | Release Date | Features |
|---|---|---|
| 1.0 | June 30, 1992 | Initial release. |
| 1.1 | March 4, 1997[49][50] | Texture objects, Vertex Arrays |
| 1.2 | March 16, 1998 | 3D textures, BGRA andpacked pixel formats,[51] introduction of theimaging subset useful to image-processing applications |
| 1.2.1 | October 14, 1998 | A concept of ARB extensions |
| 1.3 | August 14, 2001 | Multitexturing, multisampling,texture compression |
| 1.4 | July 24, 2002 | Depth textures, GLSlang[52] |
| 1.5 | July 29, 2003 | Vertex Buffer Object (VBO), Occlusion Queries[53] |
| 2.0 | September 7, 2004 | GLSL 1.1,MRT, Non Power of Two textures, Point Sprites,[54] Two-sided stencil[53] |
| 2.1 | July 2, 2006 | GLSL 1.2, Pixel Buffer Object (PBO), sRGB Textures[53] |
| 3.0 | August 11, 2008 | GLSL 1.3, Texture Arrays, Conditional rendering, Frame Buffer Object (FBO)[55] |
| 3.1 | March 24, 2009 | GLSL 1.4, Instancing, Texture Buffer Object, Uniform Buffer Object, Primitive restart[56] |
| 3.2 | August 3, 2009 | GLSL 1.5, Geometry Shader, Multi-sampled textures[57] |
| 3.3 | March 11, 2010 | GLSL 3.30, Retain as much OpenGL 4.0 functionality as possible, New blending functions, Sampler Objects, new texture and vertex formats |
| 4.0 | March 11, 2010 | GLSL 4.00, Tessellation on GPU, shaders with 64-bit precision[58] |
| 4.1 | July 26, 2010 | GLSL 4.10, Developer-friendly debug outputs,[b] compatibility with OpenGL ES 2.0[59] |
| 4.2 | August 8, 2011[60] | GLSL 4.20, Shaders with atomic counters, draw transform feedback instanced, shader packing, performance improvements |
| 4.3 | August 6, 2012[61] | GLSL 4.30, Compute shaders leveraging GPU parallelism, shader storage buffer objects, high-quality ETC2/EAC texture compression, increased memory security, a multi-application robustness extension, compatibility with OpenGL ES 3.0[62] |
| 4.4 | July 22, 2013[63] | GLSL 4.40, Buffer Placement Control, Efficient Asynchronous Queries, Shader Variable Layout, Efficient Multiple Object Binding, Streamlined Porting of Direct3D applications, Bindless Texture Extension, Sparse Texture Extension[63] |
| 4.5 | August 11, 2014[9][64] | GLSL 4.50, Direct State Access (DSA), Flush Control, Robustness, OpenGL ES 3.1 API and shader compatibility, DX11 emulation features |
| 4.6 | July 31, 2017[11][65] | GLSL 4.60, More efficient geometry processing and shader execution, more information, no error context, polygon offset clamp, SPIR-V, anisotropic filtering |
Release date: September 7, 2004
OpenGL 2.0 was originally conceived by3Dlabs to address concerns that OpenGL was stagnating and lacked a strong direction.[66] 3Dlabs proposed a number of major additions to the standard. Most of these were, at the time, rejected by the ARB or otherwise never came to fruition in the form that 3Dlabs proposed. However, their proposal for a C-style shading language was eventually completed, resulting in the current formulation of the OpenGL Shading Language (GLSL or GLslang). Like the assembly-like shading languages it was replacing, it allowed replacing the fixed-function vertex and fragment pipe withshaders, though this time written in a C-like high-level language.
The design of GLSL was notable for making relatively few concessions to the limits of the hardware then available. This harked back to the earlier tradition of OpenGL setting an ambitious, forward-looking target for 3D accelerators rather than merely tracking the state of currently available hardware. The final OpenGL 2.0 specification[67] includes support for GLSL 1.10.
Release date: July 2, 2006
OpenGL 2.1 adds support for Pixel Buffer Objects, sRGB textures and GLSL 1.20.
Before the release of OpenGL 3.0, the new revision had the codenameLongs Peak. At the time of its original announcement, Longs Peak was presented as the first major API revision in OpenGL's lifetime. It consisted of an overhaul to the way that OpenGL works, calling for fundamental changes to the API.
The draft introduced a change to object management. The GL 2.1 object model was built upon the state-based design of OpenGL. That is, to modify an object or to use it, one needs to bind the object to the state system, then make modifications to the state or perform function calls that use the bound object.
Because of OpenGL's use of a state system, objects must be mutable. That is, the basic structure of an object can change at any time, even if the rendering pipeline is asynchronously using that object. A texture object can be redefined from 2D to 3D. This requires any OpenGL implementations to add a degree of complexity to internal object management.
Under the Longs Peak API, object creation would becomeatomic, using templates to define the properties of an object which would be created with one function call. The object could then be used immediately across multiple threads. Objects would also be immutable; however, they could have their contents changed and updated. For example, a texture could change its image, but its size and format could not be changed.
To support backwards compatibility, the old state based API would still be available, but no new functionality would be exposed via the old API in later versions of OpenGL. This would have allowed legacy code bases, such as the majority ofCAD products, to continue to run while other software could be written against or ported to the new API.
Longs Peak was initially due to be finalized in September 2007 under the name OpenGL 3.0, but the Khronos Group announced on October 30 that it had run into several issues that it wished to address before releasing the specification.[68] As a result, the spec was delayed, and the Khronos Group went into amedia blackout until the release of the final OpenGL 3.0 spec.
The final specification proved far less revolutionary than the Longs Peak proposal. Instead of removing all immediate mode and fixed functionality (non-shader mode), the spec included them as deprecated features. The proposed object model was not included, and no plans have been announced to include it in any future revisions. As a result, the API remained largely the same with a few existing extensions being promoted to core functionality. Among some developer groups this decision caused something of an uproar,[69] with many developers professing that they would switch toDirectX in protest. Most complaints revolved around the lack of communication by Khronos to the development community and multiple features being discarded that were viewed favorably by many. Other frustrations included the requirement of DirectX 10 level hardware to use OpenGL 3.0 and the absence of geometry shaders and instanced rendering as core features.
Other sources reported that the community reaction was not quite as severe as originally presented,[70] with many vendors showing support for the update.[71][72]
Release date: August 11, 2008
OpenGL 3.0 introduced a deprecation mechanism to simplify future revisions of the API. Certain features, marked as deprecated, could be completely disabled by requesting aforward-compatible context from the windowing system. OpenGL 3.0 features could still be accessed alongside these deprecated features, however, by requesting afull context.
Deprecated features include:
Hardware support: NvidiaGeForce 8 Series and newer, ATIRadeon HD 2000 series and newer,Intel HD Graphics in IntelSandy Bridge processors and newer.
Release date: March 24, 2009
OpenGL 3.1 fully removed all of the features which were deprecated in version 3.0, with the exception of wide lines. From this version onwards, it's not possible to access new features using afull context, or to access deprecated features using aforward-compatible context. An exception to the former rule is made if the implementation supports theARB_compatibility extension, but this is not guaranteed. Includes support for GLSL 1.40.
Hardware support: Mesa supports ARM Panfrost with Version 21.0.
Release date: August 3, 2009
OpenGL 3.2 further built on the deprecation mechanisms introduced by OpenGL 3.0, by dividing the specification into acore profile andcompatibility profile. Compatibility contexts include the previously removed fixed-function APIs, equivalent to the ARB_compatibility extension released alongside OpenGL 3.1, while core contexts do not. OpenGL 3.2 also included an upgrade to GLSL version 1.50.
Release date: March 11, 2010
OpenGL 3.3 includes minor additions, with the goal of retaining as much functionality as possible from OpenGL 4.0, while keeping support for older hardware.[58] Additions include new blending functions, Sampler Objects and new texture and vertex formats. Support is also added for GLSL version 3.30, major and minor versions now match with OpenGL.
Release date: March 11, 2010
OpenGL 4.0 was released alongside version 3.3.[58] It was designed for hardware able to support Direct3D 11.
As in OpenGL 3.0, this version of OpenGL contains a high number of fairly inconsequential extensions, designed to thoroughly expose the abilities of Direct3D 11-class hardware, such as tessellation.
Hardware support: NvidiaGeForce 400 series and newer, AMDRadeon HD 5000 series and newer (FP64 shaders implemented by emulation on some TeraScale GPUs),Intel HD Graphics in IntelIvy Bridge processors and newer.[73]
Release date: July 26, 2010
Hardware support: NvidiaGeForce 400 series and newer, AMDRadeon HD 5000 series and newer (FP64 shaders implemented by emulation on some TeraScale GPUs),Intel HD Graphics in IntelHaswell processors and newer[73] (Linux Mesa: Ivy Bridge and newer). Additionally, this is the last core profile supported by Apple macOS.
Release date: August 8, 2011[60]
Hardware support: NvidiaGeForce 400 series and newer, AMDRadeon HD 5000 series and newer (FP64 shaders implemented by emulation on some TeraScale GPUs), andIntel HD Graphics in IntelHaswell processors and newer.[73] (Linux Mesa: Ivy Bridge and newer)
Release date: August 6, 2012[61]
Hardware support: AMDRadeon HD 5000 series and newer (FP64 shaders implemented by emulation on some TeraScale GPUs),Intel HD Graphics in IntelHaswell processors and newer.[73] (Linux Mesa: Ivy Bridge without stencil texturing, Haswell and newer), NvidiaGeForce 400 series and newer. VIRGL Emulation for virtual machines supports 4.3+ with Mesa 20.
Release date: July 22, 2013[63]
Hardware support: AMDRadeon HD 5000 series and newer (FP64 shaders implemented by emulation on some TeraScale GPUs),Intel HD Graphics in IntelBroadwell processors and newer (Linux Mesa: Haswell and newer),[77] NvidiaGeForce 400 series and newer,[78]Tegra K1.
Release date: August 11, 2014[9][64]
Hardware support: AMDRadeon HD 5000 series and newer (FP64 shaders implemented by emulation on some TeraScale GPUs),Intel HD Graphics in IntelBroadwell processors and newer (Linux Mesa: Haswell and newer), NvidiaGeForce 400 series and newer,[78]Tegra K1, and Tegra X1.[80][81]
Release date: July 31, 2017[9][11][65]
Hardware support: AMDRadeon HD 7000 series and newer (FP64 shaders implemented by emulation on some TeraScale GPUs), IntelSkylake and newer, NvidiaGeForce 400 series and newer.[78]
Driver support:
Appledeprecated OpenGL in iOS 12 and macOS 10.14 Mojave in favor ofMetal, but it is still available as ofmacOS 14 Sonoma (including onApple silicon devices).[89] The latest version supported for OpenGL is 4.1 from 2011.[90][91] A proprietary library from Molten – authors ofMoltenVK – called MoltenGL, can translate OpenGL calls to Metal.[92]
There are several projects that attempt to implement OpenGL on top of Vulkan. The Vulkan backend for Google'sANGLE achieved OpenGL ES 3.1 conformance in July 2020.[93] TheMesa3D project also includes such a driver, calledZink.[94]
Microsoft'sWindows 11 on Arm added support for OpenGL 3.3 via GLon12, an open source OpenGL implementation on top DirectX 12 viaMesa Gallium.[95][96][97]
Vulkan, formerly named the "Next Generation OpenGL Initiative" (glNext),[98][99] is a ground-up redesign effort to unify OpenGL and OpenGL ES into one common API that will not be backwards compatible with existing OpenGL versions.[100][101][102]
The initial version of Vulkan API was released on February 16, 2016.
