diff --git a/include/vulkan/layer/vk_layer_settings.h b/include/vulkan/layer/vk_layer_settings.h
index 10deab5..cb0f64a 100644
--- a/include/vulkan/layer/vk_layer_settings.h
+++ b/include/vulkan/layer/vk_layer_settings.h
@@ -15,20 +15,20 @@ extern "C" {
 
 #include "vk_layer_settings_ext.h"
 
-typedef enum VlLayerSettingType {
-    VL_LAYER_SETTING_TYPE_BOOL32 = VK_LAYER_SETTING_TYPE_BOOL32_EXT,
-    VL_LAYER_SETTING_TYPE_INT32 = VK_LAYER_SETTING_TYPE_INT32_EXT,
-    VL_LAYER_SETTING_TYPE_INT64 = VK_LAYER_SETTING_TYPE_INT64_EXT,
-    VL_LAYER_SETTING_TYPE_UINT32 = VK_LAYER_SETTING_TYPE_UINT32_EXT,
-    VL_LAYER_SETTING_TYPE_UINT64 = VK_LAYER_SETTING_TYPE_UINT64_EXT,
-    VL_LAYER_SETTING_TYPE_FLOAT32 = VK_LAYER_SETTING_TYPE_FLOAT32_EXT,
-    VL_LAYER_SETTING_TYPE_FLOAT64 = VK_LAYER_SETTING_TYPE_FLOAT64_EXT,
-    VL_LAYER_SETTING_TYPE_STRING = VK_LAYER_SETTING_TYPE_STRING_EXT,
-    VL_LAYER_SETTING_TYPE_FRAMESET,
-    VL_LAYER_SETTING_TYPE_FRAMESET_STRING
-} VlLayerSettingType;
+typedef enum VkuLayerSettingType {
+    VKU_LAYER_SETTING_TYPE_BOOL32 = VK_LAYER_SETTING_TYPE_BOOL32_EXT,
+    VKU_LAYER_SETTING_TYPE_INT32 = VK_LAYER_SETTING_TYPE_INT32_EXT,
+    VKU_LAYER_SETTING_TYPE_INT64 = VK_LAYER_SETTING_TYPE_INT64_EXT,
+    VKU_LAYER_SETTING_TYPE_UINT32 = VK_LAYER_SETTING_TYPE_UINT32_EXT,
+    VKU_LAYER_SETTING_TYPE_UINT64 = VK_LAYER_SETTING_TYPE_UINT64_EXT,
+    VKU_LAYER_SETTING_TYPE_FLOAT32 = VK_LAYER_SETTING_TYPE_FLOAT32_EXT,
+    VKU_LAYER_SETTING_TYPE_FLOAT64 = VK_LAYER_SETTING_TYPE_FLOAT64_EXT,
+    VKU_LAYER_SETTING_TYPE_STRING = VK_LAYER_SETTING_TYPE_STRING_EXT,
+    VKU_LAYER_SETTING_TYPE_FRAMESET,
+    VKU_LAYER_SETTING_TYPE_FRAMESET_STRING
+} VkuLayerSettingType;
 
-VK_DEFINE_HANDLE(VlLayerSettingSet)
+VK_DEFINE_HANDLE(VkuLayerSettingSet)
 
 // - `first` is an integer related to the first frame to be processed.
 //    The frame numbering is 0-based.
@@ -38,37 +38,37 @@ VK_DEFINE_HANDLE(VlLayerSettingSet)
 //    represent no frame to be processed.
 //    between frames to be processed.
 
-typedef struct VlFrameset {
+typedef struct VkuFrameset {
     uint32_t first;
     uint32_t count;
     uint32_t step;
-} VlFrameset;
+} VkuFrameset;
 
-typedef void (VKAPI_PTR *VlLayerSettingLogCallback)(const char *pSettingName, const char *pMessage);
+typedef void(VKAPI_PTR *VkuLayerSettingLogCallback)(const char *pSettingName, const char *pMessage);
 
 // Create a layer setting set. If 'pCallback' is set to NULL, the messages are outputed to stderr.
-VkResult vlCreateLayerSettingSet(const char *pLayerName, const VkLayerSettingsCreateInfoEXT *pCreateInfo,
-                             const VkAllocationCallbacks *pAllocator, VlLayerSettingLogCallback pCallback,
-                                 VlLayerSettingSet *pLayerSettingSet);
+VkResult vkuCreateLayerSettingSet(const char *pLayerName, const VkLayerSettingsCreateInfoEXT *pCreateInfo,
+                                  const VkAllocationCallbacks *pAllocator, VkuLayerSettingLogCallback pCallback,
+                                  VkuLayerSettingSet *pLayerSettingSet);
 
-void vlDestroyLayerSettingSet(VlLayerSettingSet layerSettingSet, const VkAllocationCallbacks *pAllocator);
+void vkuDestroyLayerSettingSet(VkuLayerSettingSet layerSettingSet, const VkAllocationCallbacks *pAllocator);
 
 // Set a compatibility namespace to find layer settings using environment variables
-void vlSetLayerSettingCompatibilityNamespace(VlLayerSettingSet layerSettingSet, const char *name);
+void vkuSetLayerSettingCompatibilityNamespace(VkuLayerSettingSet layerSettingSet, const char *name);
 
 // Check whether a setting was set either programmatically, from vk_layer_settings.txt or an environment variable
-VkBool32 vlHasLayerSetting(VlLayerSettingSet layerSettingSet, const char *pSettingName);
+VkBool32 vkuHasLayerSetting(VkuLayerSettingSet layerSettingSet, const char *pSettingName);
 
 // Query setting values
-VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *pSettingName, VlLayerSettingType type,
-                                 uint32_t *pValueCount, void *pValues);
+VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, VkuLayerSettingType type,
+                                  uint32_t *pValueCount, void *pValues);
 
 // Find the VkLayerSettingsCreateInfoEXT in the VkInstanceCreateInfo pNext chain, return NULL if not present
-const VkLayerSettingsCreateInfoEXT *vlFindLayerSettingsCreateInfo(const VkInstanceCreateInfo *pCreateInfo);
+const VkLayerSettingsCreateInfoEXT *vkuFindLayerSettingsCreateInfo(const VkInstanceCreateInfo *pCreateInfo);
 
 // Return the list of Unknown setting in VkLayerSettingsCreateInfoEXT
-VkResult vlGetUnknownSettings(const VkLayerSettingsCreateInfoEXT *pCreateInfo, uint32_t settingsCount, const char **pSettings,
-                              uint32_t *pUnknownSettingCount, const char **pUnknownSettings);
+VkResult vkuGetUnknownSettings(const VkLayerSettingsCreateInfoEXT *pCreateInfo, uint32_t settingsCount, const char **pSettings,
+                               uint32_t *pUnknownSettingCount, const char **pUnknownSettings);
 
 #ifdef __cplusplus
 }
diff --git a/include/vulkan/layer/vk_layer_settings.hpp b/include/vulkan/layer/vk_layer_settings.hpp
index 7258307..feade48 100644
--- a/include/vulkan/layer/vk_layer_settings.hpp
+++ b/include/vulkan/layer/vk_layer_settings.hpp
@@ -13,67 +13,50 @@
 #include <vector>
 #include <string>
 
-void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet,
-    const char *pSettingName, bool &settingValue);
+void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, bool &settingValue);
 
-void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet,
-    const char *pSettingName, std::vector <bool> &settingValues);
+void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<bool> &settingValues);
 
-void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet,
-    const char *pSettingName, int32_t &settingValue);
+void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, int32_t &settingValue);
 
-void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet,
-    const char *pSettingName, std::vector<int32_t> &settingValues);
+void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<int32_t> &settingValues);
 
-void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet,
-    const char *pSettingName, int64_t &settingValue);
+void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, int64_t &settingValue);
 
-void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet,
-    const char *pSettingName, std::vector<int64_t> &settingValues);
+void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<int64_t> &settingValues);
 
-void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet,
-    const char *pSettingName, uint32_t &settingValue);
+void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, uint32_t &settingValue);
 
-void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet,
-    const char *pSettingName, std::vector<uint32_t> &settingValues);
+void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<uint32_t> &settingValues);
 
-void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet,
-    const char *pSettingName, uint64_t &settingValue);
+void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, uint64_t &settingValue);
 
-void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet,
-    const char *pSettingName, std::vector<uint64_t> &settingValues);
+void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<uint64_t> &settingValues);
 
-void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet,
-    const char *pSettingName, float &settingValue);
+void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, float &settingValue);
 
-void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet,
-    const char *pSettingName, std::vector<float> &settingValues);
+void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<float> &settingValues);
 
-void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet,
-    const char *pSettingName, double &settingValue);
+void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, double &settingValue);
 
-void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet,
-    const char *pSettingName, std::vector<double> &settingValues);
+void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<double> &settingValues);
 
-void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet,
-    const char *pSettingName, std::string &settingValue);
+void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::string &settingValue);
 
-void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet,
-    const char *pSettingName, std::vector<std::string> &settingValues);
+void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
+                              std::vector<std::string> &settingValues);
 
-void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet,
-    const char *pSettingName, VlFrameset &settingValue);
+void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, VkuFrameset &settingValue);
 
-void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet,
-    const char *pSettingName, std::vector<VlFrameset> &settingValues);
+void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
+                              std::vector<VkuFrameset> &settingValues);
 
 // Required by vk_safe_struct
-typedef std::pair<uint32_t, uint32_t> VlCustomSTypeInfo;
+typedef std::pair<uint32_t, uint32_t> VkuCustomSTypeInfo;
 
-void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet,
-    const char *pSettingName,
-    std::vector<VlCustomSTypeInfo> &settingValues);
+void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
+                              std::vector<VkuCustomSTypeInfo> &settingValues);
 
 // Return the list of Unknown setting in VkLayerSettingsCreateInfoEXT
-VkResult vlGetUnknownSettings(const VkLayerSettingsCreateInfoEXT *pCreateInfo, uint32_t settingsCount, const char **pSettings,
-                              std::vector<const char *>& unknownSettings);
+VkResult vkuGetUnknownSettings(const VkLayerSettingsCreateInfoEXT *pCreateInfo, uint32_t settingsCount, const char **pSettings,
+                               std::vector<const char *> &unknownSettings);
diff --git a/src/layer/layer_settings_manager.cpp b/src/layer/layer_settings_manager.cpp
index 39ba31c..57b8f4a 100644
--- a/src/layer/layer_settings_manager.cpp
+++ b/src/layer/layer_settings_manager.cpp
@@ -101,7 +101,7 @@ static void AddWorkaroundLayerNames(std::vector<std::string> &layer_names) {
 namespace vl {
 
 LayerSettings::LayerSettings(const char *pLayerName, const VkLayerSettingsCreateInfoEXT *pCreateInfo,
-                             const VkAllocationCallbacks *pAllocator, VlLayerSettingLogCallback pCallback)
+                             const VkAllocationCallbacks *pAllocator, VkuLayerSettingLogCallback pCallback)
     : layer_name(pLayerName)
     , create_info(pCreateInfo)
     , pCallback(pCallback) {
diff --git a/src/layer/layer_settings_manager.hpp b/src/layer/layer_settings_manager.hpp
index 74dab5c..5a03f9e 100644
--- a/src/layer/layer_settings_manager.hpp
+++ b/src/layer/layer_settings_manager.hpp
@@ -19,7 +19,7 @@ namespace vl {
     class LayerSettings {
       public:
         LayerSettings(const char *pLayerName, const VkLayerSettingsCreateInfoEXT *pCreateInfo,
-                      const VkAllocationCallbacks *pAllocator, VlLayerSettingLogCallback pCallback);
+                      const VkAllocationCallbacks *pAllocator, VkuLayerSettingLogCallback pCallback);
         ~LayerSettings();
 
         void SetPrefix(const char *pPrefix) { this->prefix = pPrefix; }
@@ -57,7 +57,7 @@ namespace vl {
         std::string prefix;
         std::string layer_name;
         const VkLayerSettingsCreateInfoEXT *create_info{nullptr};
-        VlLayerSettingLogCallback pCallback{nullptr};
+        VkuLayerSettingLogCallback pCallback{nullptr};
     };
 }// namespace vl
 
diff --git a/src/layer/layer_settings_util.cpp b/src/layer/layer_settings_util.cpp
index e0c2f38..08ca78b 100644
--- a/src/layer/layer_settings_util.cpp
+++ b/src/layer/layer_settings_util.cpp
@@ -209,10 +209,10 @@ int64_t ToInt64(const std::string &token) {
     return int_id;
 }
 
-VlFrameset ToFrameSet(const std::string &s) {
+VkuFrameset ToFrameSet(const std::string &s) {
     assert(IsFrameSets(s));
 
-    VlFrameset frameset{0, 1, 1};
+    VkuFrameset frameset{0, 1, 1};
 
     const std::vector<std::string> &frameset_split = vl::Split(s, '-');
     if (frameset_split.size() >= 1) {
@@ -228,10 +228,10 @@ VlFrameset ToFrameSet(const std::string &s) {
     return frameset;
 }
 
-std::vector<VlFrameset> ToFrameSets(const std::string &s) {
+std::vector<VkuFrameset> ToFrameSets(const std::string &s) {
     std::vector<std::string> tokens = Split(s, FindDelimiter(s));
 
-    std::vector<VlFrameset> results;
+    std::vector<VkuFrameset> results;
     results.resize(tokens.size());
     for (std::size_t i = 0, n = tokens.size(); i < n; ++i) {
         results[i] = ToFrameSet(tokens[i]);
diff --git a/src/layer/layer_settings_util.hpp b/src/layer/layer_settings_util.hpp
index 957773a..83c7557 100644
--- a/src/layer/layer_settings_util.hpp
+++ b/src/layer/layer_settings_util.hpp
@@ -62,9 +62,9 @@ namespace vl {
 
     bool IsFrameSets(const std::string &s);
 
-    VlFrameset ToFrameSet(const std::string &s);
+    VkuFrameset ToFrameSet(const std::string &s);
 
-    std::vector<VlFrameset> ToFrameSets(const std::string &s);
+    std::vector<VkuFrameset> ToFrameSets(const std::string &s);
 
     bool IsInteger(const std::string &s);
 
diff --git a/src/layer/vk_layer_settings.cpp b/src/layer/vk_layer_settings.cpp
index f9295b8..bfb6a6e 100644
--- a/src/layer/vk_layer_settings.cpp
+++ b/src/layer/vk_layer_settings.cpp
@@ -20,7 +20,7 @@
 #include <unordered_map>
 
 // This is used only for unit tests in test_layer_setting_file
-void test_helper_SetLayerSetting(VlLayerSettingSet layerSettingSet, const char *pSettingName, const char *pValue) {
+void test_helper_SetLayerSetting(VkuLayerSettingSet layerSettingSet, const char *pSettingName, const char *pValue) {
     assert(layerSettingSet != VK_NULL_HANDLE);
     assert(pSettingName != nullptr);
     assert(pValue != nullptr);
@@ -30,31 +30,31 @@ void test_helper_SetLayerSetting(VlLayerSettingSet layerSettingSet, const char *
     layer_setting_set->SetFileSetting(pSettingName, pValue);
 }
 
-VkResult vlCreateLayerSettingSet(const char *pLayerName, const VkLayerSettingsCreateInfoEXT *pCreateInfo,
-                                 const VkAllocationCallbacks *pAllocator, VlLayerSettingLogCallback pCallback,
-    VlLayerSettingSet *pLayerSettingSet) {
+VkResult vkuCreateLayerSettingSet(const char *pLayerName, const VkLayerSettingsCreateInfoEXT *pCreateInfo,
+                                 const VkAllocationCallbacks *pAllocator, VkuLayerSettingLogCallback pCallback,
+    VkuLayerSettingSet *pLayerSettingSet) {
     (void)pAllocator;
 
     vl::LayerSettings* layer_setting_set = new vl::LayerSettings(pLayerName, pCreateInfo, pAllocator, pCallback);
-    *pLayerSettingSet = (VlLayerSettingSet)layer_setting_set;
+    *pLayerSettingSet = (VkuLayerSettingSet)layer_setting_set;
 
     return VK_SUCCESS;
 }
 
-void vlDestroyLayerSettingSet(VlLayerSettingSet layerSettingSet, const VkAllocationCallbacks *pAllocator) {
+void vkuDestroyLayerSettingSet(VkuLayerSettingSet layerSettingSet, const VkAllocationCallbacks *pAllocator) {
     (void)pAllocator;
 
     vl::LayerSettings *layer_setting_set = (vl::LayerSettings*)layerSettingSet;
     delete layer_setting_set;
 }
 
-void vlSetLayerSettingCompatibilityNamespace(VlLayerSettingSet layerSettingSet, const char *prefixName) {
+void vkuSetLayerSettingCompatibilityNamespace(VkuLayerSettingSet layerSettingSet, const char *prefixName) {
     vl::LayerSettings *layer_setting_set = (vl::LayerSettings *)layerSettingSet;
 
     layer_setting_set->SetPrefix(prefixName);
 }
 
-VkBool32 vlHasLayerSetting(VlLayerSettingSet layerSettingSet, const char *pSettingName) {
+VkBool32 vkuHasLayerSetting(VkuLayerSettingSet layerSettingSet, const char *pSettingName) {
     assert(layerSettingSet != VK_NULL_HANDLE);
     assert(pSettingName);
     assert(!std::string(pSettingName).empty());
@@ -68,7 +68,7 @@ VkBool32 vlHasLayerSetting(VlLayerSettingSet layerSettingSet, const char *pSetti
     return (has_env_setting || has_file_setting || has_api_setting) ? VK_TRUE : VK_FALSE;
 }
 
-VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *pSettingName, VlLayerSettingType type,
+VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, VkuLayerSettingType type,
                                  uint32_t *pValueCount, void *pValues) {
     assert(pValueCount != nullptr);
 
@@ -76,7 +76,7 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
         return VK_ERROR_INITIALIZATION_FAILED;
     }
 
-    if (!vlHasLayerSetting(layerSettingSet, pSettingName)) {
+    if (!vkuHasLayerSetting(layerSettingSet, pSettingName)) {
         *pValueCount = 0;
         return VK_SUCCESS;
     }
@@ -114,7 +114,7 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
             layer_setting_set->Log(pSettingName, message.c_str());
             return VK_ERROR_UNKNOWN;
         }
-        case VL_LAYER_SETTING_TYPE_BOOL32: {
+        case VKU_LAYER_SETTING_TYPE_BOOL32: {
             std::vector<VkBool32> values;
             VkResult result = VK_SUCCESS;
 
@@ -143,7 +143,7 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
                     *pValueCount = static_cast<std::uint32_t>(settings.size());
                 }
             } else if (api_setting != nullptr) { // From Vulkan Layer Setting API
-                if (static_cast<VlLayerSettingType>(api_setting->type) != type) {
+                if (static_cast<VkuLayerSettingType>(api_setting->type) != type) {
                     result = VK_ERROR_FORMAT_NOT_SUPPORTED;
                 } else if (copy_values) {
                     if (*pValueCount < api_setting->count) {
@@ -163,7 +163,7 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
 
             return result;
         }
-        case VL_LAYER_SETTING_TYPE_INT32: {
+        case VKU_LAYER_SETTING_TYPE_INT32: {
             std::vector<std::int32_t> values;
             VkResult result = VK_SUCCESS;
 
@@ -188,7 +188,7 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
                     *pValueCount = static_cast<std::uint32_t>(settings.size());
                 }
             } else if (api_setting != nullptr) {  // From Vulkan Layer Setting API
-                if (static_cast<VlLayerSettingType>(api_setting->type) != type) {
+                if (static_cast<VkuLayerSettingType>(api_setting->type) != type) {
                     result = VK_ERROR_FORMAT_NOT_SUPPORTED;
                 } else if (copy_values) {
                     if (*pValueCount < api_setting->count) {
@@ -208,7 +208,7 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
 
             return result;
         }
-        case VL_LAYER_SETTING_TYPE_INT64: {
+        case VKU_LAYER_SETTING_TYPE_INT64: {
             std::vector<std::int64_t> values;
             VkResult result = VK_SUCCESS;
 
@@ -233,7 +233,7 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
                     *pValueCount = static_cast<std::uint32_t>(settings.size());
                 }
             } else if (api_setting != nullptr) {  // From Vulkan Layer Setting API
-                if (static_cast<VlLayerSettingType>(api_setting->type) != type) {
+                if (static_cast<VkuLayerSettingType>(api_setting->type) != type) {
                     result = VK_ERROR_FORMAT_NOT_SUPPORTED;
                 } else if (copy_values) {
                     if (*pValueCount < api_setting->count) {
@@ -253,7 +253,7 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
 
             return result;
         }
-        case VL_LAYER_SETTING_TYPE_UINT32: {
+        case VKU_LAYER_SETTING_TYPE_UINT32: {
             std::vector<std::uint32_t> values;
             VkResult result = VK_SUCCESS;
 
@@ -278,7 +278,7 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
                     *pValueCount = static_cast<std::uint32_t>(settings.size());
                 }
             } else if (api_setting != nullptr) {  // From Vulkan Layer Setting API
-                if (static_cast<VlLayerSettingType>(api_setting->type) != type) {
+                if (static_cast<VkuLayerSettingType>(api_setting->type) != type) {
                     result = VK_ERROR_FORMAT_NOT_SUPPORTED;
                 } else if (copy_values) {
                     if (*pValueCount < api_setting->count) {
@@ -298,7 +298,7 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
 
             return result;
         }
-        case VL_LAYER_SETTING_TYPE_UINT64: {
+        case VKU_LAYER_SETTING_TYPE_UINT64: {
             std::vector<std::uint64_t> values;
             VkResult result = VK_SUCCESS;
 
@@ -323,7 +323,7 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
                     *pValueCount = static_cast<std::uint32_t>(settings.size());
                 }
             } else if (api_setting != nullptr) {  // From Vulkan Layer Setting API
-                if (static_cast<VlLayerSettingType>(api_setting->type) != type) {
+                if (static_cast<VkuLayerSettingType>(api_setting->type) != type) {
                     result = VK_ERROR_FORMAT_NOT_SUPPORTED;
                 } else if (copy_values) {
                     if (*pValueCount < api_setting->count) {
@@ -343,7 +343,7 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
 
             return result;
         }
-        case VL_LAYER_SETTING_TYPE_FLOAT32: {
+        case VKU_LAYER_SETTING_TYPE_FLOAT32: {
             std::vector<float> values;
             VkResult result = VK_SUCCESS;
 
@@ -368,7 +368,7 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
                     *pValueCount = static_cast<std::uint32_t>(settings.size());
                 }
             } else if (api_setting != nullptr) {  // From Vulkan Layer Setting API
-                if (static_cast<VlLayerSettingType>(api_setting->type) != type) {
+                if (static_cast<VkuLayerSettingType>(api_setting->type) != type) {
                     result = VK_ERROR_FORMAT_NOT_SUPPORTED;
                 } else if (copy_values) {
                     if (*pValueCount < api_setting->count) {
@@ -388,7 +388,7 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
 
             return result;
         }
-        case VL_LAYER_SETTING_TYPE_FLOAT64: {
+        case VKU_LAYER_SETTING_TYPE_FLOAT64: {
             std::vector<double> values;
             VkResult result = VK_SUCCESS;
 
@@ -413,7 +413,7 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
                     *pValueCount = static_cast<std::uint32_t>(settings.size());
                 }
             } else if (api_setting != nullptr) {  // From Vulkan Layer Setting API
-                if (static_cast<VlLayerSettingType>(api_setting->type) != type) {
+                if (static_cast<VkuLayerSettingType>(api_setting->type) != type) {
                     result = VK_ERROR_FORMAT_NOT_SUPPORTED;
                 } else if (copy_values) {
                     if (*pValueCount < api_setting->count) {
@@ -433,8 +433,8 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
 
             return result;
         }
-        case VL_LAYER_SETTING_TYPE_FRAMESET: {
-            std::vector<VlFrameset> values;
+        case VKU_LAYER_SETTING_TYPE_FRAMESET: {
+            std::vector<VkuFrameset> values;
             VkResult result = VK_SUCCESS;
 
             if (!settings.empty()) {  // From env variable or setting file
@@ -458,7 +458,7 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
                     *pValueCount = static_cast<std::uint32_t>(settings.size());
                 }
             } else if (api_setting != nullptr) {  // From Vulkan Layer Setting API
-                const uint32_t frameset_count = static_cast<uint32_t>(api_setting->count / (sizeof(VlFrameset) / sizeof(VlFrameset::count)));
+                const uint32_t frameset_count = static_cast<uint32_t>(api_setting->count / (sizeof(VkuFrameset) / sizeof(VkuFrameset::count)));
                 if (api_setting->type != VK_LAYER_SETTING_TYPE_UINT32_EXT) {
                     result = VK_ERROR_FORMAT_NOT_SUPPORTED;
                 } else if (copy_values) {
@@ -466,7 +466,7 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
                         result = VK_INCOMPLETE;
                     }
                     const std::uint32_t count = std::min(*pValueCount, frameset_count);
-                    const VlFrameset *data = static_cast<const VlFrameset *>(api_setting->pValues);
+                    const VkuFrameset *data = static_cast<const VkuFrameset *>(api_setting->pValues);
                     values.assign(data, data + count);
                 } else {
                     *pValueCount = frameset_count;
@@ -474,12 +474,12 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
             }
 
             if (copy_values) {
-                std::copy(values.begin(), values.end(), reinterpret_cast<VlFrameset *>(pValues));
+                std::copy(values.begin(), values.end(), reinterpret_cast<VkuFrameset *>(pValues));
             }
 
             return result;
         }
-        case VL_LAYER_SETTING_TYPE_STRING: {
+        case VKU_LAYER_SETTING_TYPE_STRING: {
             VkResult result = VK_SUCCESS;
 
             std::vector<std::string> &settings_cache = layer_setting_set->GetSettingCache(pSettingName);
@@ -561,7 +561,7 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
 
             return result;
         }
-        case VL_LAYER_SETTING_TYPE_FRAMESET_STRING: {
+        case VKU_LAYER_SETTING_TYPE_FRAMESET_STRING: {
             VkResult result = VK_SUCCESS;
 
             std::vector<std::string> &settings_cache = layer_setting_set->GetSettingCache(pSettingName);
@@ -578,7 +578,7 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
                 }
             } else if (api_setting != nullptr) {  // From Vulkan Layer Setting API
                 const std::uint32_t frameset_count =
-                    static_cast<uint32_t>(api_setting->count / (sizeof(VlFrameset) / sizeof(VlFrameset::count)));
+                    static_cast<uint32_t>(api_setting->count / (sizeof(VkuFrameset) / sizeof(VkuFrameset::count)));
 
                 if (copy_values) {
                     if (*pValueCount < frameset_count) {
@@ -595,7 +595,7 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
                             break;
                         case VK_LAYER_SETTING_TYPE_UINT32_EXT:
                             for (std::size_t i = 0, n = settings_cache.size(); i < n; ++i) {
-                                const VlFrameset *asFramesets = static_cast<const VlFrameset *>(api_setting->pValues);
+                                const VkuFrameset *asFramesets = static_cast<const VkuFrameset *>(api_setting->pValues);
                                 settings_cache[i] = vl::FormatString("%d-%d-%d",
                                     asFramesets[i].first, asFramesets[i].count, asFramesets[i].step);
                             }
@@ -620,7 +620,7 @@ VkResult vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *
     }
 }
 
-const VkLayerSettingsCreateInfoEXT *vlFindLayerSettingsCreateInfo(const VkInstanceCreateInfo *pCreateInfo) {
+const VkLayerSettingsCreateInfoEXT *vkuFindLayerSettingsCreateInfo(const VkInstanceCreateInfo *pCreateInfo) {
     const VkBaseOutStructure *current = reinterpret_cast<const VkBaseOutStructure *>(pCreateInfo);
     const VkLayerSettingsCreateInfoEXT *found = nullptr;
     while (current) {
@@ -644,7 +644,7 @@ static bool vlHasSetting(uint32_t settingsCount, const char **pSettings, const c
     return false;
 }
 
-VkResult vlGetUnknownSettings(const VkLayerSettingsCreateInfoEXT* pCreateInfo, uint32_t settingsCount, const char** pSettings,
+VkResult vkuGetUnknownSettings(const VkLayerSettingsCreateInfoEXT* pCreateInfo, uint32_t settingsCount, const char** pSettings,
     uint32_t* pUnknownSettingCount, const char** pUnknownSettings) {
     assert(pUnknownSettingCount != nullptr);
 
@@ -672,15 +672,15 @@ VkResult vlGetUnknownSettings(const VkLayerSettingsCreateInfoEXT* pCreateInfo, u
     return VK_SUCCESS;
 }
 
-VkResult vlGetUnknownSettings(const VkLayerSettingsCreateInfoEXT* pCreateInfo, uint32_t settingsCount, const char** pSettings,
+VkResult vkuGetUnknownSettings(const VkLayerSettingsCreateInfoEXT* pCreateInfo, uint32_t settingsCount, const char** pSettings,
     std::vector<const char*>& unknownSettings) {
     uint32_t unknown_setting_count = 0;
-    VkResult result = vlGetUnknownSettings(pCreateInfo, settingsCount, pSettings, &unknown_setting_count, nullptr);
+    VkResult result = vkuGetUnknownSettings(pCreateInfo, settingsCount, pSettings, &unknown_setting_count, nullptr);
 
     if (unknown_setting_count > 0) {
         unknownSettings.resize(unknown_setting_count);
 
-        result = vlGetUnknownSettings(pCreateInfo, settingsCount, pSettings, &unknown_setting_count, &unknownSettings[0]);
+        result = vkuGetUnknownSettings(pCreateInfo, settingsCount, pSettings, &unknown_setting_count, &unknownSettings[0]);
     }
 
     return result;
diff --git a/src/layer/vk_layer_settings_helper.cpp b/src/layer/vk_layer_settings_helper.cpp
index 910cf32..4bbc72a 100644
--- a/src/layer/vk_layer_settings_helper.cpp
+++ b/src/layer/vk_layer_settings_helper.cpp
@@ -21,136 +21,136 @@ static std::string Merge(const std::vector<std::string> &strings) {
     return result;
 }
 
-void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, const char *pSettingName, bool &settingValue) {
+void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, bool &settingValue) {
     uint32_t value_count = 1;
     VkBool32 pValues;
-    vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_BOOL32, &value_count, &pValues);
+    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_BOOL32, &value_count, &pValues);
     settingValue = pValues == VK_TRUE;
 }
 
-void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<bool> &settingValues) {
+void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<bool> &settingValues) {
     uint32_t value_count = 0;
-    vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_BOOL32, &value_count, nullptr);
+    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_BOOL32, &value_count, nullptr);
     if (value_count > 0) {
         std::vector<VkBool32> values(value_count);
-        vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_BOOL32, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_BOOL32, &value_count, &values[0]);
         for (std::size_t i = 0, n = values.size(); i < n; ++i) {
             settingValues.push_back(values[i] == VK_TRUE);
         }
     }
 }
 
-void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, const char *pSettingName, int32_t &settingValue) {
+void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, int32_t &settingValue) {
     uint32_t value_count = 1;
-    vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_INT32, &value_count, &settingValue);
+    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_INT32, &value_count, &settingValue);
 }
 
-void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<int32_t> &settingValues) {
+void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<int32_t> &settingValues) {
     uint32_t value_count = 1;
-    vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_INT32, &value_count, nullptr);
+    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_INT32, &value_count, nullptr);
     if (value_count > 0) {
         settingValues.resize(static_cast<std::size_t>(value_count));
-        vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_INT32, &value_count, &settingValues[0]);
+        vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_INT32, &value_count, &settingValues[0]);
     }
 }
 
-void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, const char *pSettingName, int64_t &settingValue) {
+void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, int64_t &settingValue) {
     uint32_t value_count = 1;
-    vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_INT64, &value_count, &settingValue);
+    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_INT64, &value_count, &settingValue);
 }
 
-void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<int64_t> &settingValues) {
+void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<int64_t> &settingValues) {
     uint32_t value_count = 1;
-    vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_INT64, &value_count, nullptr);
+    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_INT64, &value_count, nullptr);
     if (value_count > 0) {
         settingValues.resize(static_cast<std::size_t>(value_count));
-        vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_INT64, &value_count, &settingValues[0]);
+        vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_INT64, &value_count, &settingValues[0]);
     }
 }
 
-void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, const char *pSettingName, uint32_t &settingValue) {
+void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, uint32_t &settingValue) {
     uint32_t value_count = 1;
-    vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_UINT32, &value_count, &settingValue);
+    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &settingValue);
 }
 
-void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<uint32_t> &settingValues) {
+void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<uint32_t> &settingValues) {
     uint32_t value_count = 1;
-    vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_UINT32, &value_count, nullptr);
+    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT32, &value_count, nullptr);
     if (value_count > 0) {
         settingValues.resize(static_cast<std::size_t>(value_count));
-        vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_UINT32, &value_count, &settingValues[0]);
+        vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &settingValues[0]);
     }
 }
 
-void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, const char *pSettingName, uint64_t &settingValue) {
+void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, uint64_t &settingValue) {
     uint32_t value_count = 1;
-    vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_UINT64, &value_count, &settingValue);
+    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT64, &value_count, &settingValue);
 }
 
-void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<uint64_t> &settingValues) {
+void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<uint64_t> &settingValues) {
     uint32_t value_count = 1;
-    vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_UINT64, &value_count, nullptr);
+    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT64, &value_count, nullptr);
     if (value_count > 0) {
         settingValues.resize(static_cast<std::size_t>(value_count));
-        vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_UINT64, &value_count, &settingValues[0]);
+        vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT64, &value_count, &settingValues[0]);
     }
 }
 
-void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, const char *pSettingName, float &settingValue) {
+void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, float &settingValue) {
     uint32_t value_count = 1;
-    vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_FLOAT32, &value_count, &settingValue);
+    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_FLOAT32, &value_count, &settingValue);
 }
 
-void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<float> &settingValues) {
+void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<float> &settingValues) {
     uint32_t value_count = 1;
-    vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_FLOAT32, &value_count, nullptr);
+    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_FLOAT32, &value_count, nullptr);
     if (value_count > 0) {
         settingValues.resize(static_cast<std::size_t>(value_count));
-        vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_FLOAT32, &value_count, &settingValues[0]);
+        vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_FLOAT32, &value_count, &settingValues[0]);
     }
 }
 
-void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, const char *pSettingName, double &settingValue) {
+void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, double &settingValue) {
     uint32_t value_count = 1;
-    vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_FLOAT64, &value_count, &settingValue);
+    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_FLOAT64, &value_count, &settingValue);
 }
 
-void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<double> &settingValues) {
+void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<double> &settingValues) {
     uint32_t value_count = 1;
-    vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_FLOAT64, &value_count, nullptr);
+    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_FLOAT64, &value_count, nullptr);
     if (value_count > 0) {
         settingValues.resize(static_cast<std::size_t>(value_count));
-        vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_FLOAT64, &value_count, &settingValues[0]);
+        vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_FLOAT64, &value_count, &settingValues[0]);
     }
 }
 
-void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, const char *pSettingName, std::string &settingValue) {
+void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::string &settingValue) {
     std::vector<std::string> values;
-    vlGetLayerSettingValues(layerSettingSet, pSettingName, values);
+    vkuGetLayerSettingValues(layerSettingSet, pSettingName, values);
     settingValue = Merge(values);
 }
 
-void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<std::string> &settingValues) {
+void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<std::string> &settingValues) {
     uint32_t value_count = 0;
-    vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_STRING, &value_count, nullptr);
+    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_STRING, &value_count, nullptr);
     if (value_count > 0) {
         std::vector<const char *> values(value_count);
-        vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_STRING, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_STRING, &value_count, &values[0]);
         settingValues.assign(values.begin(), values.end());
     }
 }
 
-void vlGetLayerSettingValue(VlLayerSettingSet layerSettingSet, const char* pSettingName, VlFrameset& settingValue) {
-    uint32_t value_count = sizeof(VlFrameset) / sizeof(VlFrameset::count);
-    vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_UINT32, &value_count, &settingValue);
+void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char* pSettingName, VkuFrameset& settingValue) {
+    uint32_t value_count = sizeof(VkuFrameset) / sizeof(VkuFrameset::count);
+    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &settingValue);
 }
 
-void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<VlFrameset> &settingValues) {
+void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<VkuFrameset> &settingValues) {
     uint32_t value_count = 0;
-    vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_UINT32, &value_count, nullptr);
+    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT32, &value_count, nullptr);
     if (value_count > 0) {
-        settingValues.resize(static_cast<std::size_t>(value_count) / (sizeof(VlFrameset) / sizeof(VlFrameset::count)));
-        vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_UINT32, &value_count, &settingValues[0]);
+        settingValues.resize(static_cast<std::size_t>(value_count) / (sizeof(VkuFrameset) / sizeof(VkuFrameset::count)));
+        vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &settingValues[0]);
     }
 }
 
@@ -164,7 +164,7 @@ static uint32_t TokenToUint(const std::string &token) {
     return int_id;
 }
 
-static void SetCustomStypeInfo(std::vector<const char *> raw_id_list, std::vector<VlCustomSTypeInfo>& custom_stype_info) {
+static void SetCustomStypeInfo(std::vector<const char *> raw_id_list, std::vector<VkuCustomSTypeInfo>& custom_stype_info) {
     // List format is a list of integer pairs
     for (std::size_t i = 0, n = raw_id_list.size(); i < n; i += 2) {
         uint32_t stype_id = TokenToUint(raw_id_list[i + 0]);
@@ -184,12 +184,12 @@ static void SetCustomStypeInfo(std::vector<const char *> raw_id_list, std::vecto
     }
 }
 
-void vlGetLayerSettingValues(VlLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<VlCustomSTypeInfo> &settingValues) {
+void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<VkuCustomSTypeInfo> &settingValues) {
     uint32_t value_count = 0;
-    vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_STRING, &value_count, nullptr);
+    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_STRING, &value_count, nullptr);
     if (value_count > 0) {
         std::vector<const char *> values(value_count);
-        vlGetLayerSettingValues(layerSettingSet, pSettingName, VL_LAYER_SETTING_TYPE_STRING, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_STRING, &value_count, &values[0]);
         SetCustomStypeInfo(values, settingValues);
     }
 }
diff --git a/tests/add_subdirectory/vk_layer_settings.c b/tests/add_subdirectory/vk_layer_settings.c
index b15b041..b90b328 100644
--- a/tests/add_subdirectory/vk_layer_settings.c
+++ b/tests/add_subdirectory/vk_layer_settings.c
@@ -6,12 +6,12 @@
 #include <vulkan/layer/vk_layer_settings.h>
 
 VkBool32 vk_layer_settings() {
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", NULL, NULL, NULL, &layerSettingSet);
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", NULL, NULL, NULL, &layerSettingSet);
 
-    VkBool32 result = vlHasLayerSetting(layerSettingSet, "setting_key") ? VK_TRUE : VK_FALSE;
+    VkBool32 result = vkuHasLayerSetting(layerSettingSet, "setting_key") ? VK_TRUE : VK_FALSE;
 
-    vlDestroyLayerSettingSet(layerSettingSet, NULL);
+    vkuDestroyLayerSettingSet(layerSettingSet, NULL);
 
     return result;
 }
diff --git a/tests/layer/test_setting_api.cpp b/tests/layer/test_setting_api.cpp
index eecb9a9..5b16a05 100644
--- a/tests/layer/test_setting_api.cpp
+++ b/tests/layer/test_setting_api.cpp
@@ -10,17 +10,17 @@
 
 #include "vulkan/layer/vk_layer_settings.h"
 
-TEST(test_layer_setting_api, vlHasLayerSetting_NotFound) {
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+TEST(test_layer_setting_api, vkuHasLayerSetting_NotFound) {
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
 
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
 
-    EXPECT_FALSE(vlHasLayerSetting(layerSettingSet, "setting_key"));
+    EXPECT_FALSE(vkuHasLayerSetting(layerSettingSet, "setting_key"));
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_api, vlHasLayerSetting_Found) {
+TEST(test_layer_setting_api, vkuHasLayerSetting_Found) {
     std::int32_t pValues = 76;
 
     VkLayerSettingEXT my_setting;
@@ -36,15 +36,15 @@ TEST(test_layer_setting_api, vlHasLayerSetting_Found) {
     VkLayerSettingsCreateInfoEXT layer_settings_create_info{
         VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
 
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_api, vlHasLayerSetting) {
+TEST(test_layer_setting_api, vkuHasLayerSetting) {
     // The expected application code side:
     std::vector<VkLayerSettingEXT> settings;
 
@@ -111,13 +111,13 @@ TEST(test_layer_setting_api, vlHasLayerSetting) {
     setting_double_value.count = 1;
     settings.push_back(setting_double_value);
 
-    VlFrameset value_frameset{76, 100, 10};
+    VkuFrameset value_frameset{76, 100, 10};
     VkLayerSettingEXT setting_frameset_value{};
     setting_frameset_value.pLayerName = "VK_LAYER_LUNARG_test";
     setting_frameset_value.pSettingName = "frameset_value";
     setting_frameset_value.type = VK_LAYER_SETTING_TYPE_UINT32_EXT;
     setting_frameset_value.pValues = &value_frameset;
-    setting_frameset_value.count = sizeof(VlFrameset) / sizeof(VlFrameset::count);
+    setting_frameset_value.count = sizeof(VkuFrameset) / sizeof(VkuFrameset::count);
     settings.push_back(setting_frameset_value);
 
     VkLayerSettingsCreateInfoEXT layer_settings_create_info;
@@ -127,23 +127,23 @@ TEST(test_layer_setting_api, vlHasLayerSetting) {
     layer_settings_create_info.pSettings = &settings[0];
 
     // The expected layer code side:
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
 
-    EXPECT_FALSE(vlHasLayerSetting(layerSettingSet, "setting0"));
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "bool_value"));
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "int32_value"));
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "int64_value"));
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "uint32_value"));
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "uint64_value"));
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "float_value"));
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "double_value"));
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "frameset_value"));
+    EXPECT_FALSE(vkuHasLayerSetting(layerSettingSet, "setting0"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "bool_value"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "int32_value"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "int64_value"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "uint32_value"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "uint64_value"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "float_value"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "double_value"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "frameset_value"));
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_api, vlGetLayerSettingValues_Bool) {
+TEST(test_layer_setting_api, vkuGetLayerSettingValues_Bool) {
     std::vector<VkBool32> input_values{VK_TRUE, VK_FALSE};
 
     std::vector<VkLayerSettingEXT> settings{
@@ -152,14 +152,14 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Bool) {
     VkLayerSettingsCreateInfoEXT layer_settings_create_info{
         VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
 
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
     uint32_t value_count = 0;
     VkResult result_count =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_BOOL32, &value_count, nullptr);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_BOOL32, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
     EXPECT_EQ(2, value_count);
 
@@ -167,7 +167,7 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Bool) {
 
     value_count = 1;
     VkResult result_incomplete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_BOOL32, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_BOOL32, &value_count, &values[0]);
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_EQ(VK_TRUE, values[0]);
     EXPECT_EQ(VK_FALSE, values[1]);
@@ -175,16 +175,16 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Bool) {
 
     value_count = 2;
     VkResult result_complete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_BOOL32, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_BOOL32, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(VK_TRUE, values[0]);
     EXPECT_EQ(VK_FALSE, values[1]);
     EXPECT_EQ(2, value_count);
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_api, vlGetLayerSettingValues_Int32) {
+TEST(test_layer_setting_api, vkuGetLayerSettingValues_Int32) {
     std::vector<std::int32_t> input_values{76, -82};
 
     std::vector<VkLayerSettingEXT> settings{
@@ -193,14 +193,14 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Int32) {
     VkLayerSettingsCreateInfoEXT layer_settings_create_info{
         VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
 
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
     uint32_t value_count = 2;
     VkResult result_count =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_INT32, &value_count, nullptr);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_INT32, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
     EXPECT_EQ(2, value_count);
 
@@ -208,7 +208,7 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Int32) {
 
     value_count = 1;
     VkResult result_incomplete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_INT32, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_INT32, &value_count, &values[0]);
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(0, values[1]);
@@ -216,16 +216,16 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Int32) {
 
     value_count = 2;
     VkResult result_complete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_INT32, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_INT32, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(-82, values[1]);
     EXPECT_EQ(2, value_count);
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_api, vlGetLayerSettingValues_Int64) {
+TEST(test_layer_setting_api, vkuGetLayerSettingValues_Int64) {
     std::vector<std::int64_t> input_values{76, -82};
 
     std::vector<VkLayerSettingEXT> settings{
@@ -234,14 +234,14 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Int64) {
     VkLayerSettingsCreateInfoEXT layer_settings_create_info{
         VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
 
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
     uint32_t value_count = 2;
     VkResult result_count =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_INT64, &value_count, nullptr);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_INT64, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
     EXPECT_EQ(2, value_count);
 
@@ -249,7 +249,7 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Int64) {
 
     value_count = 1;
     VkResult result_incomplete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_INT64, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_INT64, &value_count, &values[0]);
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(0, values[1]);
@@ -257,16 +257,16 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Int64) {
 
     value_count = 2;
     VkResult result_complete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_INT64, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_INT64, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(-82, values[1]);
     EXPECT_EQ(2, value_count);
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_api, vlGetLayerSettingValues_Uint32) {
+TEST(test_layer_setting_api, vkuGetLayerSettingValues_Uint32) {
     std::vector<std::uint32_t> input_values{76, 82};
 
     std::vector<VkLayerSettingEXT> settings{
@@ -276,14 +276,14 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Uint32) {
     VkLayerSettingsCreateInfoEXT layer_settings_create_info{
         VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
 
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
     uint32_t value_count = 0;
     VkResult result_count =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_UINT32, &value_count, nullptr);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT32, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
     EXPECT_EQ(2, value_count);
 
@@ -291,7 +291,7 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Uint32) {
 
     value_count = 1;
     VkResult result_incomplete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_UINT32, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &values[0]);
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(0, values[1]);
@@ -299,16 +299,16 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Uint32) {
 
     value_count = 2;
     VkResult result_complete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_UINT32, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(82, values[1]);
     EXPECT_EQ(2, value_count);
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_api, vlGetLayerSettingValues_Uint64) {
+TEST(test_layer_setting_api, vkuGetLayerSettingValues_Uint64) {
     std::vector<std::uint64_t> input_values{76, 82};
 
     std::vector<VkLayerSettingEXT> settings{
@@ -318,14 +318,14 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Uint64) {
     VkLayerSettingsCreateInfoEXT layer_settings_create_info{
         VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
 
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
     uint32_t value_count = 0;
     VkResult result_count =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_UINT64, &value_count, nullptr);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT64, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
     EXPECT_EQ(2, value_count);
 
@@ -333,7 +333,7 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Uint64) {
 
     value_count = 1;
     VkResult result_incomplete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_UINT64, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT64, &value_count, &values[0]);
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(0, values[1]);
@@ -341,16 +341,16 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Uint64) {
 
     value_count = 2;
     VkResult result_complete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_UINT64, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT64, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(82, values[1]);
     EXPECT_EQ(2, value_count);
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_api, vlGetLayerSettingValues_Float) {
+TEST(test_layer_setting_api, vkuGetLayerSettingValues_Float) {
     std::vector<float> input_values{76.1f, -82.5f};
 
     std::vector<VkLayerSettingEXT> settings{
@@ -360,14 +360,14 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Float) {
     VkLayerSettingsCreateInfoEXT layer_settings_create_info{
         VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
 
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
     uint32_t value_count = 0;
     VkResult result_count =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FLOAT32, &value_count, nullptr);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT32, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
     EXPECT_EQ(2, value_count);
 
@@ -375,23 +375,23 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Float) {
 
     value_count = 1;
     VkResult result_incomplete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FLOAT32, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT32, &value_count, &values[0]);
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f);
     EXPECT_EQ(1, value_count);
 
     value_count = 2;
     VkResult result_complete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FLOAT32, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT32, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f);
     EXPECT_TRUE(std::abs(values[1] - -82.5f) <= 0.0001f);
     EXPECT_EQ(2, value_count);
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_api, vlGetLayerSettingValues_Double) {
+TEST(test_layer_setting_api, vkuGetLayerSettingValues_Double) {
     std::vector<double> input_values{76.1, -82.5};
 
     std::vector<VkLayerSettingEXT> settings{
@@ -401,14 +401,14 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Double) {
     VkLayerSettingsCreateInfoEXT layer_settings_create_info{
         VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
 
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
     uint32_t value_count = 0;
     VkResult result_count =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FLOAT64, &value_count, nullptr);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT64, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
     EXPECT_EQ(2, value_count);
 
@@ -416,28 +416,28 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Double) {
 
     value_count = 1;
     VkResult result_incomplete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FLOAT64, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT64, &value_count, &values[0]);
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001);
     EXPECT_EQ(1, value_count);
 
     value_count = 2;
     VkResult result_complete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FLOAT64, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT64, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001);
     EXPECT_TRUE(std::abs(values[1] - -82.5) <= 0.0001);
     EXPECT_EQ(2, value_count);
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_api, vlGetLayerSettingValues_Frameset) {
-    const VlFrameset input_values[] = {
+TEST(test_layer_setting_api, vkuGetLayerSettingValues_Frameset) {
+    const VkuFrameset input_values[] = {
         {76, 100, 10}, {1, 100, 1}
     };
     const std::uint32_t frameset_count =
-        static_cast<std::uint32_t>(std::size(input_values) * (sizeof(VlFrameset) / sizeof(VlFrameset::count)));
+        static_cast<std::uint32_t>(std::size(input_values) * (sizeof(VkuFrameset) / sizeof(VkuFrameset::count)));
 
     const VkLayerSettingEXT settings[] = {
         {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_UINT32_EXT, frameset_count, input_values}
@@ -446,22 +446,22 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Frameset) {
     const VkLayerSettingsCreateInfoEXT layer_settings_create_info{
         VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<std::uint32_t>(std::size(settings)), settings};
 
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
     uint32_t value_count = 0;
     VkResult result_count =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FRAMESET, &value_count, nullptr);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FRAMESET, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
     EXPECT_EQ(2, value_count);
 
-    std::vector<VlFrameset> values(static_cast<uint32_t>(value_count));
+    std::vector<VkuFrameset> values(static_cast<uint32_t>(value_count));
 
     value_count = 1;
     VkResult result_incomplete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FRAMESET, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FRAMESET, &value_count, &values[0]);
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_EQ(76, values[0].first);
     EXPECT_EQ(100, values[0].count);
@@ -470,7 +470,7 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Frameset) {
 
     value_count = 2;
     VkResult result_complete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FRAMESET, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FRAMESET, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(76, values[0].first);
     EXPECT_EQ(100, values[0].count);
@@ -480,10 +480,10 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_Frameset) {
     EXPECT_EQ(1, values[1].step);
     EXPECT_EQ(2, value_count);
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_api, vlGetLayerSettingValues_String) {
+TEST(test_layer_setting_api, vkuGetLayerSettingValues_String) {
     std::vector<const char*> input_values{"VALUE_A", "VALUE_B"};
     std::vector<VkLayerSettingEXT> settings{
         {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, static_cast<uint32_t>(input_values.size()), &input_values[0]}
@@ -492,14 +492,14 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_String) {
     VkLayerSettingsCreateInfoEXT layer_settings_create_info{
         VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
 
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
     uint32_t value_count = 0;
     VkResult result_count =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_STRING, &value_count, nullptr);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
     EXPECT_EQ(2, value_count);
 
@@ -507,7 +507,7 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_String) {
 
     value_count = 1;
     VkResult result_incomplete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_STRING, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, &values[0]);
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_STREQ("VALUE_A", values[0]);
     EXPECT_STREQ(nullptr, values[1]);
@@ -515,11 +515,11 @@ TEST(test_layer_setting_api, vlGetLayerSettingValues_String) {
 
     value_count = 2;
     VkResult result_complete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_STRING, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_STREQ("VALUE_A", values[0]);
     EXPECT_STREQ("VALUE_B", values[1]);
     EXPECT_EQ(2, value_count);
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
diff --git a/tests/layer/test_setting_cast.cpp b/tests/layer/test_setting_cast.cpp
index d6d7aa2..c67d2ca 100644
--- a/tests/layer/test_setting_cast.cpp
+++ b/tests/layer/test_setting_cast.cpp
@@ -12,7 +12,7 @@
 #include <vector>
 #include <cstring>
 
-TEST(test_layer_setting_cast, vlGetLayerSettingValues_Bool) {
+TEST(test_layer_setting_cast, vkuGetLayerSettingValues_Bool) {
     std::vector<VkBool32> input_values{VK_TRUE, VK_FALSE};
 
     std::vector<VkLayerSettingEXT> settings{
@@ -21,16 +21,16 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Bool) {
     VkLayerSettingsCreateInfoEXT layer_settings_create_info{
         VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
 
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
     std::vector<VkBool32> values(input_values.size());
 
     uint32_t value_count = 2;
     VkResult result_complete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_BOOL32, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_BOOL32, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(2, value_count);
     EXPECT_EQ(VK_TRUE, values[0]);
@@ -39,16 +39,16 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Bool) {
     std::vector<const char*> string_values(input_values.size());
 
     result_complete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_STRING, &value_count, &string_values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, &string_values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(2, value_count);
     EXPECT_STREQ("true", string_values[0]);
     EXPECT_STREQ("false", string_values[1]);
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_cast, vlGetLayerSettingValues_Int32) {
+TEST(test_layer_setting_cast, vkuGetLayerSettingValues_Int32) {
     std::vector<std::int32_t> input_values{76, -82};
 
     std::vector<VkLayerSettingEXT> settings{
@@ -57,16 +57,16 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Int32) {
     VkLayerSettingsCreateInfoEXT layer_settings_create_info{
         VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
 
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
     std::vector<std::int32_t> values(input_values.size());
 
     uint32_t value_count = 2;
     VkResult result_complete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_INT32, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_INT32, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(-82, values[1]);
@@ -75,16 +75,16 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Int32) {
     std::vector<const char*> string_values(input_values.size());
 
     result_complete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_STRING, &value_count, &string_values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, &string_values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(2, value_count);
     EXPECT_STREQ("76", string_values[0]);
     EXPECT_STREQ("-82", string_values[1]);
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_cast, vlGetLayerSettingValues_Int64) {
+TEST(test_layer_setting_cast, vkuGetLayerSettingValues_Int64) {
     std::vector<std::int64_t> input_values{76, -82};
 
     std::vector<VkLayerSettingEXT> settings{
@@ -93,16 +93,16 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Int64) {
     VkLayerSettingsCreateInfoEXT layer_settings_create_info{
         VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
 
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
     std::vector<std::int64_t> values(input_values.size());
 
     uint32_t value_count = 2;
     VkResult result_complete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_INT64, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_INT64, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(-82, values[1]);
@@ -111,16 +111,16 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Int64) {
     std::vector<const char*> string_values(input_values.size());
 
     result_complete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_STRING, &value_count, &string_values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, &string_values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(2, value_count);
     EXPECT_STREQ("76", string_values[0]);
     EXPECT_STREQ("-82", string_values[1]);
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_cast, vlGetLayerSettingValues_Uint32) {
+TEST(test_layer_setting_cast, vkuGetLayerSettingValues_Uint32) {
     std::vector<std::uint32_t> input_values{76, 82};
 
     std::vector<VkLayerSettingEXT> settings{
@@ -130,16 +130,16 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Uint32) {
     VkLayerSettingsCreateInfoEXT layer_settings_create_info{
         VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
 
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
     std::vector<std::uint32_t> values(input_values.size());
 
     uint32_t value_count = 2;
     VkResult result_complete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_UINT32, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(82, values[1]);
@@ -148,16 +148,16 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Uint32) {
     std::vector<const char*> string_values(input_values.size());
 
     result_complete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_STRING, &value_count, &string_values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, &string_values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(2, value_count);
     EXPECT_STREQ("76", string_values[0]);
     EXPECT_STREQ("82", string_values[1]);
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_cast, vlGetLayerSettingValues_Uint64) {
+TEST(test_layer_setting_cast, vkuGetLayerSettingValues_Uint64) {
     std::vector<std::uint64_t> input_values{76, 82};
 
     std::vector<VkLayerSettingEXT> settings{
@@ -167,16 +167,16 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Uint64) {
     VkLayerSettingsCreateInfoEXT layer_settings_create_info{
         VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
 
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
     std::vector<std::uint64_t> values(input_values.size());
 
     uint32_t value_count = 2;
     VkResult result_complete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_UINT64, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT64, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(2, value_count);
     EXPECT_EQ(76, values[0]);
@@ -185,16 +185,16 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Uint64) {
     std::vector<const char*> string_values(input_values.size());
 
     result_complete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_STRING, &value_count, &string_values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, &string_values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(2, value_count);
     EXPECT_STREQ("76", string_values[0]);
     EXPECT_STREQ("82", string_values[1]);
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_cast, vlGetLayerSettingValues_Float) {
+TEST(test_layer_setting_cast, vkuGetLayerSettingValues_Float) {
     std::vector<float> input_values{76.1f, -82.5f};
 
     std::vector<VkLayerSettingEXT> settings{
@@ -204,16 +204,16 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Float) {
     VkLayerSettingsCreateInfoEXT layer_settings_create_info{
         VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
 
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
     std::vector<float> values(input_values.size());
 
     uint32_t value_count = 2;
     VkResult result_complete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FLOAT32, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT32, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(2, value_count);
     EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f);
@@ -222,16 +222,16 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Float) {
     std::vector<const char*> string_values(input_values.size());
 
     result_complete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_STRING, &value_count, &string_values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, &string_values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(2, value_count);
     EXPECT_TRUE(std::strstr(string_values[0], "76.") != nullptr);
     EXPECT_TRUE(std::strstr(string_values[1], "-82.5") != nullptr);
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_cast, vlGetLayerSettingValues_Double) {
+TEST(test_layer_setting_cast, vkuGetLayerSettingValues_Double) {
     std::vector<double> input_values{76.1, -82.5};
 
     std::vector<VkLayerSettingEXT> settings{
@@ -241,16 +241,16 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Double) {
     VkLayerSettingsCreateInfoEXT layer_settings_create_info{
         VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
 
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
     std::vector<double> values(input_values.size());
 
     uint32_t value_count = 2;
     VkResult result_complete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FLOAT64, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT64, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001);
     EXPECT_TRUE(std::abs(values[1] - -82.5) <= 0.0001);
@@ -259,19 +259,19 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Double) {
     std::vector<const char*> string_values(input_values.size());
 
     result_complete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_STRING, &value_count, &string_values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, &string_values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(2, value_count);
     EXPECT_TRUE(std::strstr(string_values[0], "76.") != nullptr);
     EXPECT_TRUE(std::strstr(string_values[1], "-82.5") != nullptr);
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_cast, vlGetLayerSettingValues_Frameset) {
-    const std::size_t frameset_size = (sizeof(VlFrameset) / sizeof(VlFrameset::count));
+TEST(test_layer_setting_cast, vkuGetLayerSettingValues_Frameset) {
+    const std::size_t frameset_size = (sizeof(VkuFrameset) / sizeof(VkuFrameset::count));
 
-    std::vector<VlFrameset> input_values{
+    std::vector<VkuFrameset> input_values{
         {76, 100, 10}, {1, 100, 1}
     };
 
@@ -282,16 +282,16 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Frameset) {
     VkLayerSettingsCreateInfoEXT layer_settings_create_info{
         VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
 
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
-    std::vector<VlFrameset> values(input_values.size());
+    std::vector<VkuFrameset> values(input_values.size());
 
     uint32_t value_count = 2 * frameset_size;
     VkResult result_complete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_UINT32, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(76, values[0].first);
     EXPECT_EQ(100, values[0].count);
@@ -302,23 +302,23 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_Frameset) {
     EXPECT_EQ(6, value_count);
 
     value_count = 0;
-    result_complete = vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FRAMESET_STRING, &value_count, nullptr);
+    result_complete = vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FRAMESET_STRING, &value_count, nullptr);
     EXPECT_EQ(2, value_count);
 
     std::vector<const char*> string_values(input_values.size());
 
     value_count = 2;
     result_complete = 
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FRAMESET_STRING, &value_count, &string_values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FRAMESET_STRING, &value_count, &string_values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(2, value_count);
     EXPECT_STREQ("76-100-10", string_values[0]);
     EXPECT_STREQ("1-100-1", string_values[1]);
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_cast, vlGetLayerSettingValues_String) {
+TEST(test_layer_setting_cast, vkuGetLayerSettingValues_String) {
     std::vector<const char*> input_values{"VALUE_A", "VALUE_B"};
     std::vector<VkLayerSettingEXT> settings{
         {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, static_cast<uint32_t>(input_values.size()), &input_values[0]}
@@ -327,20 +327,20 @@ TEST(test_layer_setting_cast, vlGetLayerSettingValues_String) {
     VkLayerSettingsCreateInfoEXT layer_settings_create_info{
         VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, static_cast<uint32_t>(settings.size()), &settings[0]};
 
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
     std::vector<const char*> values(input_values.size());
 
     uint32_t value_count = 2;
     VkResult result_complete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_STRING, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_STREQ("VALUE_A", values[0]);
     EXPECT_STREQ("VALUE_B", values[1]);
     EXPECT_EQ(2, value_count);
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
diff --git a/tests/layer/test_setting_cpp.cpp b/tests/layer/test_setting_cpp.cpp
index 8de876f..fcd4c8d 100644
--- a/tests/layer/test_setting_cpp.cpp
+++ b/tests/layer/test_setting_cpp.cpp
@@ -12,7 +12,7 @@
 #include <iterator>
 #include <vector>
 
-TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Bool) {
+TEST(test_layer_setting_cpp, vkuGetLayerSettingValue_Bool) {
     const VkBool32 value_data{VK_TRUE};
 
     const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_BOOL32_EXT, 1, &value_data};
@@ -20,20 +20,20 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Bool) {
     const VkLayerSettingsCreateInfoEXT layer_settings_create_info{
         VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, 1, &setting};
 
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
     bool pValues = true;
-    vlGetLayerSettingValue(layerSettingSet, "my_setting", pValues);
+    vkuGetLayerSettingValue(layerSettingSet, "my_setting", pValues);
 
     EXPECT_EQ(true, pValues);
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Bool) {
+TEST(test_layer_setting_cpp, vkuGetLayerSettingValues_Bool) {
     const VkBool32 values_data[] = {VK_TRUE, VK_FALSE};
     const uint32_t value_count = static_cast<uint32_t>(std::size(values_data));
 
@@ -45,22 +45,22 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Bool) {
     const VkLayerSettingsCreateInfoEXT layer_settings_create_info{
         VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, settings_size, settings};
 
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
     std::vector<bool> values;
-    vlGetLayerSettingValues(layerSettingSet, "my_setting", values);
+    vkuGetLayerSettingValues(layerSettingSet, "my_setting", values);
 
     EXPECT_EQ(true, values[0]);
     EXPECT_EQ(false, values[1]);
     EXPECT_EQ(2, values.size());
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Int32) {
+TEST(test_layer_setting_cpp, vkuGetLayerSettingValue_Int32) {
     const std::int32_t value_data{76};
 
     const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_INT32_EXT, 1, &value_data};
@@ -68,20 +68,20 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Int32) {
     const VkLayerSettingsCreateInfoEXT layer_settings_create_info{
         VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, 1, &setting};
 
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
     std::int32_t pValues;
-    vlGetLayerSettingValue(layerSettingSet, "my_setting", pValues);
+    vkuGetLayerSettingValue(layerSettingSet, "my_setting", pValues);
 
     EXPECT_EQ(76, pValues);
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Int32) {
+TEST(test_layer_setting_cpp, vkuGetLayerSettingValues_Int32) {
     const std::int32_t values_data[] = {76, 82};
     const uint32_t value_count = static_cast<uint32_t>(std::size(values_data));
 
@@ -93,22 +93,22 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Int32) {
     const VkLayerSettingsCreateInfoEXT layer_settings_create_info{
         VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, settings_size, settings};
 
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
     std::vector<std::int32_t> values;
-    vlGetLayerSettingValues(layerSettingSet, "my_setting", values);
+    vkuGetLayerSettingValues(layerSettingSet, "my_setting", values);
 
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(82, values[1]);
     EXPECT_EQ(2, values.size());
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Uint32) {
+TEST(test_layer_setting_cpp, vkuGetLayerSettingValue_Uint32) {
     const std::uint32_t value_data{76};
 
     const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_UINT32_EXT, 1, &value_data};
@@ -116,20 +116,20 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Uint32) {
     const VkLayerSettingsCreateInfoEXT layer_settings_create_info{
         VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, 1, &setting};
 
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
     std::uint32_t pValues;
-    vlGetLayerSettingValue(layerSettingSet, "my_setting", pValues);
+    vkuGetLayerSettingValue(layerSettingSet, "my_setting", pValues);
 
     EXPECT_EQ(76, pValues);
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Uint32) {
+TEST(test_layer_setting_cpp, vkuGetLayerSettingValues_Uint32) {
     const std::uint32_t values_data[] = {76, 82};
     const uint32_t value_count = static_cast<uint32_t>(std::size(values_data));
 
@@ -141,22 +141,22 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Uint32) {
     const VkLayerSettingsCreateInfoEXT layer_settings_create_info{
         VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, settings_size, settings};
 
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
     std::vector<std::uint32_t> values;
-    vlGetLayerSettingValues(layerSettingSet, "my_setting", values);
+    vkuGetLayerSettingValues(layerSettingSet, "my_setting", values);
 
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(82, values[1]);
     EXPECT_EQ(2, values.size());
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Int64) {
+TEST(test_layer_setting_cpp, vkuGetLayerSettingValue_Int64) {
     const std::int64_t value_data{76};
 
     const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_INT64_EXT, 1, &value_data};
@@ -164,20 +164,20 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Int64) {
     const VkLayerSettingsCreateInfoEXT layer_settings_create_info{
         VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, 1, &setting};
 
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
     std::int64_t pValues;
-    vlGetLayerSettingValue(layerSettingSet, "my_setting", pValues);
+    vkuGetLayerSettingValue(layerSettingSet, "my_setting", pValues);
 
     EXPECT_EQ(76, pValues);
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Int64) {
+TEST(test_layer_setting_cpp, vkuGetLayerSettingValues_Int64) {
     const std::int64_t values_data[] = {76, 82};
     const uint32_t value_count = static_cast<uint32_t>(std::size(values_data));
 
@@ -189,22 +189,22 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Int64) {
     const VkLayerSettingsCreateInfoEXT layer_settings_create_info{
         VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, settings_size, &settings[0]};
 
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
     std::vector<std::int64_t> values;
-    vlGetLayerSettingValues(layerSettingSet, "my_setting", values);
+    vkuGetLayerSettingValues(layerSettingSet, "my_setting", values);
 
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(82, values[1]);
     EXPECT_EQ(2, values.size());
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Uint64) {
+TEST(test_layer_setting_cpp, vkuGetLayerSettingValue_Uint64) {
     const std::uint64_t value_data{76};
 
     const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_UINT64_EXT, 1, &value_data};
@@ -212,20 +212,20 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Uint64) {
     const VkLayerSettingsCreateInfoEXT layer_settings_create_info{
         VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, 1, &setting};
 
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
     std::uint64_t pValues;
-    vlGetLayerSettingValue(layerSettingSet, "my_setting", pValues);
+    vkuGetLayerSettingValue(layerSettingSet, "my_setting", pValues);
 
     EXPECT_EQ(76, pValues);
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Uint64) {
+TEST(test_layer_setting_cpp, vkuGetLayerSettingValues_Uint64) {
     const std::uint64_t values_data[] = {76, 82};
     const uint32_t value_count = static_cast<uint32_t>(std::size(values_data));
 
@@ -237,22 +237,22 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Uint64) {
     const VkLayerSettingsCreateInfoEXT layer_settings_create_info{
         VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, settings_size, settings};
 
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
     std::vector<std::uint64_t> values;
-    vlGetLayerSettingValues(layerSettingSet, "my_setting", values);
+    vkuGetLayerSettingValues(layerSettingSet, "my_setting", values);
 
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(82, values[1]);
     EXPECT_EQ(2, values.size());
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Float) {
+TEST(test_layer_setting_cpp, vkuGetLayerSettingValue_Float) {
     const float value_data{-82.5f};
 
     const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_FLOAT32_EXT, 1, &value_data};
@@ -260,20 +260,20 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Float) {
     const VkLayerSettingsCreateInfoEXT layer_settings_create_info{
         VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, 1, &setting};
 
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
     float pValues;
-    vlGetLayerSettingValue(layerSettingSet, "my_setting", pValues);
+    vkuGetLayerSettingValue(layerSettingSet, "my_setting", pValues);
 
     EXPECT_TRUE(std::abs(pValues - -82.5f) <= 0.0001f);
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Float) {
+TEST(test_layer_setting_cpp, vkuGetLayerSettingValues_Float) {
     const float values_data[] = {76.1f, -82.5f};
     const uint32_t value_count = static_cast<uint32_t>(std::size(values_data));
 
@@ -285,22 +285,22 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Float) {
     const VkLayerSettingsCreateInfoEXT layer_settings_create_info{
         VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, settings_size, settings};
 
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
     std::vector<float> values;
-    vlGetLayerSettingValues(layerSettingSet, "my_setting", values);
+    vkuGetLayerSettingValues(layerSettingSet, "my_setting", values);
 
     EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f);
     EXPECT_TRUE(std::abs(values[1] - -82.5f) <= 0.0001f);
     EXPECT_EQ(2, values.size());
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Double) {
+TEST(test_layer_setting_cpp, vkuGetLayerSettingValue_Double) {
     const double value_data{-82.5};
 
     const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_FLOAT64_EXT, 1, &value_data};
@@ -308,20 +308,20 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Double) {
     const VkLayerSettingsCreateInfoEXT layer_settings_create_info{
         VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, 1, &setting};
 
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
     double pValues;
-    vlGetLayerSettingValue(layerSettingSet, "my_setting", pValues);
+    vkuGetLayerSettingValue(layerSettingSet, "my_setting", pValues);
 
     EXPECT_TRUE(std::abs(pValues - -82.5) <= 0.0001);
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Double) {
+TEST(test_layer_setting_cpp, vkuGetLayerSettingValues_Double) {
     const double values_data[] = {76.1, -82.5};
     const uint32_t value_count = static_cast<uint32_t>(std::size(values_data));
 
@@ -333,22 +333,22 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Double) {
     const VkLayerSettingsCreateInfoEXT layer_settings_create_info{
         VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, settings_size, settings};
 
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
     std::vector<double> values;
-    vlGetLayerSettingValues(layerSettingSet, "my_setting", values);
+    vkuGetLayerSettingValues(layerSettingSet, "my_setting", values);
 
     EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001);
     EXPECT_TRUE(std::abs(values[1] - -82.5) <= 0.0001);
     EXPECT_EQ(2, values.size());
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_cpp, vlGetLayerSettingValue_String) {
+TEST(test_layer_setting_cpp, vkuGetLayerSettingValue_String) {
     const char* value_data[] = {"VALUE_A"};
 
     const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_STRING_EXT, 1, value_data};
@@ -356,17 +356,17 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValue_String) {
     const VkLayerSettingsCreateInfoEXT layer_settings_create_info{
         VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, 1, &setting};
 
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
 
     std::string pValues;
-    vlGetLayerSettingValue(layerSettingSet, "my_setting", pValues);
+    vkuGetLayerSettingValue(layerSettingSet, "my_setting", pValues);
     EXPECT_STREQ("VALUE_A", pValues.c_str());
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Strings) {
+TEST(test_layer_setting_cpp, vkuGetLayerSettingValue_Strings) {
     const char* values_data[] = {"VALUE_A", "VALUE_B"};
     const uint32_t value_count = static_cast<uint32_t>(std::size(values_data));
 
@@ -378,17 +378,17 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Strings) {
     const VkLayerSettingsCreateInfoEXT layer_settings_create_info{
         VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, settings_size, settings};
 
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
 
     std::string pValues;
-    vlGetLayerSettingValue(layerSettingSet, "my_setting", pValues);
+    vkuGetLayerSettingValue(layerSettingSet, "my_setting", pValues);
     EXPECT_STREQ("VALUE_A,VALUE_B", pValues.c_str());
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_cpp, vlGetLayerSettingValues_String) {
+TEST(test_layer_setting_cpp, vkuGetLayerSettingValues_String) {
     const char* values_data[] = {"VALUE_A", "VALUE_B"};
     const uint32_t value_count = static_cast<uint32_t>(std::size(values_data));
 
@@ -400,48 +400,48 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_String) {
     const VkLayerSettingsCreateInfoEXT layer_settings_create_info{
         VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, settings_size, settings};
 
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
     std::vector<std::string> values;
-    vlGetLayerSettingValues(layerSettingSet, "my_setting", values);
+    vkuGetLayerSettingValues(layerSettingSet, "my_setting", values);
     EXPECT_STREQ("VALUE_A", values[0].c_str());
     EXPECT_STREQ("VALUE_B", values[1].c_str());
     EXPECT_EQ(2, values.size());
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_cpp, vlGetLayerSettingValue_Frameset) {
-    const VlFrameset value_data{76, 100, 10};
+TEST(test_layer_setting_cpp, vkuGetLayerSettingValue_Frameset) {
+    const VkuFrameset value_data{76, 100, 10};
 
     const VkLayerSettingEXT setting{"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_UINT32_EXT, 3, &value_data};
 
     const VkLayerSettingsCreateInfoEXT layer_settings_create_info{
         VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, 1, &setting};
 
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
-    VlFrameset pValues;
-    vlGetLayerSettingValue(layerSettingSet, "my_setting", pValues);
+    VkuFrameset pValues;
+    vkuGetLayerSettingValue(layerSettingSet, "my_setting", pValues);
 
     EXPECT_EQ(76, pValues.first);
     EXPECT_EQ(100, pValues.count);
     EXPECT_EQ(10, pValues.step);
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Frameset) {
-    const VlFrameset values_data[] = {
+TEST(test_layer_setting_cpp, vkuGetLayerSettingValues_Frameset) {
+    const VkuFrameset values_data[] = {
         {76, 100, 10}, {1, 100, 1}
     };
-    const uint32_t value_count = static_cast<uint32_t>(std::size(values_data) * (sizeof(VlFrameset) / sizeof(VlFrameset::count)));
+    const uint32_t value_count = static_cast<uint32_t>(std::size(values_data) * (sizeof(VkuFrameset) / sizeof(VkuFrameset::count)));
 
     const VkLayerSettingEXT settings[] = {
         {"VK_LAYER_LUNARG_test", "my_setting", VK_LAYER_SETTING_TYPE_UINT32_EXT, value_count, values_data}
@@ -451,13 +451,13 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Frameset) {
     const VkLayerSettingsCreateInfoEXT layer_settings_create_info{
         VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, settings_size, settings};
 
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
-    std::vector<VlFrameset> values;
-    vlGetLayerSettingValues(layerSettingSet, "my_setting", values);
+    std::vector<VkuFrameset> values;
+    vkuGetLayerSettingValues(layerSettingSet, "my_setting", values);
 
     EXPECT_EQ(76, values[0].first);
     EXPECT_EQ(100, values[0].count);
@@ -467,10 +467,10 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_Frameset) {
     EXPECT_EQ(1, values[1].step);
     EXPECT_EQ(2, values.size());
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_cpp, vlGetLayerSettingValues_VlCustomSTypeInfo) {
+TEST(test_layer_setting_cpp, vkuGetLayerSettingValues_VkuCustomSTypeInfo) {
     const char* values_data[] = {"0x76", "0X82", "76", "82"};
     const uint32_t value_count = static_cast<uint32_t>(std::size(values_data));
 
@@ -482,22 +482,22 @@ TEST(test_layer_setting_cpp, vlGetLayerSettingValues_VlCustomSTypeInfo) {
     const VkLayerSettingsCreateInfoEXT layer_settings_create_info{
         VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, settings_size, &settings[0]};
 
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", &layer_settings_create_info, nullptr, nullptr, &layerSettingSet);
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
-    std::vector<VlCustomSTypeInfo> values;
-    vlGetLayerSettingValues(layerSettingSet, "my_setting", values);
+    std::vector<VkuCustomSTypeInfo> values;
+    vkuGetLayerSettingValues(layerSettingSet, "my_setting", values);
     EXPECT_EQ(0x76, values[0].first);
     EXPECT_EQ(0x82, values[0].second);
     EXPECT_EQ(76, values[1].first);
     EXPECT_EQ(82, values[1].second);
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_cpp, vlGetUnknownSettings) {
+TEST(test_layer_setting_cpp, vkuGetUnknownSettings) {
     std::vector<VkLayerSettingEXT> settings;
 
     VkBool32 value_bool = VK_TRUE;
@@ -563,13 +563,13 @@ TEST(test_layer_setting_cpp, vlGetUnknownSettings) {
     setting_double_value.count = 1;
     settings.push_back(setting_double_value);
 
-    VlFrameset value_frameset{76, 100, 10};
+    VkuFrameset value_frameset{76, 100, 10};
     VkLayerSettingEXT setting_frameset_value{};
     setting_frameset_value.pLayerName = "VK_LAYER_LUNARG_test";
     setting_frameset_value.pSettingName = "frameset_value";
     setting_frameset_value.type = VK_LAYER_SETTING_TYPE_UINT32_EXT;
     setting_frameset_value.pValues = &value_frameset;
-    setting_frameset_value.count = sizeof(VlFrameset) / sizeof(VlFrameset::count);
+    setting_frameset_value.count = sizeof(VkuFrameset) / sizeof(VkuFrameset::count);
     settings.push_back(setting_frameset_value);
 
     VkLayerSettingsCreateInfoEXT layer_settings_create_info;
@@ -582,7 +582,7 @@ TEST(test_layer_setting_cpp, vlGetUnknownSettings) {
     const std::uint32_t setting_name_count = static_cast<std::uint32_t>(std::size(setting_names));
 
     std::vector<const char*> unknown_settings;
-    vlGetUnknownSettings(&layer_settings_create_info, setting_name_count, setting_names, unknown_settings);
+    vkuGetUnknownSettings(&layer_settings_create_info, setting_name_count, setting_names, unknown_settings);
     EXPECT_EQ(2, unknown_settings.size());
 
     EXPECT_STREQ("bool_value", unknown_settings[0]);
diff --git a/tests/layer/test_setting_env.cpp b/tests/layer/test_setting_env.cpp
index 545b0b7..ac50d4d 100644
--- a/tests/layer/test_setting_env.cpp
+++ b/tests/layer/test_setting_env.cpp
@@ -24,116 +24,116 @@ static void SetEnv(const char* value) {
 TEST(test_layer_setting_env, EnvVar_TrimNone) {
     SetEnv("VK_LUNARG_TEST_MY_SETTING_A=true,false");
 
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting_a"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting_a"));
 
     uint32_t value_count_a = 0;
     VkResult result_count_a =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting_a", VL_LAYER_SETTING_TYPE_BOOL32, &value_count_a, nullptr);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting_a", VKU_LAYER_SETTING_TYPE_BOOL32, &value_count_a, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count_a);
     EXPECT_EQ(2, value_count_a);
 
     std::vector<VkBool32> values_a(static_cast<std::size_t>(value_count_a));
     VkResult result_complete_a =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting_a", VL_LAYER_SETTING_TYPE_BOOL32, &value_count_a, &values_a[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting_a", VKU_LAYER_SETTING_TYPE_BOOL32, &value_count_a, &values_a[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete_a);
     EXPECT_EQ(VK_TRUE, values_a[0]);
     EXPECT_EQ(VK_FALSE, values_a[1]);
     EXPECT_EQ(2, value_count_a);
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
 TEST(test_layer_setting_env, EnvVar_TrimVendor) {
     SetEnv("VK_TEST_MY_SETTING_B=true,false");
 
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting_b"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting_b"));
 
     uint32_t value_count_b = 0;
     VkResult result_count_b =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting_b", VL_LAYER_SETTING_TYPE_BOOL32, &value_count_b, nullptr);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting_b", VKU_LAYER_SETTING_TYPE_BOOL32, &value_count_b, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count_b);
     EXPECT_EQ(2, value_count_b);
 
     std::vector<VkBool32> values_b(static_cast<std::size_t>(value_count_b));
     VkResult result_complete_b =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting_b", VL_LAYER_SETTING_TYPE_BOOL32, &value_count_b, &values_b[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting_b", VKU_LAYER_SETTING_TYPE_BOOL32, &value_count_b, &values_b[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete_b);
     EXPECT_EQ(VK_TRUE, values_b[0]);
     EXPECT_EQ(VK_FALSE, values_b[1]);
     EXPECT_EQ(2, value_count_b);
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
 TEST(test_layer_setting_env, EnvVar_TrimNamespace) {
     SetEnv("VK_MY_SETTING_C=true,false");
 
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting_c"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting_c"));
 
     uint32_t value_count_c = 0;
     VkResult result_count_c =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting_c", VL_LAYER_SETTING_TYPE_BOOL32, &value_count_c, nullptr);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting_c", VKU_LAYER_SETTING_TYPE_BOOL32, &value_count_c, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count_c);
     EXPECT_EQ(2, value_count_c);
 
     std::vector<VkBool32> values_c(static_cast<std::size_t>(value_count_c));
     VkResult result_complete_c =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting_c", VL_LAYER_SETTING_TYPE_BOOL32, &value_count_c, &values_c[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting_c", VKU_LAYER_SETTING_TYPE_BOOL32, &value_count_c, &values_c[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete_c);
     EXPECT_EQ(VK_TRUE, values_c[0]);
     EXPECT_EQ(VK_FALSE, values_c[1]);
     EXPECT_EQ(2, value_count_c);
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
 TEST(test_layer_setting_env, EnvVar_TrimNamespace_OveriddenPrefix) {
     SetEnv("VK_POUET_MY_SETTING_C=true,false");
 
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
 
-    vlSetLayerSettingCompatibilityNamespace(layerSettingSet, "POUET");
+    vkuSetLayerSettingCompatibilityNamespace(layerSettingSet, "POUET");
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting_c"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting_c"));
 
     uint32_t value_count_c = 0;
     VkResult result_count_c =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting_c", VL_LAYER_SETTING_TYPE_BOOL32, &value_count_c, nullptr);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting_c", VKU_LAYER_SETTING_TYPE_BOOL32, &value_count_c, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count_c);
     EXPECT_EQ(2, value_count_c);
 
     std::vector<VkBool32> values_c(static_cast<std::size_t>(value_count_c));
     VkResult result_complete_c =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting_c", VL_LAYER_SETTING_TYPE_BOOL32, &value_count_c, &values_c[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting_c", VKU_LAYER_SETTING_TYPE_BOOL32, &value_count_c, &values_c[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete_c);
     EXPECT_EQ(VK_TRUE, values_c[0]);
     EXPECT_EQ(VK_FALSE, values_c[1]);
     EXPECT_EQ(2, value_count_c);
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_env, vlGetLayerSettingValues_Bool) {
+TEST(test_layer_setting_env, vkuGetLayerSettingValues_Bool) {
     SetEnv("VK_LUNARG_TEST_MY_SETTING=true,false");
 
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
     uint32_t value_count = 0;
     VkResult result_count =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_BOOL32, &value_count, nullptr);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_BOOL32, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
     EXPECT_EQ(2, value_count);
 
@@ -141,7 +141,7 @@ TEST(test_layer_setting_env, vlGetLayerSettingValues_Bool) {
 
     value_count = 1;
     VkResult result_incomplete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_BOOL32, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_BOOL32, &value_count, &values[0]);
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_EQ(VK_TRUE, values[0]);
     EXPECT_EQ(VK_FALSE, values[1]);
@@ -149,26 +149,26 @@ TEST(test_layer_setting_env, vlGetLayerSettingValues_Bool) {
 
     value_count = 2;
     VkResult result_complete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_BOOL32, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_BOOL32, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(VK_TRUE, values[0]);
     EXPECT_EQ(VK_FALSE, values[1]);
     EXPECT_EQ(2, value_count);
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_env, vlGetLayerSettingValues_Int32) {
+TEST(test_layer_setting_env, vkuGetLayerSettingValues_Int32) {
     SetEnv("VK_LUNARG_TEST_MY_SETTING=76,-82");
 
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
     uint32_t value_count = 2;
     VkResult result_count =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_INT32, &value_count, nullptr);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_INT32, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
     EXPECT_EQ(2, value_count);
 
@@ -176,7 +176,7 @@ TEST(test_layer_setting_env, vlGetLayerSettingValues_Int32) {
 
     value_count = 1;
     VkResult result_incomplete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_INT32, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_INT32, &value_count, &values[0]);
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(0, values[1]);
@@ -184,26 +184,26 @@ TEST(test_layer_setting_env, vlGetLayerSettingValues_Int32) {
 
     value_count = 2;
     VkResult result_complete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_INT32, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_INT32, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(-82, values[1]);
     EXPECT_EQ(2, value_count);
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_env, vlGetLayerSettingValues_Int64) {
+TEST(test_layer_setting_env, vkuGetLayerSettingValues_Int64) {
     SetEnv("VK_LUNARG_TEST_MY_SETTING=76,-82");
 
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
     uint32_t value_count = 2;
     VkResult result_count =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_INT64, &value_count, nullptr);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_INT64, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
     EXPECT_EQ(2, value_count);
 
@@ -211,7 +211,7 @@ TEST(test_layer_setting_env, vlGetLayerSettingValues_Int64) {
 
     value_count = 1;
     VkResult result_incomplete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_INT64, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_INT64, &value_count, &values[0]);
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(0, values[1]);
@@ -219,26 +219,26 @@ TEST(test_layer_setting_env, vlGetLayerSettingValues_Int64) {
 
     value_count = 2;
     VkResult result_complete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_INT64, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_INT64, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(-82, values[1]);
     EXPECT_EQ(2, value_count);
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_env, vlGetLayerSettingValues_Uint32) {
+TEST(test_layer_setting_env, vkuGetLayerSettingValues_Uint32) {
     SetEnv("VK_LUNARG_TEST_MY_SETTING=76,82");
 
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
     uint32_t value_count = 0;
     VkResult result_count =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_UINT32, &value_count, nullptr);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT32, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
     EXPECT_EQ(2, value_count);
 
@@ -246,7 +246,7 @@ TEST(test_layer_setting_env, vlGetLayerSettingValues_Uint32) {
 
     value_count = 1;
     VkResult result_incomplete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_UINT32, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &values[0]);
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(0, values[1]);
@@ -254,26 +254,26 @@ TEST(test_layer_setting_env, vlGetLayerSettingValues_Uint32) {
 
     value_count = 2;
     VkResult result_complete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_UINT32, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(82, values[1]);
     EXPECT_EQ(2, value_count);
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_env, vlGetLayerSettingValues_Uint64) {
+TEST(test_layer_setting_env, vkuGetLayerSettingValues_Uint64) {
     SetEnv("VK_LUNARG_TEST_MY_SETTING=76,82");
 
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
     uint32_t value_count = 0;
     VkResult result_count =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_UINT64, &value_count, nullptr);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT64, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
     EXPECT_EQ(2, value_count);
 
@@ -281,7 +281,7 @@ TEST(test_layer_setting_env, vlGetLayerSettingValues_Uint64) {
 
     value_count = 1;
     VkResult result_incomplete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_UINT64, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT64, &value_count, &values[0]);
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(0, values[1]);
@@ -289,26 +289,26 @@ TEST(test_layer_setting_env, vlGetLayerSettingValues_Uint64) {
 
     value_count = 2;
     VkResult result_complete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_UINT64, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT64, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(82, values[1]);
     EXPECT_EQ(2, value_count);
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_env, vlGetLayerSettingValues_Float) {
+TEST(test_layer_setting_env, vkuGetLayerSettingValues_Float) {
     SetEnv("VK_LUNARG_TEST_MY_SETTING=76.1f,-82.5f");
 
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
     uint32_t value_count = 0;
     VkResult result_count =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FLOAT32, &value_count, nullptr);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT32, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
     EXPECT_EQ(2, value_count);
 
@@ -316,33 +316,33 @@ TEST(test_layer_setting_env, vlGetLayerSettingValues_Float) {
 
     value_count = 1;
     VkResult result_incomplete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FLOAT32, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT32, &value_count, &values[0]);
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f);
     EXPECT_EQ(1, value_count);
 
     value_count = 2;
     VkResult result_complete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FLOAT32, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT32, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f);
     EXPECT_TRUE(std::abs(values[1] - -82.5f) <= 0.0001f);
     EXPECT_EQ(2, value_count);
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_env, vlGetLayerSettingValues_Double) {
+TEST(test_layer_setting_env, vkuGetLayerSettingValues_Double) {
     SetEnv("VK_LUNARG_TEST_MY_SETTING=76.1,-82.5");
 
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
     uint32_t value_count = 0;
     VkResult result_count =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FLOAT64, &value_count, nullptr);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT64, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
     EXPECT_EQ(2, value_count);
 
@@ -350,41 +350,41 @@ TEST(test_layer_setting_env, vlGetLayerSettingValues_Double) {
 
     value_count = 1;
     VkResult result_incomplete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FLOAT64, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT64, &value_count, &values[0]);
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001);
     EXPECT_EQ(1, value_count);
 
     value_count = 2;
     VkResult result_complete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FLOAT64, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT64, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001);
     EXPECT_TRUE(std::abs(values[1] - -82.5) <= 0.0001);
     EXPECT_EQ(2, value_count);
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_env, vlGetLayerSettingValues_Frameset) {
+TEST(test_layer_setting_env, vkuGetLayerSettingValues_Frameset) {
     SetEnv("VK_LUNARG_TEST_MY_SETTING=76-100-10,1-100-1");
 
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
     uint32_t value_count = 0;
     VkResult result_count =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FRAMESET, &value_count, nullptr);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FRAMESET, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
     EXPECT_EQ(2, value_count);
 
-    std::vector<VlFrameset> values(static_cast<uint32_t>(value_count));
+    std::vector<VkuFrameset> values(static_cast<uint32_t>(value_count));
 
     value_count = 1;
     VkResult result_incomplete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FRAMESET, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FRAMESET, &value_count, &values[0]);
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_EQ(76, values[0].first);
     EXPECT_EQ(100, values[0].count);
@@ -393,7 +393,7 @@ TEST(test_layer_setting_env, vlGetLayerSettingValues_Frameset) {
 
     value_count = 2;
     VkResult result_complete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FRAMESET, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FRAMESET, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(76, values[0].first);
     EXPECT_EQ(100, values[0].count);
@@ -403,20 +403,20 @@ TEST(test_layer_setting_env, vlGetLayerSettingValues_Frameset) {
     EXPECT_EQ(1, values[1].step);
     EXPECT_EQ(2, value_count);
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_env, vlGetLayerSettingValues_String) {
+TEST(test_layer_setting_env, vkuGetLayerSettingValues_String) {
     SetEnv("VK_LUNARG_TEST_MY_SETTING=VALUE_A,VALUE_B");
 
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
     uint32_t value_count = 0;
     VkResult result_count =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_STRING, &value_count, nullptr);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
     EXPECT_EQ(2, value_count);
 
@@ -424,7 +424,7 @@ TEST(test_layer_setting_env, vlGetLayerSettingValues_String) {
 
     value_count = 1;
     VkResult result_incomplete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_STRING, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, &values[0]);
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_STREQ("VALUE_A", values[0]);
     EXPECT_STREQ(nullptr, values[1]);
@@ -432,11 +432,11 @@ TEST(test_layer_setting_env, vlGetLayerSettingValues_String) {
 
     value_count = 2;
     VkResult result_complete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_STRING, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_STREQ("VALUE_A", values[0]);
     EXPECT_STREQ("VALUE_B", values[1]);
     EXPECT_EQ(2, value_count);
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
diff --git a/tests/layer/test_setting_file.cpp b/tests/layer/test_setting_file.cpp
index c6f17fc..dafa63c 100644
--- a/tests/layer/test_setting_file.cpp
+++ b/tests/layer/test_setting_file.cpp
@@ -11,19 +11,19 @@
 #include "vulkan/layer/vk_layer_settings.h"
 #include <vector>
 
-void test_helper_SetLayerSetting(VlLayerSettingSet layerSettingSet, const char *pSettingName, const char *pValue);
+void test_helper_SetLayerSetting(VkuLayerSettingSet layerSettingSet, const char *pSettingName, const char *pValue);
 
-TEST(test_layer_setting_file, vlGetLayerSettingValues_Bool) {
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
+TEST(test_layer_setting_file, vkuGetLayerSettingValues_Bool) {
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
 
     test_helper_SetLayerSetting(layerSettingSet, "lunarg_test.my_setting", "true,false");
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
     uint32_t value_count = 0;
     VkResult result_count =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_BOOL32, &value_count, nullptr);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_BOOL32, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
     EXPECT_EQ(2, value_count);
 
@@ -31,7 +31,7 @@ TEST(test_layer_setting_file, vlGetLayerSettingValues_Bool) {
 
     value_count = 1;
     VkResult result_incomplete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_BOOL32, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_BOOL32, &value_count, &values[0]);
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_EQ(VK_TRUE, values[0]);
     EXPECT_EQ(VK_FALSE, values[1]);
@@ -39,26 +39,26 @@ TEST(test_layer_setting_file, vlGetLayerSettingValues_Bool) {
 
     value_count = 2;
     VkResult result_complete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_BOOL32, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_BOOL32, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(VK_TRUE, values[0]);
     EXPECT_EQ(VK_FALSE, values[1]);
     EXPECT_EQ(2, value_count);
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_file, vlGetLayerSettingValues_Int32) {
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
+TEST(test_layer_setting_file, vkuGetLayerSettingValues_Int32) {
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
 
     test_helper_SetLayerSetting(layerSettingSet, "lunarg_test.my_setting", "76,-82");
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
     uint32_t value_count = 2;
     VkResult result_count =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_INT32, &value_count, nullptr);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_INT32, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
     EXPECT_EQ(2, value_count);
 
@@ -66,7 +66,7 @@ TEST(test_layer_setting_file, vlGetLayerSettingValues_Int32) {
 
     value_count = 1;
     VkResult result_incomplete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_INT32, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_INT32, &value_count, &values[0]);
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(0, values[1]);
@@ -74,26 +74,26 @@ TEST(test_layer_setting_file, vlGetLayerSettingValues_Int32) {
 
     value_count = 2;
     VkResult result_complete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_INT32, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_INT32, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(-82, values[1]);
     EXPECT_EQ(2, value_count);
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_file, vlGetLayerSettingValues_Int64) {
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
+TEST(test_layer_setting_file, vkuGetLayerSettingValues_Int64) {
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
 
     test_helper_SetLayerSetting(layerSettingSet, "lunarg_test.my_setting", "76,-82");
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
     uint32_t value_count = 2;
     VkResult result_count =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_INT64, &value_count, nullptr);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_INT64, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
     EXPECT_EQ(2, value_count);
 
@@ -101,7 +101,7 @@ TEST(test_layer_setting_file, vlGetLayerSettingValues_Int64) {
 
     value_count = 1;
     VkResult result_incomplete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_INT64, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_INT64, &value_count, &values[0]);
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(0, values[1]);
@@ -109,26 +109,26 @@ TEST(test_layer_setting_file, vlGetLayerSettingValues_Int64) {
 
     value_count = 2;
     VkResult result_complete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_INT64, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_INT64, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(-82, values[1]);
     EXPECT_EQ(2, value_count);
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_file, vlGetLayerSettingValues_Uint32) {
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
+TEST(test_layer_setting_file, vkuGetLayerSettingValues_Uint32) {
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
 
     test_helper_SetLayerSetting(layerSettingSet, "lunarg_test.my_setting", "76,82");
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
     uint32_t value_count = 0;
     VkResult result_count =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_UINT32, &value_count, nullptr);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT32, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
     EXPECT_EQ(2, value_count);
 
@@ -136,7 +136,7 @@ TEST(test_layer_setting_file, vlGetLayerSettingValues_Uint32) {
 
     value_count = 1;
     VkResult result_incomplete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_UINT32, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &values[0]);
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(0, values[1]);
@@ -144,26 +144,26 @@ TEST(test_layer_setting_file, vlGetLayerSettingValues_Uint32) {
 
     value_count = 2;
     VkResult result_complete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_UINT32, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(82, values[1]);
     EXPECT_EQ(2, value_count);
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_file, vlGetLayerSettingValues_Uint64) {
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
+TEST(test_layer_setting_file, vkuGetLayerSettingValues_Uint64) {
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
 
     test_helper_SetLayerSetting(layerSettingSet, "lunarg_test.my_setting", "76,82");
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
     uint32_t value_count = 0;
     VkResult result_count =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_UINT64, &value_count, nullptr);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT64, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
     EXPECT_EQ(2, value_count);
 
@@ -171,7 +171,7 @@ TEST(test_layer_setting_file, vlGetLayerSettingValues_Uint64) {
 
     value_count = 1;
     VkResult result_incomplete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_UINT64, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT64, &value_count, &values[0]);
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(0, values[1]);
@@ -179,26 +179,26 @@ TEST(test_layer_setting_file, vlGetLayerSettingValues_Uint64) {
 
     value_count = 2;
     VkResult result_complete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_UINT64, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT64, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(82, values[1]);
     EXPECT_EQ(2, value_count);
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_file, vlGetLayerSettingValues_Float) {
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
+TEST(test_layer_setting_file, vkuGetLayerSettingValues_Float) {
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
 
     test_helper_SetLayerSetting(layerSettingSet, "lunarg_test.my_setting", "76.1f,-82.5f");
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
     uint32_t value_count = 0;
     VkResult result_count =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FLOAT32, &value_count, nullptr);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT32, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
     EXPECT_EQ(2, value_count);
 
@@ -206,33 +206,33 @@ TEST(test_layer_setting_file, vlGetLayerSettingValues_Float) {
 
     value_count = 1;
     VkResult result_incomplete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FLOAT32, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT32, &value_count, &values[0]);
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f);
     EXPECT_EQ(1, value_count);
 
     value_count = 2;
     VkResult result_complete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FLOAT32, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT32, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f);
     EXPECT_TRUE(std::abs(values[1] - -82.5f) <= 0.0001f);
     EXPECT_EQ(2, value_count);
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_file, vlGetLayerSettingValues_Double) {
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
+TEST(test_layer_setting_file, vkuGetLayerSettingValues_Double) {
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
 
     test_helper_SetLayerSetting(layerSettingSet, "lunarg_test.my_setting", "76.1,-82.5");
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
     uint32_t value_count = 0;
     VkResult result_count =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FLOAT64, &value_count, nullptr);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT64, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
     EXPECT_EQ(2, value_count);
 
@@ -240,41 +240,41 @@ TEST(test_layer_setting_file, vlGetLayerSettingValues_Double) {
 
     value_count = 1;
     VkResult result_incomplete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FLOAT64, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT64, &value_count, &values[0]);
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001);
     EXPECT_EQ(1, value_count);
 
     value_count = 2;
     VkResult result_complete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FLOAT64, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT64, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001);
     EXPECT_TRUE(std::abs(values[1] - -82.5) <= 0.0001);
     EXPECT_EQ(2, value_count);
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_file, vlGetLayerSettingValues_Frameset) {
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
+TEST(test_layer_setting_file, vkuGetLayerSettingValues_Frameset) {
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
 
     test_helper_SetLayerSetting(layerSettingSet, "lunarg_test.my_setting", "76-100-10,1-100-1");
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
     uint32_t value_count = 0;
     VkResult result_count =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FRAMESET, &value_count, nullptr);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FRAMESET, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
     EXPECT_EQ(2, value_count);
 
-    std::vector<VlFrameset> values(static_cast<uint32_t>(value_count));
+    std::vector<VkuFrameset> values(static_cast<uint32_t>(value_count));
 
     value_count = 1;
     VkResult result_incomplete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FRAMESET, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FRAMESET, &value_count, &values[0]);
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_EQ(76, values[0].first);
     EXPECT_EQ(100, values[0].count);
@@ -283,7 +283,7 @@ TEST(test_layer_setting_file, vlGetLayerSettingValues_Frameset) {
 
     value_count = 2;
     VkResult result_complete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_FRAMESET, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FRAMESET, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(76, values[0].first);
     EXPECT_EQ(100, values[0].count);
@@ -293,20 +293,20 @@ TEST(test_layer_setting_file, vlGetLayerSettingValues_Frameset) {
     EXPECT_EQ(1, values[1].step);
     EXPECT_EQ(2, value_count);
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
 
-TEST(test_layer_setting_file, vlGetLayerSettingValues_String) {
-    VlLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
-    vlCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
+TEST(test_layer_setting_file, vkuGetLayerSettingValues_String) {
+    VkuLayerSettingSet layerSettingSet = VK_NULL_HANDLE;
+    vkuCreateLayerSettingSet("VK_LAYER_LUNARG_test", nullptr, nullptr, nullptr, &layerSettingSet);
 
     test_helper_SetLayerSetting(layerSettingSet, "lunarg_test.my_setting", "VALUE_A,VALUE_B");
 
-    EXPECT_TRUE(vlHasLayerSetting(layerSettingSet, "my_setting"));
+    EXPECT_TRUE(vkuHasLayerSetting(layerSettingSet, "my_setting"));
 
     uint32_t value_count = 0;
     VkResult result_count =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_STRING, &value_count, nullptr);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
     EXPECT_EQ(2, value_count);
 
@@ -314,7 +314,7 @@ TEST(test_layer_setting_file, vlGetLayerSettingValues_String) {
 
     value_count = 1;
     VkResult result_incomplete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_STRING, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, &values[0]);
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_STREQ("VALUE_A", values[0]);
     EXPECT_STREQ(nullptr, values[1]);
@@ -322,11 +322,11 @@ TEST(test_layer_setting_file, vlGetLayerSettingValues_String) {
 
     value_count = 2;
     VkResult result_complete =
-        vlGetLayerSettingValues(layerSettingSet, "my_setting", VL_LAYER_SETTING_TYPE_STRING, &value_count, &values[0]);
+        vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_STREQ("VALUE_A", values[0]);
     EXPECT_STREQ("VALUE_B", values[1]);
     EXPECT_EQ(2, value_count);
 
-    vlDestroyLayerSettingSet(layerSettingSet, nullptr);
+    vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
diff --git a/tests/layer/test_setting_util.cpp b/tests/layer/test_setting_util.cpp
index 627c67d..1de5e9b 100644
--- a/tests/layer/test_setting_util.cpp
+++ b/tests/layer/test_setting_util.cpp
@@ -23,7 +23,7 @@ TEST(test_layer_settings_util, FindSettingsInChain_found_first) {
     instanceCreateInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
     instanceCreateInfo.pNext = &layerSettingsCreateInfo;
 
-    EXPECT_EQ(&layerSettingsCreateInfo, vlFindLayerSettingsCreateInfo(&instanceCreateInfo));
+    EXPECT_EQ(&layerSettingsCreateInfo, vkuFindLayerSettingsCreateInfo(&instanceCreateInfo));
 }
 
 TEST(test_layer_settings_util, FindSettingsInChain_found_last) {
@@ -38,7 +38,7 @@ TEST(test_layer_settings_util, FindSettingsInChain_found_last) {
     instanceCreateInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
     instanceCreateInfo.pNext = &debugReportCallbackCreateInfo;
 
-    EXPECT_EQ(&layerSettingsCreateInfo, vlFindLayerSettingsCreateInfo(&instanceCreateInfo));
+    EXPECT_EQ(&layerSettingsCreateInfo, vkuFindLayerSettingsCreateInfo(&instanceCreateInfo));
 }
 
 TEST(test_layer_settings_util, FindSettingsInChain_found_not) {
@@ -49,7 +49,7 @@ TEST(test_layer_settings_util, FindSettingsInChain_found_not) {
     instanceCreateInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
     instanceCreateInfo.pNext = &debugReportCallbackCreateInfo;
 
-    EXPECT_EQ(nullptr, vlFindLayerSettingsCreateInfo(&instanceCreateInfo));
+    EXPECT_EQ(nullptr, vkuFindLayerSettingsCreateInfo(&instanceCreateInfo));
 }
 
 TEST(test_layer_settings_util, FindDelimiter) {
@@ -405,7 +405,7 @@ TEST(test_layer_settings_util, is_framesets) {
 
 TEST(test_layer_settings_util, to_framesets) {
     {
-        std::vector<VlFrameset> framesets = vl::ToFrameSets("0");
+        std::vector<VkuFrameset> framesets = vl::ToFrameSets("0");
         EXPECT_EQ(1, framesets.size());
 
         EXPECT_EQ(0, framesets[0].first);
@@ -414,7 +414,7 @@ TEST(test_layer_settings_util, to_framesets) {
     }
 
     {
-        std::vector<VlFrameset> framesets = vl::ToFrameSets("76");
+        std::vector<VkuFrameset> framesets = vl::ToFrameSets("76");
         EXPECT_EQ(1, framesets.size());
 
         EXPECT_EQ(76, framesets[0].first);
@@ -423,7 +423,7 @@ TEST(test_layer_settings_util, to_framesets) {
     }
 
     {
-        std::vector<VlFrameset> framesets = vl::ToFrameSets("0-2");
+        std::vector<VkuFrameset> framesets = vl::ToFrameSets("0-2");
         EXPECT_EQ(1, framesets.size());
 
         EXPECT_EQ(0, framesets[0].first);
@@ -432,7 +432,7 @@ TEST(test_layer_settings_util, to_framesets) {
     }
 
     {
-        std::vector<VlFrameset> framesets = vl::ToFrameSets("0-2,6,7");
+        std::vector<VkuFrameset> framesets = vl::ToFrameSets("0-2,6,7");
         EXPECT_EQ(3, framesets.size());
 
         EXPECT_EQ(0, framesets[0].first);
@@ -449,7 +449,7 @@ TEST(test_layer_settings_util, to_framesets) {
     }
 
     {
-        std::vector<VlFrameset> framesets = vl::ToFrameSets("0-2,6-7");
+        std::vector<VkuFrameset> framesets = vl::ToFrameSets("0-2,6-7");
         EXPECT_EQ(2, framesets.size());
 
         EXPECT_EQ(0, framesets[0].first);
@@ -462,7 +462,7 @@ TEST(test_layer_settings_util, to_framesets) {
     }
 
     {
-        std::vector<VlFrameset> framesets = vl::ToFrameSets("1-2,60,70");
+        std::vector<VkuFrameset> framesets = vl::ToFrameSets("1-2,60,70");
         EXPECT_EQ(3, framesets.size());
 
         EXPECT_EQ(1, framesets[0].first);
@@ -479,7 +479,7 @@ TEST(test_layer_settings_util, to_framesets) {
     }
 
     {
-        std::vector<VlFrameset> framesets = vl::ToFrameSets("10-20,60,70");
+        std::vector<VkuFrameset> framesets = vl::ToFrameSets("10-20,60,70");
         EXPECT_EQ(3, framesets.size());
 
         EXPECT_EQ(10, framesets[0].first);
@@ -496,7 +496,7 @@ TEST(test_layer_settings_util, to_framesets) {
     }
 
     {
-        std::vector<VlFrameset> framesets = vl::ToFrameSets("1-8-2");
+        std::vector<VkuFrameset> framesets = vl::ToFrameSets("1-8-2");
         EXPECT_EQ(1, framesets.size());
 
         EXPECT_EQ(1, framesets[0].first);
@@ -505,7 +505,7 @@ TEST(test_layer_settings_util, to_framesets) {
     }
 
     {
-        std::vector<VlFrameset> framesets = vl::ToFrameSets("1-8-2,0");
+        std::vector<VkuFrameset> framesets = vl::ToFrameSets("1-8-2,0");
         EXPECT_EQ(2, framesets.size());
 
         EXPECT_EQ(1, framesets[0].first);
@@ -518,7 +518,7 @@ TEST(test_layer_settings_util, to_framesets) {
     }
 
     {
-        std::vector<VlFrameset> framesets = vl::ToFrameSets("1-8-2,10-20-5");
+        std::vector<VkuFrameset> framesets = vl::ToFrameSets("1-8-2,10-20-5");
         EXPECT_EQ(2, framesets.size());
 
         EXPECT_EQ(1, framesets[0].first);
@@ -531,7 +531,7 @@ TEST(test_layer_settings_util, to_framesets) {
     }
 
     {
-        std::vector<VlFrameset> framesets = vl::ToFrameSets("1-8,10-20-5");
+        std::vector<VkuFrameset> framesets = vl::ToFrameSets("1-8,10-20-5");
         EXPECT_EQ(2, framesets.size());
 
         EXPECT_EQ(1, framesets[0].first);
@@ -544,7 +544,7 @@ TEST(test_layer_settings_util, to_framesets) {
     }
 
     {
-        std::vector<VlFrameset> framesets = vl::ToFrameSets("1-8-2,10-20-1");
+        std::vector<VkuFrameset> framesets = vl::ToFrameSets("1-8-2,10-20-1");
         EXPECT_EQ(2, framesets.size());
 
         EXPECT_EQ(1, framesets[0].first);
@@ -557,7 +557,7 @@ TEST(test_layer_settings_util, to_framesets) {
     }
 
     {
-        std::vector<VlFrameset> framesets = vl::ToFrameSets("1,2,3,4");
+        std::vector<VkuFrameset> framesets = vl::ToFrameSets("1,2,3,4");
         EXPECT_EQ(4, framesets.size());
 
         EXPECT_EQ(1, framesets[0].first);
@@ -578,7 +578,7 @@ TEST(test_layer_settings_util, to_framesets) {
     }
 }
 
-TEST(test_layer_settings_util, vlGetUnknownSettings) {
+TEST(test_layer_settings_util, vkuGetUnknownSettings) {
     std::vector<VkLayerSettingEXT> settings;
 
     VkBool32 value_bool = VK_TRUE;
@@ -644,13 +644,13 @@ TEST(test_layer_settings_util, vlGetUnknownSettings) {
     setting_double_value.count = 1;
     settings.push_back(setting_double_value);
 
-    VlFrameset value_frameset{76, 100, 10};
+    VkuFrameset value_frameset{76, 100, 10};
     VkLayerSettingEXT setting_frameset_value{};
     setting_frameset_value.pLayerName = "VK_LAYER_LUNARG_test";
     setting_frameset_value.pSettingName = "frameset_value";
     setting_frameset_value.type = VK_LAYER_SETTING_TYPE_UINT32_EXT;
     setting_frameset_value.pValues = &value_frameset;
-    setting_frameset_value.count = sizeof(VlFrameset) / sizeof(VlFrameset::count);
+    setting_frameset_value.count = sizeof(VkuFrameset) / sizeof(VkuFrameset::count);
     settings.push_back(setting_frameset_value);
 
     VkLayerSettingsCreateInfoEXT create_info;
@@ -665,18 +665,18 @@ TEST(test_layer_settings_util, vlGetUnknownSettings) {
     const std::uint32_t setting_name_count = static_cast<std::uint32_t>(std::size(setting_names));
 
     uint32_t unknown_settings_count = 0;
-    vlGetUnknownSettings(&create_info, setting_name_count, setting_names, &unknown_settings_count, nullptr);
+    vkuGetUnknownSettings(&create_info, setting_name_count, setting_names, &unknown_settings_count, nullptr);
     EXPECT_EQ(2, unknown_settings_count);
 
     std::vector<const char*> unknown_settings(unknown_settings_count);
 
     unknown_settings_count = 1;
-    vlGetUnknownSettings(&create_info, setting_name_count, setting_names, &unknown_settings_count, &unknown_settings[0]);
+    vkuGetUnknownSettings(&create_info, setting_name_count, setting_names, &unknown_settings_count, &unknown_settings[0]);
     EXPECT_EQ(1, unknown_settings_count);
     EXPECT_STREQ("bool_value", unknown_settings[0]);
 
     unknown_settings_count = 2;
-    vlGetUnknownSettings(&create_info, setting_name_count, setting_names, &unknown_settings_count, &unknown_settings[0]);
+    vkuGetUnknownSettings(&create_info, setting_name_count, setting_names, &unknown_settings_count, &unknown_settings[0]);
 
     EXPECT_STREQ("bool_value", unknown_settings[0]);
     EXPECT_STREQ("frameset_value", unknown_settings[1]);