Build portable rendering systems across Vulkan and DirectX 12 with QHWI

Co-written with Kashyap Rajpal and Mauricio Maurer.

Building rendering systems across Vulkan and DirectX 12 often means maintaining duplicate infrastructure, integrating the same GPU features multiple times, and managing backend-specific optimizations.

QHWI (Qualcomm Hardware Interface) is an open-source graphics abstraction layer provides a lightweight abstraction layer that helps graphics teams build portable rendering systems across APIs while still taking advantage of modern graphics features and Adreno-specific optimizations.

Motivation

We designed QHWI with several goals in mind, including:

1. Provide optimal performance and demonstrate best practices for Adreno GPUs

QHWI is designed to enable optimal performance for Adreno GPUs by supporting the latest Qualcomm Technologies extensions including — VK_QCOM_TILE_SHADING, VK_QCOM_TILE_MEMORY_HEAP, VK_QCOM_IMAGE_PROCESSING, VK_QCOM_TILE_PROPERTIES, VK_QCOM_RENDER_PASS_SHADER_RESOLVE, VK_QCOM_MULTIVIEW_PER_VIEW_VIEWPORTS, and VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS.

QHWI provides various examples to demonstrate usage of these extensions and encourage adoption.  In addition, QHWI demonstrates best practices for Adreno GPUs including optimal barrier usage, tile memory-aware render-pass design, bindless resource patterns, and optimizations for UMA (unified memory architecture).

2. Support the latest bleeding-edge features

QHWI leverages the latest and experimental features of both APIs, such as mesh and amplification shader pipelines, ray tracing acceleration structures, and ray queries. In addition, QHWI exposes and leverages backend-specific features and extensions, such as D3D12 enhanced barriers, VK dynamic rendering with local read, and VK specialization constants.

3. Support multiple platforms via a thin abstraction API

QHWI lets developers write portable, high-performance graphics code that runs across multiple platforms including Windows, Linux, and Android. It exposes modern capabilities including command buffer recording, manual synchronization, descriptor and resource binding models, and pipeline state objects — behind a single backend-agnostic interface. The abstraction is as thin as possible: QHWI maps as closely as possible to the underlying APIs to minimize CPU overhead and maximize performance.

How QHWI is used at Qualcomm Technologies

QHWI supports several graphics and AI initiatives across Qualcomm Technologies:

1.  Quadrangle rendering engine: QHWI serves as the graphics abstraction layer for Qualcomm Technologies’ cross-platform C++20 renderer targeting Windows, Android, and Linux.
   
   
2. Adreno performance evaluation: Teams use QHWI as a test harness to measure and communicate the performance impact of new Adreno extensions and optimization techniques.
   
   
3. ANF (Adreno Neural Fusion) SDK: QHWI provides graphics infrastructure that supports the Qualcomm ANF SDK.
   
   
4. Broader internal adoption: Multiple teams across Qualcomm Technologies use QHWI for graphics development, validation, and experimentation.

Features

Supported platforms and backends

• Windows (x64, ARM64-compatible) – Vulkan and D3D12, selectable independently or enabled together
  
  
• Linux (x64) – Vulkan
  
  
• Android (arm64-v8a-compatible) – Vulkan

Rendering, compute, and resource management

• Graphics and compute pipelines, PipelineLayout-based descriptor binding, device enumeration, and GPU feature querying
  
  
• Render-to-texture with multiple render targets, MSAA, and 2D / 3D / 2D-array / cube-map texture types
  
  
• Swapchain and window creation, bindless rendering, GPU timer-query profiling, and both explicit and automatic resource barrier modes

Advanced GPU capabilities

• Mesh and amplification shader pipelines, ray queries, and ray tracing acceleration structures
  
  
• Single-pass mipmap generation, HDR rendering, MultiView, D3D12 enhanced barriers, Vulkan specialization constants, and dynamic rendering with local read

Qualcomm and performance-focused extensions

• Qualcomm Vulkan extensions – VK_QCOM_IMAGE_PROCESSING, VK_QCOM_MULTIVIEW_PER_VIEW_VIEWPORTS, VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS, VK_QCOM_TILE_PROPERTIES, VK_QCOM_TILE_SHADING, VK_QCOM_TILE_MEMORY_HEAP, and VK_QCOM_RENDER_PASS_SHADER_RESOLVE are exposed as opt-in QHWI capabilities.
  
  
• Hardware-accelerated optical flow – wraps VK_NV_OPTICAL_FLOW, available on supporting devices, behind the same QHWI resource and command model used for other GPU workloads.
  
  
• GPU-targeted compressed asset storage – loads and optionally decompresses assets directly into GPU-visible memory, using DirectStorage on D3D12 and VK_EXT_memory_decompression on Vulkan.
  
  
• Integrated profiling capabilities– CPU and GPU profiling, including HW counters via PIL.  Also support for various 3^rd-party tracing tools (including tracy)

Examples

QHWI ships several example applications that demonstrate important graphics and GPU capabilities:

• gpl – compares monolithic vs. Vulkan graphics-pipeline-library-constructed pipelines across several shader permutation types, with CPU/GPU performance measurement built in
  
  
• qcom_image_proc – hardware-accelerated image downscaling via VK_QCOM_IMAGE_PROCESSING
  
  
• qcom_multiview – per-view viewport and render-area multiview extensions
  
  
• qcom_tile_shading and qcom_tile_memory_heap – Adreno tile-shading render pass mode and tile-memory-heap buffer usage (Android)
  
  
• vk_custom_resolve – custom MSAA resolve via VK_QCOM_RENDER_PASS_SHADER_RESOLVE, with fallback to VK_EXT_custom_resolve or standard MSAA resolve when the primary extension isn't available – a pattern worth studying for any team writing extension-aware fallback logic
  
  
• vr – a spinning-cube VR sample over OpenXR, running as a native Android VR app (validated on Quest 2) or via PC VR streaming over Oculus Link, on both the Vulkan and D3D12 backends

Testing

QHWI has extensive unit testing and CI coverage to help maintain build correctness and backend reliability across supported platforms. The test suite runs on Adreno and various other GPUs / devices.  Contributors can also run the test suite locally against their own GPU-equipped systems before submitting changes.

Connect with us

We welcome feedback from the community. Please report bugs, request new features or examples, and share ideas for how QHWI can be improved. We also encourage community contributions, whether that's adding new features, creating examples, improving documentation, or enhancing existing functionality.

• Issues: https://github.com/qualcomm/qhwi/issues
  
  
• Contributing guide: https://github.com/qualcomm/qhwi/blob/main/CONTRIBUTING.md

Closing Remarks

QHWI gives graphics and engine developers a practical way to build portable rendering code while still taking full advantage of modern Vulkan, DirectX 12, and enables optimal performance on Adreno GPUs. By reducing backend-specific infrastructure and exposing advanced GPU features through a consistent API, QHWI helps teams move faster from prototype to production without compromising performance.

For developers targeting Adreno, QHWI provides a clear path to achieving optimal Adreno performance through extension-aware examples, best-practice patterns, and reusable backend abstractions. Whether you are building a game engine, evaluating new rendering techniques, or bringing up graphics workloads across platforms, QHWI helps simplify development while keeping performance-critical control close to the hardware.

Thank you to everyone who contributed to QHWI internally before this release. We’re excited to open source QHWI and look forward to seeing what the community builds with it. Open a GitHub issue if you have questions, find a bug, or want to contribute.

We're excited to open source QHWI!