The XR_META_tile_properties_hint extension allows your application to tell the OpenXR runtime about the GPU tile layout used by your main render pass. The runtime uses this information to provide tile-aligned resolutions from XR_META_recommended_layer_resolution and tile-aligned fragment density maps when foveated rendering is enabled.

Without this hint, the runtime has no visibility into your framebuffer’s tiling — it cannot access application frame buffers directly. Providing the hint enables the runtime to make better-aligned recommendations, avoiding partial-tile waste and improving both dynamic resolution and FFR quality.

This extension works in conjunction with VK_QCOM_tile_properties, a Vulkan extension that lets you query the actual tile layout used by the GPU for a given render pass or framebuffer.

Required extensions

OpenXR

Extension	Purpose
`XR_META_tile_properties_hint`	Passes tile property data to the runtime

Vulkan

Extension	Purpose
`VK_QCOM_tile_properties`	Queries GPU tile dimensions, apron size, and origin from a framebuffer or dynamic rendering info

Implementation

Step 1: Get function pointers

PFN_xrSetTilePropertiesHintMETA xrSetTilePropertiesHintMETA = nullptr;
xrGetInstanceProcAddr(instance, "xrSetTilePropertiesHintMETA",
    (PFN_xrVoidFunction*)&xrSetTilePropertiesHintMETA);

PFN_vkGetFramebufferTilePropertiesQCOM vkGetFramebufferTilePropertiesQCOM = nullptr;
vkGetFramebufferTilePropertiesQCOM =
    (PFN_vkGetFramebufferTilePropertiesQCOM)vkGetDeviceProcAddr(
        device, "vkGetFramebufferTilePropertiesQCOM");

If your application uses dynamic rendering instead of framebuffers, use vkGetDynamicRenderingTilePropertiesQCOM instead.

Step 2: Query tile properties from Vulkan

After creating your framebuffer, query the tile layout:

uint32_t tilePropertiesCount = 0;
vkGetFramebufferTilePropertiesQCOM(device, framebuffer,
    &tilePropertiesCount, nullptr);

if (tilePropertiesCount == 0) {
    return;  // No tile properties available
}

std::vector<VkTilePropertiesQCOM> tileProperties(tilePropertiesCount);
vkGetFramebufferTilePropertiesQCOM(device, framebuffer,
    &tilePropertiesCount, tileProperties.data());

Step 3: Convert and send the hint

Convert the Vulkan tile properties to OpenXR format and pass them to the runtime:

std::vector<XrTilePropertiesMETA> xrTileProperties(tilePropertiesCount);
for (uint32_t i = 0; i < tilePropertiesCount; i++) {
    xrTileProperties[i].type = XR_TYPE_TILE_PROPERTIES_META;
    xrTileProperties[i].next = nullptr;
    xrTileProperties[i].tileDimensions.width  = tileProperties[i].tileSize.width;
    xrTileProperties[i].tileDimensions.height = tileProperties[i].tileSize.height;
    xrTileProperties[i].tileDimensions.depth  = tileProperties[i].tileSize.depth;
    xrTileProperties[i].apronDimensions.width  = tileProperties[i].apronSize.width;
    xrTileProperties[i].apronDimensions.height = tileProperties[i].apronSize.height;
    xrTileProperties[i].origin.x = tileProperties[i].origin.x;
    xrTileProperties[i].origin.y = tileProperties[i].origin.y;
}

XrTilePropertiesHintMETA hint = {XR_TYPE_TILE_PROPERTIES_HINT_META};
hint.propertiesCount = tilePropertiesCount;
hint.properties = xrTileProperties.data();

xrSetTilePropertiesHintMETA(session, &hint);

When to call

Call xrSetTilePropertiesHintMETA once after creating your framebuffers (or after any change to the render pass configuration that might affect tiling). The hint persists for the session — you do not need to call it every frame.

If your application recreates framebuffers (for example, when changing resolution), query and send the tile properties again.

What the runtime does with tile properties

The runtime uses the tile hint for two optimizations:

Tile-aligned dynamic resolution: When using XR_META_recommended_layer_resolution, the runtime snaps recommended resolutions to tile boundaries, avoiding partial tiles that waste GPU work.

Tile-aligned fragment density maps: When foveated rendering is enabled, the fragment density map regions align to tile boundaries, ensuring that foveation transitions don’t split tiles.

Combining with other features

This extension works best when combined with:

Fixed foveated rendering — tile alignment improves the efficiency of fragment density maps

Dynamic resolution via XR_META_recommended_layer_resolution — tile alignment avoids partial-tile waste

Symmetric projection — quantizing swapchain dimensions to tile multiples (as described in that guide) complements tile-aligned runtime recommendations

Tips

Call it early: Send the tile hint right after framebuffer creation, before the first frame. This ensures the runtime has tile information available from the start.

Check for extension support: Both the OpenXR and Vulkan extensions must be available. If xrGetInstanceProcAddr fails for the OpenXR function or the Vulkan function pointer is null, skip the hint gracefully.

Dynamic rendering: If you use VK_KHR_dynamic_rendering instead of VkFramebuffer, use vkGetDynamicRenderingTilePropertiesQCOM with your VkRenderingInfo to get tile properties.