OpenGL#OpenGL 1.2

File:Pipeline OpenGL.svg

The OpenGL specification describes an abstract application programming interface (API) for drawing 2D and 3D graphics. It is designed to be implemented mostly or entirely using hardware acceleration such as a GPU, although it is possible for the API to be implemented entirely in software running on a CPU.

The API is defined as a set of functions which may be called by the client program, alongside a set of named integer constants (for example, the constant GL_TEXTURE_2D, which corresponds to the decimal number 3553). Although the function definitions are superficially similar to those of the programming language C, they are language-independent. As such, OpenGL has many language bindings, some of the most noteworthy being the JavaScript binding WebGL (API, based on OpenGL ES 2.0, for 3D rendering from within a web browser); the C bindings WGL, GLX and CGL; the C binding provided by iOS; and the Java and C bindings provided by Android.

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 underlying windowing system. For the same reason, OpenGL is purely concerned with rendering, providing no APIs related to input, audio, or windowing.

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{{efn|name=extension identifiers|

ARB and EXT are OpenGL extension identifiers. Each extension is associated with a short identifier based on the name of the company which developed it, e.g. NV for Nvidia. If multiple vendors agree to implement the same functionality using the same API, a shared extension may be released using the identifier EXT. In such cases, it could also happen that the Khronos Group's Architecture Review Board gives the extension their explicit approval, in which case the identifier ARB is used.{{cite web|url=https://khronos.org/registry/OpenGL/docs/rules.html |title=How to Create Khronos API Extensions |publisher=Khronos Group |access-date=July 31, 2017}}

}} extensions into the core profile.

Active development of OpenGL was dropped in favor of the Vulkan API, released in 2016, and codenamed glNext during initial development. In 2017, Khronos Group announced that OpenGL ES would not have new versions{{cite web|title=Vulkan, OpenGL, and OpenGL ES SIGGRAPH 2017: No plan for new core version for OpenGL ES|url=https://www.khronos.org/assets/uploads/developers/library/2017-siggraph/06_3D-BOF-SIGGRAPH_Aug17.pdf |website=Khronos Group|date=2017}}

{{cite web|title=The Future of OpenGL (forum discussion)|url=https://community.khronos.org/t/the-future-of-opengl/106317|website=Khronos Group|date=2020}} and has since concentrated on development of Vulkan and other technologies.{{cite web|title=Khronos News Archives|url=https://www.khronos.org/news/archives|website=Khronos Group|date=November 28, 2022 }}{{cite web|title=Khronos Blog|url=https://www.khronos.org/blog/|website=Khronos Group|date=November 28, 2022 }} 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.{{cite web|title=GLSL_NV_ray_tracing|website=GitHub |url=https://github.com/KhronosGroup/GLSL/blob/main/extensions/nv/GLSL_NV_ray_tracing.txt}}{{cite web|title=GL_NV_mesh_shader|website=GitHub |url=https://github.com/KhronosGroup/OpenGL-Registry/blob/main/extensions/NV/NV_mesh_shader.txt}}

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 as Mozilla and Google.{{cite web|url=http://www.khronos.org/members/ |title=Khronos Membership Overview and FAQ |publisher=Khronos.org |access-date=November 7, 2012}}

In addition to the features required by the core API, graphics processing unit (GPU) vendors may provide additional functionality in the form of extensions. 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.{{cite web|url=https://khronos.org/registry/OpenGL/index_gl.php |title=Khronos OpenGL Registry |publisher=Khronos Group |access-date=July 31, 2017}}

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.

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:

;The Red Book

:OpenGL Programming Guide, 9th Edition. {{ISBN|978-0-134-49549-1}}

:The Official Guide to Learning OpenGL, Version 4.5 with SPIR-V

;The Orange Book

:OpenGL Shading Language, 3rd edition. {{ISBN|0-321-63763-1}}

:A tutorial and reference book for GLSL.

Historic books (pre-OpenGL 2.0):

;The Green Book

:OpenGL Programming for the X Window System. {{ISBN|978-0-201-48359-8}}

:A book about X11 interfacing and OpenGL Utility Toolkit (GLUT).

;The Blue Book

:OpenGL Reference manual, 4th edition. {{ISBN|0-321-17383-X}}

:Essentially a hard-copy printout of the Unix manual (man) pages for OpenGL.

:Includes a poster-sized fold-out diagram showing the structure of an idealised OpenGL implementation.

;The Alpha Book (white cover)

:OpenGL Programming for Windows 95 and Windows NT. {{ISBN|0-201-40709-4}}

:A book about interfacing OpenGL with Microsoft Windows.

OpenGL's documentation is also accessible via its official webpage.{{Cite web|date=July 19, 2011|title=OpenGL - The Industry's Foundation for High Performance Graphics|url=https://www.khronos.org/opengl/|access-date=March 18, 2021|website=The Khronos Group|language=en}}

The earliest versions of OpenGL were released with a companion library called the OpenGL Utility Library (GLU). It provided simple, useful features which were unlikely to be supported in contemporary hardware, such as tessellating, and generating mipmaps and primitive shapes. The GLU specification was last updated in 1998 and depends on OpenGL features which are now deprecated.

Given that creating an OpenGL context is quite a complex process, and given that it varies between operating systems, automatic OpenGL context creation has become a common feature of several game-development and user-interface libraries, including SDL, Allegro, SFML, FLTK, and Qt. A few libraries have been designed solely to produce an OpenGL-capable window. The first such library was OpenGL Utility Toolkit (GLUT), later superseded by freeglut. GLFW is a newer alternative.{{cite web|url=https://www.opengl.org/resources/libraries/windowtoolkits/ |title=A list of GLUT alternatives, maintained by |publisher=Khronos Group |access-date=May 2, 2013}}

• These toolkits are designed to create and manage OpenGL windows, and manage input, but little beyond that.{{cite web|title=Related toolkits and APIs|url=https://www.opengl.org/wiki/Related_toolkits_and_APIs#Context.2FWindow_Toolkits|website=www.opengl.org|publisher=OpenGL|access-date=October 8, 2014}}

:* GLFW – A cross-platform windowing and keyboard-mouse-joystick handler; is more game-oriented

:* freeglut – A cross-platform windowing and keyboard-mouse handler; its API is a superset of the GLUT API, and it is more stable and up to date than GLUT

:* OpenGL Utility Toolkit (GLUT) – An old windowing handler, no longer maintained.

• Several "multimedia libraries" can create OpenGL windows, in addition to input, sound and other tasks useful for game-like applications

:* Allegro 5 – A cross-platform multimedia library with a C API focused on game development

:* Simple DirectMedia Layer (SDL) – A cross-platform multimedia library with a C API

:* SFML – A cross-platform multimedia library with a C++ API and multiple other bindings to languages such as C#, Java, Haskell, and Go

• Widget toolkits

:* FLTK – A small cross-platform C++ widget library

:* Qt – A cross-platform C++ widget toolkit. It provides many OpenGL helper objects, which even abstract away the difference between desktop GL and OpenGL ES

:* wxWidgets – A cross-platform C++ widget toolkit

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) and glbinding. Extensions are also loaded automatically by most language bindings, such as Java OpenGL, PyOpenGL and WebGL.

File:Glxinfo with glxgears screenshot.png

Mesa 3D is an open-source implementation of OpenGL. It can do pure software rendering, and it may also use hardware acceleration on BSD, Linux, and other platforms by taking advantage of the Direct Rendering Infrastructure. As of version 20.0, it implements version 4.6 of the OpenGL standard.

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.

By the early 1990s, Silicon Graphics (SGI) was a leader in 3D graphics for workstations. Their IRIS GL API{{cite web|url=http://www.cg.tuwien.ac.at/~wimmer/apis/API_Summary.html|title= IRIS GL, SGI's property}}{{cite web|author=Kilgard, Mark|url=https://www.slideshare.net/Mark_Kilgard/sigraph-asia-2008-modern-opengl-presentation/13-13OpenGLs_PrehistoryIRIS_GL_1Window_system|title=OpenGL Prehistory: IRIS GL (slide)|website=www.slideshare.net|year=2008}} became the industry standard, as IRIS GL was considered easier to use,{{By whom|date=March 2021}} and it supported immediate mode rendering, therefore being faster{{cite web |title=Preface: What is OpenGL? |url=https://openglbook.com/chapter-0-preface-what-is-opengl.html |website=OpenGLBook |access-date=31 December 2024}} than competitors like PHIGS.

SGI's competitors (including Sun Microsystems, Hewlett-Packard and IBM) 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 called OpenGL.

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 the X Window System and Sun's NeWS. IRIS GL libraries also were unsuitable for opening due to licensing and patent issues{{Explain|reason=What patent issues?|date=September 2016}}. These factors required SGI to continue to support the advanced and proprietary Iris Inventor and Iris 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,{{cite web|url=http://www.sgi.com/company_info/newsroom/press_releases/2004/august/opengl.html|title=Creation of the OpenGL ARB|access-date=February 16, 2007|archive-url=https://web.archive.org/web/20070222123208/http://www.sgi.com/company_info/newsroom/press_releases/2004/august/opengl.html|archive-date=February 22, 2007|url-status=dead}} SGI led the creation of the OpenGL 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 their Performer technology). The specification was circulated among a few interested parties – but never turned into a product.{{cite web|url=https://www.opengl.org/archives/about/arb/meeting_notes/notes/Meeting1.2/meeting_note_10-03-98.html|title=End of OpenGL++|publisher=Khronos Group}}

Released in 1996, Microsoft's Direct3D eventually became the main competitor of OpenGL. Over 50 game developers signed an open letter to Microsoft, released on June 12, 1997, calling on the company to actively support OpenGL.{{cite magazine |title=Top Game Developers Call on Microsoft to Actively Support OpenGL |magazine=Next Generation|issue=32|publisher=Imagine Media |date=August 1997|page=17 |url=https://archive.org/details/NEXT_Generation_32/page/n18}} On December 17, 1997,{{cite web|url=http://www.windowsitpro.com/Article/ArticleID/17533/17533.html|title=Announcement of Fahrenheit|url-status=dead |archive-url=https://web.archive.org/web/20070927212603/http://www.windowsitpro.com/Article/ArticleID/17533/17533.html|archive-date=September 27, 2007}} Microsoft and SGI initiated the Fahrenheit 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.{{cite news|url=http://www.findarticles.com/p/articles/mi_m0CGN/is_n3341/ai_20211297 |archive-url=https://web.archive.org/web/20071005013207/http://findarticles.com/p/articles/mi_m0CGN/is_n3341/ai_20211297 |url-status=dead |archive-date=October 5, 2007 |title=Members of Fahrenheit. 1998. |work=Computergram International |year=1998 }} 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.{{cite web|url=https://www.theregister.co.uk/1999/11/29/ms_quietly_dumps_windows_opengl/|title=End of Fahrenheit|website=The Register}}

In July 2006, the OpenGL Architecture Review Board voted to transfer control of the OpenGL API standard to the Khronos Group.{{cite web|url=https://www.khronos.org/news/press/opengl_arb_to_pass_control_of_opengl_specification_to_khronos_group|title=OpenGL ARB to pass control of OpenGL specification to Khronos Group|date=July 31, 2006|publisher=Khronos press release}}{{cite web|url=http://www.accessmylibrary.com/coms2/summary_0286-16157838_ITM|title=OpenGL ARB to Pass Control of OpenGL Specification to Khronos Group|publisher=AccessMyLibrary Archive}}

{{Expand section|more historical background when support was being added|date=January 2023|small=no}}

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 like ANGLE 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.{{Cite web |title=OpenGL Celebrates Its 30th Birthday |url=https://www.phoronix.com/news/OpenGL-30-Birthday |access-date=2024-12-07 |website=www.phoronix.com |language=en}}{{Cite web |date=2023-04-09 |title=OpenGL is not dead, long live Vulkan |url=https://accidentalastro.com/2023/04/opengl-is-not-dead-long-live-vulkan/ |access-date=2024-12-07 |website=The Accidental Astronomer |language=en-US}}{{Better source needed|reason=I believe my given source of accidentalastro.com falls under user-generated content, but it does explain the compatibility layers.|date=December 2024}}

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 and tvOS), strongly encouraging developers to use their proprietary Metal API, which was introduced in 2014.{{cite news |last1=Smith |first1=Ryan |date=June 5, 2018 |title=Apple Deprecates OpenGL Across All OSes; Urges Developers to use Metal |website=www.anandtech.com |publisher=Purch |url=https://www.anandtech.com/show/12894/apple-deprecates-opengl-across-all-oses |access-date=June 5, 2018}}

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 as GLQuake

{{cite web |title=GLQuake |url=https://quake.fandom.com/wiki/GLQuake |website=Quake Wiki}} or some games of the Doom franchise,{{Cite web |last=eTeknix.com |date=2016-07-29 |title=Doom OpenGL VS Vulkan Graphics Performance Analysis |url=https://www.eteknix.com/doom-opengl-vs-vulkan-graphics-performance-analysis/ |access-date=2024-12-07 |website=eTeknix |language=en-GB}} transitioned away to its successor Vulkan in its id Tech 7 engine in 2016.{{cite web |title=Doom Wiki: id Tech 7 |url=https://doomwiki.org/wiki/Id_Tech_7 |access-date=October 26, 2021}} They first supported Vulkan in an update for their id Tech 6 engine. The company's first licensed use of OpenGL was in its Quake II engine, also known as id Tech 2.{{cite web |title=Technology Licensing: id Tech 2 |url=http://www.idsoftware.com/business/idtech2/ |archive-url=https://web.archive.org/web/20091108191715/http://www.idsoftware.com/business/idtech2/ |archive-date=November 8, 2009 |access-date=September 17, 2008}} In March 2023, Valve removed OpenGL support from Dota 2 in favor of Vulkan.{{Cite web |last=Dawe |first=Liam |date=March 7, 2023 |title=Dota 2 removes OpenGL support, new hero Muerta now live, big update due in April |url=https://www.gamingonlinux.com/2023/03/dota-2-removes-opengl-new-hero-muerta-live-big-update-in-april/ |access-date=March 26, 2023 |website=GamingOnLinux |language=en}} Atypical Games, with support from Samsung, updated their game engine to use Vulkan, rather than OpenGL, across all non-Apple platforms.{{Cite web |title=Jet Set Vulkan : Reflecting on the move to Vulkan |url=https://developer.samsung.com/galaxy-gamedev/gamedev-blog/infinitejet.html}}

The Khronos Group, the consortium responsible for OpenGL's development, has stopped providing support for OpenGL.{{Citation needed|date=December 2024}} It has not received a number of modern graphics technologies, such as Ray Tracing, on-GPU video decoding, anti-aliasing algorithms with deep learning

like as Nvidia DLSS{{cite web|url=https://github.com/NVIDIA/DLSS|

title=NVIDIA DLSS SDK|website=github.com/NVIDIA/DLSS}} and [https://www.amd.com/en/products/graphics/technologies/fidelityfx/super-resolution.html AMD FSR]{{cite web|url=https://github.com/GPUOpen-LibrariesAndSDKs/FidelityFX-SDK|

title=AMD FidelityFX-SDK|website=github.com/GPUOpen-LibrariesAndSDKs/FidelityFX-SDK}}

Google's Fuchsia 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.

{{cite web

|url=https://fuchsia.dev/fuchsia-src/development/graphics/magma

|title=Magma: Overview

|website=fuchsia.dev

|access-date=March 26, 2023

}}

The first version of OpenGL, version 1.0, was released on June 30, 1992, by Mark Segal and Kurt 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.

Release date: September 7, 2004

OpenGL 2.0 was originally conceived by 3Dlabs to address concerns that OpenGL was stagnating and lacked a strong direction.{{cite web

| url=http://www.tomshardware.com/reviews/opengl-directx,2019-2.html

| title=OpenGL 3 (3DLabs And The Evolution Of OpenGL)

| last=Abi-Chahla

| first=Fedy

| publisher=Tom's Hardware

| date=September 16, 2008

| access-date=October 24, 2010}} 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 with shaders, 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 includes support for GLSL.

Before the release of OpenGL 3.0, the new revision had the codename Longs 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 become atomic, 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 of CAD 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.{{cite web|url=http://www.opengl.org/discussion_boards/ubbthreads.php?ubb=showflat&Number=229374#Post229374|title=OpenGL ARB announces an update on OpenGL 3.0|date=October 30, 2007|access-date=October 31, 2007|archive-date=November 7, 2007|archive-url=https://web.archive.org/web/20071107050010/http://www.opengl.org/discussion_boards/ubbthreads.php?ubb=showflat&Number=229374#Post229374|url-status=dead}} As a result, the spec was delayed, and the Khronos Group went into a media 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,{{cite web|url=http://tech.slashdot.org/article.pl?sid=08/08/11/2135259 |title=OpenGL 3.0 Released, Developers Furious – Slashdot |date=August 11, 2008 |publisher=Tech.slashdot.org |access-date=November 7, 2012}} with many developers professing that they would switch to DirectX 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,{{cite web|url=https://www.opengl.org/news/opengl_bof_went_over_well_no_pitch_forks_seen|title=OpenGL BOF went over well, no pitch forks seen}} with many vendors showing support for the update.{{cite web|url=https://www.opengl.org/news/nick_haemel_amd_blog_post_opengl_30_a_big_step_in_the_right_direction/ |title=The Industry Standard for High Performance Graphics |publisher=OpenGL |date=August 18, 2008 |access-date=July 31, 2017}}{{cite web|url=https://www.opengl.org/news/nvidia_provides_early_opengl_30_driver_now|title=NVIDIA provides early OpenGL 3.0 driver now}}

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 a forward-compatible context from the windowing system. OpenGL 3.0 features could still be accessed alongside these deprecated features, however, by requesting a full context.

Deprecated features include:

• All fixed-function vertex and fragment processing
• Direct-mode rendering, using glBegin and glEnd
• Display lists
• Indexed-color rendering targets
• OpenGL Shading Language versions 1.10 and 1.20

Hardware support: Nvidia GeForce 8 Series and newer, ATI Radeon HD 2000 series 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 a full context, or to access deprecated features using a forward-compatible context. An exception to the former rule is made if the implementation supports the [https://www.khronos.org/registry/OpenGL/extensions/ARB/ARB_compatibility.txt ARB_compatibility] extension, but this is not guaranteed.

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 a core profile and compatibility 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

Mesa supports software Driver SWR, softpipe and for older Nvidia cards with NV50. Several minor additions were made, with the goal of retaining

as much functionality as possible from OpenGL 4.0, while keeping support for older hardware. 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. 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: Nvidia GeForce 400 series and newer, AMD Radeon HD 5000 series and newer (FP64 shaders implemented by emulation on some TeraScale GPUs), Intel HD Graphics in Intel Ivy Bridge processors and newer.{{cite web|url=https://downloadcenter.intel.com/download/24785|title=Intel Iris and HD Graphics Driver for Windows 7/8/8.1 64bit|work=Intel Download Center|url-status=dead|archive-url=https://web.archive.org/web/20150402105758/https://downloadcenter.intel.com/download/24785|archive-date=April 2, 2015}}

Release date: July 26, 2010

Hardware support: Nvidia GeForce 400 series and newer, AMD Radeon HD 5000 series and newer (FP64 shaders implemented by emulation on some TeraScale GPUs), Intel HD Graphics in Intel Haswell processors and newer. (Linux Mesa: Ivy Bridge and newer)

• Minimum "maximum texture size" is 16,384 × 16,384 for GPUs implementing this specification.{{cite web|url=http://www.gamedev.net/topic/646362-expected-maximum-texture-size/|title=Expected maximum texture size - Graphics and GPU Programming|website=GameDev.net}}
• Improved compatibility for OpenGL ES 2.0{{cite web|url=https://registry.khronos.org/OpenGL/specs/gl/glspec41.core.pdf|title=OpenGL 4.1 (Core Profile) - July 25, 2010|website=Khronos.org}}

Release date: August 8, 2011{{cite web|url=http://www.khronos.org/news/press/khronos-enriches-cross-platform-3d-graphics-with-release-of-opengl-4.2-spec|title=Khronos Enriches Cross-Platform 3D Graphics with Release of OpenGL 4.2 Specification|work=The Khronos Group |date=August 8, 2011}}

• Support for shaders with atomic counters and load-store-atomic read-modify-write operations to one level of a texture
• Drawing multiple instances of data captured from GPU vertex processing (including tessellation), to enable complex objects to be efficiently repositioned and replicated
• Support for modifying an arbitrary subset of a compressed texture, without having to re-download the whole texture to the GPU for significant performance improvements

Hardware support: Nvidia GeForce 400 series and newer, AMD Radeon HD 5000 series and newer (FP64 shaders implemented by emulation on some TeraScale GPUs), and Intel HD Graphics in Intel Haswell processors and newer. (Linux Mesa: Ivy Bridge and newer)

Release date: August 6, 2012{{cite web|url=http://www.khronos.org/news/press/khronos-releases-opengl-4.3-specification-with-major-enhancements|title=Khronos Releases OpenGL 4.3 Specification with Major Enhancements|date=August 6, 2012}}

• Compute shaders leveraging GPU parallelism within the context of the graphics pipeline
• Shader storage buffer objects, allowing shaders to read and write buffer objects like image load/store from 4.2, but through the language rather than function calls.
• Image format parameter queries
• ETC2/EAC texture compression as a standard feature
• Full compatibility with OpenGL ES 3.0 APIs
• Debug abilities to receive debugging messages during application development
• Texture views to interpret textures in different ways without data replication
• Increased memory security and multi-application robustness

Hardware support: AMD Radeon HD 5000 series and newer (FP64 shaders implemented by emulation on some TeraScale GPUs), Intel HD Graphics in Intel Haswell processors and newer. (Linux Mesa: Ivy Bridge without stencil texturing, Haswell and newer), Nvidia GeForce 400 series and newer. VIRGL Emulation for virtual machines supports 4.3+ with Mesa 20.

Release date: July 22, 2013

• Enforced buffer object usage controls
• Asynchronous queries into buffer objects
• Expression of more layout controls of interface variables in shaders
• Efficient binding of multiple objects simultaneously

Hardware support: AMD Radeon HD 5000 series and newer (FP64 shaders implemented by emulation on some TeraScale GPUs), Intel HD Graphics in Intel Broadwell processors and newer (Linux Mesa: Haswell and newer),{{cite web|url=http://gadgets.ndtv.com/laptops/news/intel-skylake-s-cpus-and-100-series-chipsets-detailed-in-apparent-leak-682437|title=Intel Skylake-S CPUs and 100-series Chipsets Detailed in Apparent Leak|date=April 17, 2015|work= NDTV Gadgets}} Nvidia GeForce 400 series and newer, Tegra K1.

Release date: August 11, 2014{{cite web|url=https://www.khronos.org/news/press/khronos-group-announces-key-advances-in-opengl-ecosystem|title=Khronos Group Announces Key Advances in OpenGL Ecosystem – Khronos Group Press Release|date=August 10, 2014|publisher=The Khronos Group Inc|access-date=April 17, 2015}}

• Direct State Access (DSA) – object accessors enable state to be queried and modified without binding objects to contexts, for increased application and middleware efficiency and flexibility.{{cite web|url=https://arstechnica.com/information-technology/2014/08/opengl-4-5-released-with-one-of-direct3ds-best-features/|title=OpenGL 4.5 released—with one of Direct3D's best features|work=Ars Technica|date=August 11, 2014|access-date=April 17, 2015}}
• Flush Control – applications can control flushing of pending commands before context switching – enabling high-performance multithreaded applications;
• Robustness – providing a secure platform for applications such as WebGL browsers, including preventing a GPU reset affecting any other running applications;
• OpenGL ES 3.1 API and shader compatibility – to enable the easy development and execution of the latest OpenGL ES applications on desktop systems.

Hardware support: AMD Radeon HD 5000 series and newer (FP64 shaders implemented by emulation on some TeraScale GPUs), Intel HD Graphics in Intel Broadwell processors and newer (Linux Mesa: Haswell and newer), Nvidia GeForce 400 series and newer, Tegra K1, and Tegra X1.{{cite web|url=http://www.ustream.tv/recorded/51255959|title=SG4121: OpenGL Update for NVIDIA GPUs|work=Ustream|access-date=April 17, 2015|url-status=dead|archive-url=https://web.archive.org/web/20150517205154/http://www.ustream.tv/recorded/51255959|archive-date=May 17, 2015}}{{cite web|url=http://www.slideshare.net/Mark_Kilgard/opengl-45-update-for-nvidia-gpus|title=OpenGL 4.5 Update for NVIDIA GPUs|last=Kilgard|first=Mark|date=August 12, 2014|access-date=April 17, 2015}}

Release date: July 31, 2017{{cite web|url=https://www.khronos.org/news/press/khronos-releases-opengl-4.6-with-spir-v-support|title=Khronos Releases OpenGL 4.6 with SPIR-V Support|date=July 31, 2017|publisher=The Khronos Group Inc|access-date=July 31, 2017}}{{cite web | last1=Kessenich | first1=John | last2=Baldwin | first2=Dave | title=The OpenGL Shading Language, Version 4.60.7 | website=The Khronos Group Inc | url=https://www.khronos.org/registry/OpenGL/specs/gl/GLSLangSpec.4.60.html | access-date=August 21, 2019}}

• more efficient, GPU-sided, geometry processing
• more efficient shader execution (Glossary of computer graphics#azdo)
• more information through statistics, overflow query and counters
• higher performance through no error handling contexts
• clamping of polygon offset function, solves a shadow rendering problem
• SPIR-V shaders
• Improved anisotropic filtering

Hardware support: AMD Radeon HD 7000 series and newer (FP64 shaders implemented by emulation on some TeraScale GPUs), Intel Skylake and newer, Nvidia GeForce 400 series and newer.{{cite web |url=https://www.phoronix.com/scan.php?page=news_item&px=NVIDIA-OpenGL-4.6-Driver |title=NVIDIA Releases 381.26.11 Linux Driver With OpenGL 4.6 Support |first=Michael |last=Larabel |date=July 31, 2017 |website=Phoronix}}

Driver support:

• Mesa 19.2 on Linux supports OpenGL 4.6 for Intel Broadwell and newer.{{cite web |url=https://www.phoronix.com/scan.php?page=news_item&px=OpenGL-4.6-Mesa-19.2-Intel |title=Intel's OpenGL Linux Driver Now Has OpenGL 4.6 Support For Mesa 19.2 |first=Michael |last=Larabel |date=August 21, 2019 |website=Phoronix }} Mesa 20.0 supports AMD Radeon GPUs,{{cite web |url=https://www.phoronix.com/scan.php?page=news_item&px=RadeonSI-GL-4.6-NIR-Lands |title=AMD's RadeonSI Driver Finally Enables OpenGL 4.6 |first=Michael |last=Larabel |date=November 27, 2019 |website=Phoronix }} while support for Nvidia Kepler+ is in progress. Zink as Emulation Driver with 21.1 and software driver LLVMpipe also support with Mesa 21.0.
• AMD Adrenalin 18.4.1 Graphics Driver on Windows 7 SP1, 10 version 1803 (April 2018 update) for AMD Radeon HD 7700+, HD 8500+ and newer. Released April 2018.{{Cite web|url=http://www.geeks3d.com/20180501/amd-adrenalin-18-4-1-graphics-driver-released-opengl-4-6-vulkan-1-1-70/|title=AMD Adrenalin 18.4.1 Graphics Driver Released (OpenGL 4.6, Vulkan 1.1.70) – Geeks3D|website=www.geeks3d.com|date=May 2018 |language=en-US|access-date=May 10, 2018}}{{Cite web|url=https://support.amd.com/en-us/kb-articles/Pages/Radeon-Software-Adrenalin-Edition-18.4.1-Release-Notes.aspx|title=Radeon Software Adrenalin Edition 18.4.1 Release Notes|website=support.amd.com|language=en-US|access-date=May 10, 2018}}
• Intel 26.20.100.6861 graphics driver on Windows 10. Released May 2019.{{Cite web|url=https://www.geeks3d.com/20190516/intel-graphics-driver-25-20-100-6861-released-opengl-4-6-vulkan-1-1-103/|title=Intel Graphics Driver 25.20.100.6861 Released (OpenGL 4.6 + Vulkan 1.1.103) {{!}} Geeks3D|date=May 16, 2019 |language=en-US|access-date=May 16, 2019}}{{cite web | title=Windows 10 DCH Drivers | website=Intel DownloadCenter | url=https://downloadcenter.intel.com/download/28783/Intel-Graphics-Windows-10-DCH-Drivers | access-date=August 21, 2019}}
• NVIDIA GeForce 397.31 Graphics Driver on Windows 7, 8, 10 x86-64 bit only, no 32-bit support. Released April 2018{{Cite web|url=http://www.geeks3d.com/20180425/nvidia-geforce-397-31-graphics-driver-released-opengl-4-6-vulkan-1-1-rtx-cuda-9-2/|title=NVIDIA GeForce 397.31 Graphics Driver Released (OpenGL 4.6, Vulkan 1.1, RTX, CUDA 9.2) – Geeks3D|website=www.geeks3d.com|date=April 25, 2018 |language=en-US|access-date=May 10, 2018}}

{{anchor|Deprecation in Apple devices}}Apple deprecated OpenGL in iOS 12 and macOS 10.14 Mojave in favor of Metal, but it is still available as of macOS 14 Sonoma (including on Apple silicon devices).{{cite web |title=Apple Developer Documentation |url=https://developer.apple.com/documentation/apple-silicon/porting-your-macos-apps-to-apple-silicon |website=developer.apple.com}} The latest version supported for OpenGL is 4.1 from 2011.{{cite web |last1=Cunningham |first1=Andrew |title=macOS 10.15 Catalina: The Ars Technica review |url=https://arstechnica.com/gadgets/2019/10/macos-10-15-catalina-the-ars-technica-review/3/#h2 |website=Ars Technica |language=en-us |date=October 7, 2019}}{{Cite web|last=Axon|first=Samuel|date=June 6, 2018|title=The end of OpenGL support, plus other updates Apple didn't share at the keynote|url=https://arstechnica.com/gadgets/2018/06/the-end-of-opengl-support-other-updates-apple-didnt-share-at-the-keynote/|access-date=October 19, 2020|website=Ars Technica|language=en-us}} A proprietary library from Molten – authors of MoltenVK – called MoltenGL, can translate OpenGL calls to Metal.{{Cite web|title=Vulkan, and faster OpenGL ES, on iOS and macOS|url=https://moltengl.com/|access-date=October 19, 2020|website=Molten|language=en-US}}

There are several projects that attempt to implement OpenGL on top of Vulkan. The Vulkan backend for Google's ANGLE achieved OpenGL ES 3.1 conformance in July 2020.{{cite web|url=https://github.com/google/angle|title=google/angle: A conformant OpenGL ES implementation for Windows, Mac, Linux, iOS and Android.|website=GitHub|author=The ANGLE Project Authors|access-date=December 17, 2020|date=October 14, 2020}} The Mesa3D project also includes such a driver, called Zink.{{cite web |title=Zink |url=https://docs.mesa3d.org/gallium/drivers/zink.html |website=The Mesa 3D Graphics Library latest documentation}}

Microsoft's Windows 11 on Arm added support for OpenGL 3.3 via GLon12, an open source OpenGL implementation on top DirectX 12 via Mesa Gallium.{{Cite web |date=March 13, 2022 |title=State of Windows on Arm64: a high-level perspective |url=https://chipsandcheese.com/2022/03/13/state-of-windows-on-arm64-a-high-level-perspective/ |access-date=October 23, 2023 |website=Chips and Cheese |language=en-US}}{{Cite web |title=Introducing OpenCL and OpenGL on DirectX |url=https://www.collabora.com/news-and-blog/news-and-events/introducing-opencl-and-opengl-on-directx.html |access-date=October 23, 2023 |website=Collabora {{!}} Open Source Consulting |language=en}}{{Cite web |title=Deep dive into OpenGL over DirectX layering |url=https://www.collabora.com/news-and-blog/blog/2020/07/09/deep-dive-into-opengl-over-directx-layering/ |access-date=October 23, 2023 |website=Collabora {{!}} Open Source Consulting |language=en}}

{{Main|Vulkan}}

Vulkan, formerly named the "Next Generation OpenGL Initiative" (glNext),{{cite news|last=Dingman|first=Hayden|date=March 3, 2015|title=Meet Vulkan, the powerful, platform-agnostic gaming tech taking aim at DirectX 12|url=http://www.pcworld.com/article/2891613/meet-vulkan-the-powerful-platform-agnostic-gaming-tech-taking-aim-at-directx-12.html|newspaper=PC World|access-date=March 3, 2015}}{{cite news|last=Bright|first=Peter|date=March 3, 2015|title=Khronos unveils Vulkan: OpenGL built for modern systems|url=https://arstechnica.com/gadgets/2015/03/khronos-unveils-vulkan-opengl-built-for-modern-systems/|newspaper=Ars Technica|access-date=March 3, 2015}} 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.{{cite web |url=http://www.anandtech.com/show/8363/khronos-announces-next-generation-opengl-initiative |title=Khronos Announces Next Generation OpenGL Initiative |publisher=AnandTech |access-date=August 20, 2014}}{{cite web |url=https://www.extremetech.com/gaming/187796-opengl-4-5-released-next-gen-opengl-unveiled-cross-platform-mantle-killer-dx12-competitor |title=OpenGL 4.5 released, next-gen OpenGL unveiled: Cross-platform Mantle killer, DX12 competitor |date=August 11, 2014 |access-date=August 20, 2014}}{{cite web |url=https://www.phoronix.com/scan.php?page=news_item&px=MTc2ODQ |title=Khronos Publishes Its Slides About OpenGL-Next |publisher=Phoronix |access-date=August 22, 2014}}

The initial version of Vulkan API was released on February 16, 2016.

{{Portal|Free and open-source software

}}

• ARB assembly language – OpenGL's legacy low-level shading language
• Direct3D – main competitor of OpenGL
• Glide (API) – a graphics API once used on 3dfx Voodoo cards
• Metal (API) – a graphics API for iOS, macOS, tvOS, watchOS
• OpenAL – cross-platform audio library, designed to resemble OpenGL
• OpenGL ES – OpenGL for embedded systems
• OpenSL ES – API for audio on embedded systems, developed by the Khronos Group
• OpenVG – API for accelerated 2D graphics, developed by the Khronos Group
• RenderMan Interface Specification (RISpec) – Pixar's open API for photorealistic off-line rendering
• VOGL – a debugger for OpenGL
• Vulkan – low-overhead, cross-platform 2D and 3D graphics API, the "next generation OpenGL initiative"
• Graphics pipeline
• WebGL
• WebGPU

{{Notelist}}

{{Reflist|refs=

{{cite web|url=https://registry.khronos.org/OpenGL/specs/gl/glspec11.pdf|title=The OpenGL Graphics System: A Specification|version=1.1|date=March 4, 1997}}

{{cite web|url=https://www.khronos.org/registry/OpenGL/specs/gl/glspec20.pdf|title=The OpenGL Graphics System: A Specification|version=2.0|date=October 22, 2004}}

{{cite web|url=https://www.khronos.org/registry/OpenGL/specs/gl/glspec21.pdf|title=The OpenGL Graphics System: A Specification|version=2.1|date=December 1, 2006}}

{{cite web|url=https://www.khronos.org/registry/OpenGL/specs/gl/glspec30.pdf|title=The OpenGL Graphics System: A Specification|version=3.0|date=September 23, 2008}}

{{cite web|url=https://www.khronos.org/registry/OpenGL/specs/gl/glspec31.pdf|title=The OpenGL Graphics System: A Specification|version=3.1|date=May 28, 2009}}

{{cite web|url=https://www.khronos.org/registry/OpenGL/specs/gl/glspec32.core.pdf|title=The OpenGL Graphics System: A Specification|version=3.2 (Core Profile)|date=December 7, 2009}}

{{cite web|url=https://www.khronos.org/registry/OpenGL/specs/gl/glspec40.core.pdf|title=The OpenGL Graphics System: A Specification|version=4.0 (Core Profile)|date=March 11, 2010}}

}}

• {{cite book | first1=Dave | last1=Shreiner | first2=Graham | last2=Sellers | first3=John M. | last3=Kessenich | first4=Bill | last4=Licea-Kane | display-authors=2 | title=OpenGL Programming Guide: The Official Guide to Learning OpenGL | version=Version 4.3 | edition=8th | publisher=Addison-Wesley | date=March 30, 2013 | isbn=978-0-321-77303-6}}
• {{cite book | first1=Graham | last1=Sellers | first2=Richard S. | last2=Wright | first3=Nicholas | last3=Haemel | title=OpenGL SuperBible: Comprehensive Tutorial and Reference | edition=6th | publisher=Addison-Wesley | date=July 31, 2013 | isbn=978-0-321-90294-8}}
• {{cite book | first=Randi J. | last=Rost | author-link=Randi J. Rost | title=OpenGL Shading Language | edition=3rd | publisher=Addison-Wesley | date=July 30, 2009 | isbn=978-0-321-63763-5}}
• {{cite book | first=Eric | last=Lengyel | author-link=Eric Lengyel | title=The OpenGL Extensions Guide | publisher=Charles River Media | isbn=1-58450-294-0 | year=2003 | url=https://archive.org/details/openglextensions0000leng }}
• {{cite book | author1=OpenGL Architecture Review Board | author-link1=OpenGL Architecture Review Board | first2=Dave | last2=Shreiner | title=OpenGL Reference Manual: The Official Reference Document to OpenGL | version=Version 1.4 | publisher=Addison-Wesley | isbn=0-321-17383-X| year=2004 }}
• {{cite book | author1=OpenGL Architecture Review Board | author-link1=OpenGL Architecture Review Board | first2=Dave | last2=Shreiner | first3=Mason | last3=Woo | first4=Jackie | last4=Neider | first5=Tom | last5=Davis | display-authors=2 | title=OpenGL Programming Guide: The Official Guide to Learning OpenGL | year=2006 | version=Version 2 | edition=5th | publisher=Addison-Wesley | isbn=0-321-33573-2 | url-access=registration | url=https://archive.org/details/openglprogrammin0000unse }}

{{Commons category|OpenGL}}

{{wikibooks|OpenGL Programming}}

• {{Official website}}
• [https://www.khronos.org/opengl/ OpenGL Overview] and [https://www.khronos.org/opengl/wiki/ OpenGL.org's Wiki] with more information on OpenGL Language bindings
• [https://web.archive.org/web/20161112121902/http://www.sgi.com/tech/opengl/ SGI's OpenGL website]
• [https://www.khronos.org/ Khronos Group, Inc.]
• [https://ledin.cs.sonoma.edu/CS375_OpenGL_Slides/] OpenGL lectures by Tom Duff (Pixar Animation) and George Ledin Jr (Sonoma State University)

{{Khronos Group standards}}

{{Authority control}}

Category:1992 software

Category:3D graphics APIs

Category:Application programming interfaces

Category:Cross-platform software

Category:Graphics libraries

Category:Graphics standards

Category:Video game development

Category:Video game development software

Category:Virtual reality

Category:Augmented reality