Discover published sets by community

OpenGL uses a right-handed coordinate system, while DirectX uses a left-handed system. Vulkan offers flexibility through its configurable coordinate system.

OpenGL uses GLSL while DirectX uses HLSL. Vulkan uses SPIR-V, which is an intermediate language that any shading language can be compiled into.

DirectX 12 and Vulkan are both explicit APIs with similar stages in the rendering pipeline, but they manage memory and synchronization differently. OpenGL has a more fixed-function pipeline approach.

OpenGL and DirectX both support various texture compression formats, but the specific supported formats can vary. Vulkan supports ASTC and additional formats through extensions.

Vulkan and DirectX 12 allow for more control over the swap chain, while OpenGL handles swap chains more implicitly through the windowing system.

Vulkan and DirectX 12 are designed to better utilize multithreading, while OpenGL's support is more limited and less efficient due to its older design.

Vulkan and DirectX 12 allow pre-recording of command lists/buffers which can then be executed multiple times, offering performance benefits. In OpenGL, command recording is less explicit and more state-based.

Vulkan uses explicit synchronization mechanisms like fences, semaphores, and barriers. DirectX 12 uses similar concepts. OpenGL has implicit synchronization, which can be less fine-grained.

Vulkan and DirectX 12 aim to reduce driver overhead compared to OpenGL by providing lower-level access to the hardware.

Vulkan provides explicit memory management, while OpenGL manages memory behind the scenes. DirectX 12 also allows for explicit control but is different in terms of how memory allocation and deallocation is handled.

DirectX 12 uses Descriptor Heaps and Tables for resource binding, Vulkan uses Descriptor Sets, while OpenGL uses context-bound objects, which are less flexible.

Vulkan and DirectX 12 use PSOs to encapsulate all states required for rendering. OpenGL uses separate state calls, leading to potentially more draw calls and overhead.

Vulkan provides verbose error information through return codes and validation layers. DirectX 12 also offers extensive debugging capabilities. OpenGL's error handling is more limited in scope and detail.

OpenGL and DirectX use similar tessellation stages within the pipeline; however, there are differences in control over tessellation factors. Vulkan also supports tessellation but requires explicit activation via pipeline states.

All three APIs support compute shaders, with similar capabilities. The main differences lie in how compute resources are managed and dispatched.

OpenGL embraces extensions broadly for functionality augmentation. Vulkan has a core set of features and additional explicitly enabled extensions. DirectX typically integrates new features in major releases, rather than via extensions.

Anisotropic filtering is supported across OpenGL, DirectX, and Vulkan. The APIs differ in the way anisotropic filtering is enabled and controlled.

DirectX has explicit support for fullscreen exclusive mode, which can increase performance. OpenGL relies on the windowing system, and Vulkan offers a similar mode through extensions.

Adaptive sync (such as V-Sync) is implemented in OpenGL via extensions, while DirectX 12 has integrated support for tearing control. Vulkan also supports adaptive sync mechanisms.