Vulkan 1.1 is here

A bit later than initially planned Vulkan 1.1 was released to the public yesterday, as usual with day-one driver support by most of the IHVs.

Vulkan 1.1 promoted several extension to the core and also adds interesting new functionality like vendor independent subgroup operations.

You can get all the details at the Khronos Vulkan landing page.

Note that all my open source examples, demos and applications will work fine with Vulkan 1.1 SDK and drivers. I’m already planing to add 1.1 specific functions to the Vulkan Hardware Capability Viewer and my examples.


Conservative rasterization in Vulkan

I have added a new example to my open source C++ Vulkan examples that demonstrates the basic use of conservative rasterization using the VK_EXT_conservative_rasterization extension. This has been missing from Vulkan some time now (while other APIs already offer this feature) but has recently been added and is already support by at least NVIDIA.

Conservative rasterization changes the way fragments are generated, and enabling over estimation generates fragments for every pixel touched instead of only pixels that are fully covered.

Without conservative rasterization:

Conservative rasterization enabled (over estimate):

This technique has multiple use-cases with the most prominent one being voxelization, e.g. as a base for global illumination.

For details see this article on conservative rasterization by NVIDIA.

How-to video: Debugging a non-visible model in Vulkan using RenderDoc

One of the most common Vulkan related that I’m seeing a lot is about rendering stuff that somehow ends up being not visible on the screen, even though technically everything looks okay (no validation layer errors, correct buffer uploads, etc.).

Luckily there are debugging tools tools like RenderDoc that can help locating and fixing such problems. But not everyone knows about such tools or how to use them for debugging these kind of problems.

So I decided to upload a narrated video that shows how to debug non-visible models (in Vulkan) using RenderDoc:

If you’re interested in additional narrated, Vulkan related videos just drop me a line.

Vulkan glTF 2.0 C++ phyiscal based rendering

I have released the first working version of a separate (from the examples) Vulkan physical based rendering example that uses the glTF 2.0 model file format.

The repository can be found at

glTF is a royalty free format specification by the Khronos Group and is a new format for 3D models gaining lots of traction. With version 2.0 it also added several PBR extensions and definitions.

I decided to make this a stand-alone project instead of “just” another example in my Vulkan C++ example repository to make it easier getting into the code. While lots of people seem to learn from my examples they contain a lot of abstraction, and for this example I wanted the code to be very readable and verbose on purpose so those interested in doing PBR with Vulkan and glTF 2.0 get a closer look at the actual code without that much abstraction as was the case for my examples.

So while it still contains a few base classes from my examples, these have been stripped down (e.g. no more initializers) and the main class is pretty verbose and doesn’t do much Vulkan abstraction. I hope this makes it easier to actually get into the relevant Vulkan parts.

Combined Vulkan and OpenGL ES listing for android

Upon popular request I finally got around combining android device data from my Vulkan and OpenGL ES hardware databases into a convenient table. This should be handy if you plan on supporting both apis on Vulkan or if you just need to check for general device support.

The new page can be reached via

It combines all android device reports from the Vulkan database with all reports from the OpenGL ES database and also uses google’s official device list for translating device IDs (stored with Vulkan and OpenGL ES reports) into actual retail names.

Each entry displays the highest supported Vulkan and OpenGL ES version if there is a report present for that device in at least one of the database and also lists what apis are supported by a given device. Clicking on the version opens up the report for this device in the respective database.

So if you just want to see all devices that support (have a report present for) Vulkan and OpenGL ES you can filter by the list of supported apis or just pass this selection as a parameter to the url:,gles


Headless Vulkan examples

I have just added two minimal, mostly self-contained cross-platform headless Vulkan examples to my open source C++ Vulkan repository. Unlike the other examples in my repository these two don’t require a surface (created from a window) and as such can be run on systems with no window compositor.

The intention behind the two examples is to show how Vulkan can be used for running graphics and compute tasks without the need for an actual user interface to be present i.e. in the form of a window, often called “headless mode”. Those could e.g. be run on headless cloud-hosted server instances (like AWS once they add support) with Vulkan support.

Continue reading

The Vulkan Device Simulation Layer

LunarG recently made the new Vulkan Device Simulation layer public. This is a Vulkan instance level layer that injects physical device properties, limits and features based on a json input file, simulating different features than the actual Vulkan device you are running on. The idea behind this is to help developers check if their Vulkan applications can handle devices with missing features and tighter limits without having to actually run on a such a device. It’s not an emulation (like a software rasterizer, e.g. WARP for DirectX) and only affects queries against the device limits and features, so you can’t magically get e.g. tessellation support on a device that doesn’t support it by using this layer.

But still this is a nice addition to the Vulkan eco system and is especially handy for smaller devs that don’t own all the different devices they intend to run their applications on. With this layer you check your fallback paths and how your application handles missing device features.
Continue reading

iOS and macOS support added to the Vulkan examples

Thanks to a contribution from Bill Hollings, one of the developers from MoltenVK , my open source C++ Vulkan examples now also support Apple’s iOS and macOS platforms.

MoltenVK is a commercial Vulkan implementation that runs on top of Apple’s Metal api with a free trial available.

Details on how to build and run the examples for those platforms can be found in this readme.

Note that not all examples will work on iOS or macOS due to the differences in supported features like geometry or tessellation shaders not being available in Metal (1).

Vulkan Hardware Capability Viewer 1.4 released

A new version of the Vulkan Hardware Capability Viewer is now available for all platforms (Windows, Linux, Android). This is the biggest update since I released this tool, including lots of new features that also brought along a few changes to the online database. I also decided to drop the “beta” tag now that more than 1,300 reports have been uploaded, making this the first non-beta release of the Vulkan Hardware Capability viewer.

New features

  • Added support for new features and properties provided via VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2
    • Currently supported:
      • VK_KHR_push_descriptor
      • VK_EXT_discard_rectangles
      • VK_KHX_multiview
      • VK_NVX_multiview_per_view_attributes
  • Reports can now be saved to disk via command line using the -s argument (without invoking the UI)
    • Example : vulkanCapsViewer -s my_device.json
  • Added pipeline cache UUID
  • Exported JSON is now compatible with vkjson_info from LunarG SDK
  • Added Android platform info
    • Device model and manufacturer
    • Build information
  • UI improvements 
    • Updated layout and UI scaling 
    • Support for high DPI scaling
    • Touch scrolling for mobile devices (Android)


  • Fixed unauthorized access to SSL libraries message on Android 6.0 and newer

Continue reading