OpenGL - ArchWiki

Jump to content
From ArchWiki

From Wikipedia:OpenGL:

  OpenGL (Open Graphics Library) is a cross-language, cross-platform application programming interface (API) for rendering 2D and 3D vector graphics.

Learn more at Khronos.

Development of OpenGL ceased in 2017 in favour of Vulkan, the "next generation" API which offers higher performance on newer hardware.

## Installation

To run applications that use OpenGL, you will need to install the correct driver(s) for your hardware (either GPUs or CPUs).

Tip:

- For AMD (and ATI) it is recommended to use the open-source drivers unless you have a strong reason to use the proprietary ones.
- For NVIDIA, the proprietary driver is recommended for cards newer than the Kepler (NVE0/GKXXX) series, and/or better performance in general.

Note:

- Intel's GenN hardware does not refer to the generation of the CPU, it refers to the generation of the GPU, which is different from the generation of the CPU.
- To find the family of an AMD (and ATI) GPU, check Wikipedia:List of AMD graphics processing units#Features overview
- To find the code-name of an NVIDIA GPU, check the code-name list from the Nouveau project

Mesa is an open-source OpenGL implementation, continually updated to support the latest OpenGL specification. It has a collection of open-source drivers for Intel graphics, AMD (formerly ATI) and NVIDIA GPUs. Mesa also provides software rasterizers, such as llvmpipe.

There are two Mesa packages, each with a distinct set of drivers:

- mesa is the up-to-date Mesa package which includes most of the modern drivers for newer hardware:
  - `r300` : for AMD's Radeon R300, R400, and R500 GPUs.
  - `r600` : for AMD's Radeon R600 GPUs up to Northern Islands. Officially supported by AMD.
  - `radeonsi` : for AMD's Southern Island GPUs and later. Officially supported by AMD.
  - `nouveau` : Nouveau is the open-source driver for NVIDIA GPUs.
  - `virtio_gpu` : a virtual GPU driver for virtio, can be used with QEMU based VMMs (like KVM or Xen).
  - `vmwgfx` : for VMware virtual GPUs.
  - `i915` : for Intel's Gen 3 hardware.
  - `crocus` : for Intel's Gen 4 to Gen 7 hardware.
  - `iris` : for Intel's Gen 8 hardware and later. Officially supported by Intel.
  - `zink` : a Gallium driver used to run OpenGL on top of Vulkan.
  - `d3d12` : for OpenGL 3.3 support on devices that only support D3D12 (i.e. WSL).
  - `swrast` : a legacy software rasterizer.
  - `softpipe` : a software rasterizer and a reference Gallium driver.
  - `llvmpipe` : a software rasterizer which uses LLVM for x86 JIT code generation and is multi-threaded.

- mesa-amber is the legacy Mesa package which includes the classic (non-Gallium3D) drivers for older hardware:
  - `i830` : for Intel's Gen 2 hardware. Same binary as `i965`.
  - `i915` : for Intel's Gen 3 hardware. Same binary as `i965`.
  - `i965` : for Intel's Gen 4 hardware and later. Officially supported by Intel.
  - `radeon` : for AMD's Radeon R100 GPUs. Same binary as `r200`.
  - `r200` : for AMD's Radeon R200 GPUs.
  - `nouveau_vieux` : for NVIDIA NV04 (Fahrenheit) to NV20 (Kelvin) GPUs.
  - `swrast` : a legacy software rasterizer.

  Note: When using Mesa, the correct driver should be selected automatically, thus no configuration is needed once the package is installed.

- nvidia-utils is the proprietary driver for NVIDIA GPUs, which includes an OpenGL implementation.

- amdgpu-pro-oglpAUR is the proprietary driver for AMD GPUs.

## Verification

To verify your OpenGL installation, you can use mesa-utils `eglinfo`, which should display output like this (with different values depending on your setup, of course):

    $ eglinfo -B

    Wayland platform:
    EGL API version: 1.4
    EGL vendor string: Mesa Project
    EGL version string: 1.4
    EGL client APIs: OpenGL OpenGL_ES
    OpenGL compatibility profile vendor: Mesa Project
    OpenGL compatibility profile renderer: i915 (chipset: Pineview M)
    OpenGL compatibility profile version: 2.1 Mesa 23.1.5
    OpenGL compatibility profile shading language version: 1.20
    OpenGL ES profile vendor: Mesa Project
    OpenGL ES profile renderer: i915 (chipset: Pineview M)
    OpenGL ES profile version: OpenGL ES 2.0 Mesa 23.1.5
    OpenGL ES profile shading language version: OpenGL ES GLSL ES 1.0.16

    X11 platform:
    EGL API version: 1.5
    EGL vendor string: Mesa Project
    EGL version string: 1.5
    EGL client APIs: OpenGL OpenGL_ES
    OpenGL core profile vendor: Mesa
    OpenGL core profile renderer: llvmpipe (LLVM 15.0.7, 128 bits)
    OpenGL core profile version: 4.5 (Core Profile) Mesa 23.1.5
    OpenGL core profile shading language version: 4.50
    OpenGL compatibility profile vendor: Mesa
    OpenGL compatibility profile renderer: llvmpipe (LLVM 15.0.7, 128 bits)
    OpenGL compatibility profile version: 4.5 (Compatibility Profile) Mesa 23.1.5
    OpenGL compatibility profile shading language version: 4.50
    OpenGL ES profile vendor: Mesa
    OpenGL ES profile renderer: llvmpipe (LLVM 15.0.7, 128 bits)
    OpenGL ES profile version: OpenGL ES 3.2 Mesa 23.1.5
    OpenGL ES profile shading language version: OpenGL ES GLSL ES 3.20

On X11 platform, `glxinfo` works as well.

From the same package, you can also use `eglgears_x11` or `glxgears` (on X11) or `eglgears_wayland` (on Wayland) as a basic OpenGL test. You should see 3 rotating gears when running the program.

## Switching between drivers

For Hybrid graphics, see PRIME.

Note: According to this Reddit post, you can use 2 GPUs from different vendors working at the same time using PRIME without any problems.

### Mesa

You can override the driver used for an application with the following environment variable:

    MESA_LOADER_DRIVER_OVERRIDE=driver

By default, Mesa searches for drivers in `/lib/dri/`. You can view the list of installed drivers with

    $ ls /lib/dri/

`driver` in `driver_dri.so` is the actual name of the driver. If Mesa failed to find the specified driver, it will fall back to `llvmpipe`.

You can also use an OpenGL software rasterizer by setting the following environment variables:

    LIBGL_ALWAYS_SOFTWARE=true
    GALLIUM_DRIVER=driver

`driver` can be either `softpipe`, `llvmpipe`, or `swr`.

Tip: In most use-cases, `llvmpipe` and `swr` are faster than `softpipe`.

## OpenGL over Vulkan (Zink)

From the Mesa documentation:

  The Zink driver is a Gallium driver that emits Vulkan API calls instead of targeting a specific GPU architecture. This can be used to get full desktop OpenGL support on devices that only support Vulkan.

If you are experiencing issues in your default OpenGL drivers (a bug in RadeonSI, Iris, etc.), you could try using the Zink driver.

According to this Phoronix benchmark, the average FPS might be lower in some applications compared to RadeonSI.

To use Zink on NVIDIA drivers, use this command or similar:

    $ env __GLX_VENDOR_LIBRARY_NAME=mesa MESA_LOADER_DRIVER_OVERRIDE=zink GALLIUM_DRIVER=zink application

## Development

Note: This section is for developers who want to use OpenGL in projects. End users should not need anything from this section.

Using OpenGL in code requires functions loader, read more at Khronos.

This article or section needs expansion.

Reason: Put list of packages relevant to OpenGL and in Arch repo (Discuss in Talk:OpenGL)

### OpenGL Hardware Database

GPUInfo provides user reported GPU/driver combinations, supported extensions, capabilities, etc. This information is useful for verifying compatibility / compliance of particular hardware under both OpenGL and Vulkan.

Categories:

- Graphics
- Development

Hidden category:

- Pages or sections flagged with Template:Expansion