Low Level Graphics Library (LLGL)

License Join the chat at https://gitter.im/LLGL-Project/community


Platform Support

Platform CI D3D12 D3D11 Vulkan OpenGL OpenGLES 3 Metal
Windows Windows Build :heavy_check_mark: :heavy_check_mark: :heavy_check_mark: :heavy_check_mark: N/A N/A
GNU/Linux GNU/Linux Build Status N/A N/A :heavy_check_mark: :heavy_check_mark: N/A N/A
macOS macOS Build Status N/A N/A N/A :heavy_check_mark: N/A :heavy_check_mark:
iOS iOS Build Status N/A N/A N/A N/A :heavy_multiplication_x: :heavy_check_mark:
Android N/A N/A :heavy_multiplication_x: N/A :heavy_check_mark: N/A

Build Notes

Build scripts are provided for CMake.


Visual Studio 2015 or later is required to build LLGL on Windows.

macOS, iOS

Xcode 9 or later is required to build LLGL on macOS and iOS.


The following development libraries are required to build LLGL on GNU/Linux:

  • X11: libx11-dev
  • xf86vidmode: libxxf86vm-dev
  • Xrandr: libxrandr-dev


The Android NDK with at least API level 21 is required. The build script to generate project files is currently only supported on GNU/Linux and requires CMake 3.10 or later and the Code::Blocks IDE.

This platform support is currently in an experimental state.

Thin Abstraction Layer

// Unified Interface:
CommandBuffer::DrawIndexed(std::uint32_t numIndices, std::uint32_t firstIndex);

// OpenGL Implementation:
void GLCommandBuffer::DrawIndexed(std::uint32_t numIndices, std::uint32_t firstIndex) {
    const GLintptr indices = (renderState_.indexBufferOffset + firstIndex * renderState_.indexBufferStride);
        reinterpret_cast<const GLvoid*>(indices)

// Direct3D 11 Implementation
void D3D11CommandBuffer::DrawIndexed(std::uint32_t numIndices, std::uint32_t firstIndex) {
    context_->DrawIndexed(numIndices, firstIndex, 0);

// Direct3D 12 Implementation
void D3D12CommandBuffer::DrawIndexed(std::uint32_t numIndices, std::uint32_t firstIndex) {
    commandList_->DrawIndexedInstanced(numIndices, 1, firstIndex, 0, 0);

// Vulkan Implementation
void VKCommandBuffer::DrawIndexed(std::uint32_t numIndices, std::uint32_t firstIndex) {
    vkCmdDrawIndexed(commandBuffer_, numIndices, 1, firstIndex, 0, 0);

// Metal implementation
void MTCommandBuffer::DrawIndexed(std::uint32_t numIndices, std::uint32_t firstIndex) {
    if (numPatchControlPoints_ > 0) {
            drawIndexedPatches:             numPatchControlPoints_
            patchStart:                     static_cast<NSUInteger>(firstIndex) / numPatchControlPoints_
            patchCount:                     static_cast<NSUInteger>(numIndices) / numPatchControlPoints_
            patchIndexBuffer:               nil
            patchIndexBufferOffset:         0
            controlPointIndexBuffer:        indexBuffer_
            controlPointIndexBufferOffset:  indexTypeSize_ * (static_cast<NSUInteger>(firstIndex))
            instanceCount:                  1
            baseInstance:                   0
    } else {
            drawIndexedPrimitives:  primitiveType_
            indexCount:             static_cast<NSUInteger>(numIndices)
            indexType:              indexType_
            indexBuffer:            indexBuffer_
            indexBufferOffset:      indexTypeSize_ * static_cast<NSUInteger>(firstIndex)


Low Level Graphics Library (LLGL) is a thin abstraction layer for the modern graphics APIs OpenGL, Direct3D, Vulkan, and Metal

Llgl Info

⭐ Stars1276
🔗 Source Codegithub.com
🕒 Last Update8 months ago
🕒 Created6 years ago
🐞 Open Issues16
➗ Star-Issue Ratio80
😎 AuthorLukasBanana