OpenXR 1.0.1 release (2-August-2019)release-1.0.1

Patch release for the 1.0 series.

### GitHub Pull Requests

These had been integrated into the public repo incrementally.

- General, Build, Other
  - #87 - Fix makefiles
  - #88 - Remove unneeded generation (corresponds to issue #74, internal issue 1139, internal MR 1491)
  - #101 - Fix install of header and loader.
- Loader
  - #91 - Fix a loader bug which prevented Layers from not implementing all XR functions
  - #95 - Guard config includes/defines (relates to #81, #92)
  - #97 - Remove a constant static std::vector, use a std::array instead.
- From OpenXR-Docs:
  - #26 - Proposal for unbounded space and spatial anchor extensions (vendor extensions)

### Internal issues

- General, Build, Other
  - Makefile cleanups (internal MR 1469, 1489)
  - Add release scripts (internal MR 1496)
- Registry
  - Reserve Oculus extension numbers (internal MR 1493)
  - Add Monado headless (vendor extension) (internal MR 1482)
- Loader
  - Remove unnecessary `#ifdef _WIN32` in loader. (internal MR 1487)

### New extensions

- `XR_MND_headless`
- `XR_MSFT_spatial_anchor`
- `XR_MSFT_unbounded_reference_space`

24 files changed, 442 insertions, 625 deletions

diff --git a/CHANGELOG.SDK.md b/CHANGELOG.SDK.md
index 6a6fb89..03fbc86 100644
--- a/CHANGELOG.SDK.md
+++ b/CHANGELOG.SDK.md
@@ -12,6 +12,44 @@ along with any public pull requests that have been accepted.
 In this repository in particular, since it is primarily software,
 pull requests may be integrated as they are accepted even between periodic updates.
 
+## OpenXR 1.0.1 release (2-August-2019)
+
+Patch release for the 1.0 series.
+
+### GitHub Pull Requests
+
+These had been integrated into the public repo incrementally.
+
+- General, Build, Other
+  - #87 - Fix makefiles
+  - #88 - Remove unneeded generation (corresponds to issue #74, internal issue 1139, internal MR 1491)
+  - #101 - Fix install of header and loader.
+- Loader
+  - #91 - Fix a loader bug which prevented Layers from not implementing all XR functions
+  - #95 - Guard config includes/defines (relates to #81, #92)
+  - #97 - Remove a constant static std::vector, use a std::array instead.
+- Layers
+  - #84 - Fix Linux warning for apidump
+- From OpenXR-Docs:
+  - #26 - Proposal for unbounded space and spatial anchor extensions (vendor extensions)
+
+### Internal issues
+
+- General, Build, Other
+  - Makefile cleanups (internal MR 1469, 1489)
+  - Add release scripts (internal MR 1496)
+- Registry
+  - Reserve Oculus extension numbers (internal MR 1493)
+  - Add Monado headless (vendor extension) (internal MR 1482)
+- Loader
+  - Remove unnecessary `#ifdef _WIN32` in loader. (internal MR 1487)
+
+### New extensions
+
+- `XR_MND_headless`
+- `XR_MSFT_spatial_anchor`
+- `XR_MSFT_unbounded_reference_space`
+
 ## OpenXR 1.0.0 release (29-July-2019)
 
 Incorporates spec changes from OpenXR 1.0,
diff --git a/include/openxr/CMakeLists.txt b/include/openxr/CMakeLists.txt
index 0b5a74d..8a12404 100644
--- a/include/openxr/CMakeLists.txt
+++ b/include/openxr/CMakeLists.txt
@@ -39,7 +39,9 @@ if(HAVE_PREGENERATED AND NOT BUILD_FORCE_GENERATION)
     add_custom_target(generate_openxr_header
         COMMENT "Using found pre-generated OpenXR headers.")
 
-    set(INSTALL_HEADERS ${SOURCE_HEADERS})
+    set(INSTALL_HEADERS 
+        ${CMAKE_CURRENT_SOURCE_DIR}/openxr_platform_defines.h
+        ${SOURCE_HEADERS})
 else()
 
     set(GENERATED_HEADERS)
@@ -74,8 +76,7 @@ else()
 
     set(INSTALL_HEADERS
         ${CMAKE_CURRENT_BINARY_DIR}/openxr_platform_defines.h
-        ${CMAKE_CURRENT_BINARY_DIR}/openxr.h
-        ${CMAKE_CURRENT_BINARY_DIR}/openxr_platform.h)
+        ${GENERATED_HEADERS})
 
 
     # Define generate_openxr_header target to generate the OpenXR header files.
diff --git a/include/openxr/openxr.h b/include/openxr/openxr.h
index b776bab..667c056 100644
--- a/include/openxr/openxr.h
+++ b/include/openxr/openxr.h
@@ -35,7 +35,7 @@ extern "C" {
     ((((major) & 0xffffULL) << 48) | (((minor) & 0xffffULL) << 32) | ((patch) & 0xffffffffULL))
 
 // OpenXR current version number.
-#define XR_CURRENT_API_VERSION XR_MAKE_VERSION(1, 0, 0)
+#define XR_CURRENT_API_VERSION XR_MAKE_VERSION(1, 0, 1)
 
 #define XR_VERSION_MAJOR(version) (uint16_t)(((uint64_t)(version) >> 48)& 0xffffULL)
 #define XR_VERSION_MINOR(version) (uint16_t)(((uint64_t)(version) >> 32) & 0xffffULL)
@@ -192,6 +192,7 @@ typedef enum XrResult {
     XR_ERROR_LOCALIZED_NAME_INVALID = -49,
     XR_ERROR_ANDROID_THREAD_SETTINGS_ID_INVALID_KHR = -1000003000,
     XR_ERROR_ANDROID_THREAD_SETTINGS_FAILURE_KHR = -1000003001,
+    XR_ERROR_CREATE_SPATIAL_ANCHOR_FAILED_MSFT = -1000039001,
     XR_RESULT_MAX_ENUM = 0x7FFFFFFF
 } XrResult;
 
@@ -277,6 +278,8 @@ typedef enum XrStructureType {
     XR_TYPE_GRAPHICS_REQUIREMENTS_D3D12_KHR = 1000028002,
     XR_TYPE_VISIBILITY_MASK_KHR = 1000031000,
     XR_TYPE_EVENT_DATA_VISIBILITY_MASK_CHANGED_KHR = 1000031001,
+    XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_MSFT = 1000039000,
+    XR_TYPE_SPATIAL_ANCHOR_SPACE_CREATE_INFO_MSFT = 1000039001,
     XR_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF
 } XrStructureType;
 
@@ -304,6 +307,7 @@ typedef enum XrReferenceSpaceType {
     XR_REFERENCE_SPACE_TYPE_VIEW = 1,
     XR_REFERENCE_SPACE_TYPE_LOCAL = 2,
     XR_REFERENCE_SPACE_TYPE_STAGE = 3,
+    XR_REFERENCE_SPACE_TYPE_UNBOUNDED_MSFT = 1000038000,
     XR_REFERENCE_SPACE_TYPE_MAX_ENUM = 0x7FFFFFFF
 } XrReferenceSpaceType;
 
@@ -345,6 +349,7 @@ typedef enum XrObjectType {
     XR_OBJECT_TYPE_ACTION_SET = 5,
     XR_OBJECT_TYPE_ACTION = 6,
     XR_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT = 1000019000,
+    XR_OBJECT_TYPE_SPATIAL_ANCHOR_MSFT = 1000039000,
     XR_OBJECT_TYPE_MAX_ENUM = 0x7FFFFFFF
 } XrObjectType;
 typedef XrFlags64 XrInstanceCreateFlags;
@@ -1531,6 +1536,55 @@ XRAPI_ATTR XrResult XRAPI_CALL xrSessionInsertDebugUtilsLabelEXT(
 #define XR_VARJO_quad_views_SPEC_VERSION  1
 #define XR_VARJO_QUAD_VIEWS_EXTENSION_NAME "XR_VARJO_quad_views"
 
+
+#define XR_MSFT_unbounded_reference_space 1
+#define XR_MSFT_unbounded_reference_space_SPEC_VERSION 1
+#define XR_MSFT_UNBOUNDED_REFERENCE_SPACE_EXTENSION_NAME "XR_MSFT_unbounded_reference_space"
+
+
+#define XR_MSFT_spatial_anchor 1
+XR_DEFINE_HANDLE(XrSpatialAnchorMSFT)
+#define XR_MSFT_spatial_anchor_SPEC_VERSION 1
+#define XR_MSFT_SPATIAL_ANCHOR_EXTENSION_NAME "XR_MSFT_spatial_anchor"
+typedef struct XrSpatialAnchorCreateInfoMSFT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpace                     space;
+    XrPosef                     pose;
+    XrTime                      time;
+} XrSpatialAnchorCreateInfoMSFT;
+
+typedef struct XrSpatialAnchorSpaceCreateInfoMSFT {
+    XrStructureType             type;
+    const void* XR_MAY_ALIAS    next;
+    XrSpatialAnchorMSFT         anchor;
+    XrPosef                     poseInAnchorSpace;
+} XrSpatialAnchorSpaceCreateInfoMSFT;
+
+typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialAnchorMSFT)(XrSession session, const XrSpatialAnchorCreateInfoMSFT* createInfo, XrSpatialAnchorMSFT* anchor);
+typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialAnchorSpaceMSFT)(XrSession session, const XrSpatialAnchorSpaceCreateInfoMSFT* createInfo, XrSpace* space);
+typedef XrResult (XRAPI_PTR *PFN_xrDestroySpatialAnchorMSFT)(XrSpatialAnchorMSFT anchor);
+
+#ifndef XR_NO_PROTOTYPES
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialAnchorMSFT(
+    XrSession                                   session,
+    const XrSpatialAnchorCreateInfoMSFT*        createInfo,
+    XrSpatialAnchorMSFT*                        anchor);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialAnchorSpaceMSFT(
+    XrSession                                   session,
+    const XrSpatialAnchorSpaceCreateInfoMSFT*   createInfo,
+    XrSpace*                                    space);
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroySpatialAnchorMSFT(
+    XrSpatialAnchorMSFT                         anchor);
+#endif
+
+
+#define XR_MND_headless 1
+#define XR_MND_headless_SPEC_VERSION      1
+#define XR_MND_HEADLESS_EXTENSION_NAME    "XR_MND_headless"
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/include/openxr/openxr_reflection.h b/include/openxr/openxr_reflection.h
index 0589daa..622ceb5 100644
--- a/include/openxr/openxr_reflection.h
+++ b/include/openxr/openxr_reflection.h
@@ -96,6 +96,7 @@ XR_ENUM_STR(XrResult);
     _(XR_ERROR_LOCALIZED_NAME_INVALID, -49) \
     _(XR_ERROR_ANDROID_THREAD_SETTINGS_ID_INVALID_KHR, -1000003000) \
     _(XR_ERROR_ANDROID_THREAD_SETTINGS_FAILURE_KHR, -1000003001) \
+    _(XR_ERROR_CREATE_SPATIAL_ANCHOR_FAILED_MSFT, -1000039001) \
     _(XR_RESULT_MAX_ENUM, 0x7FFFFFFF)
 
 #define XR_LIST_ENUM_XrStructureType(_) \
@@ -180,6 +181,8 @@ XR_ENUM_STR(XrResult);
     _(XR_TYPE_GRAPHICS_REQUIREMENTS_D3D12_KHR, 1000028002) \
     _(XR_TYPE_VISIBILITY_MASK_KHR, 1000031000) \
     _(XR_TYPE_EVENT_DATA_VISIBILITY_MASK_CHANGED_KHR, 1000031001) \
+    _(XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_MSFT, 1000039000) \
+    _(XR_TYPE_SPATIAL_ANCHOR_SPACE_CREATE_INFO_MSFT, 1000039001) \
     _(XR_STRUCTURE_TYPE_MAX_ENUM, 0x7FFFFFFF)
 
 #define XR_LIST_ENUM_XrFormFactor(_) \
@@ -203,6 +206,7 @@ XR_ENUM_STR(XrResult);
     _(XR_REFERENCE_SPACE_TYPE_VIEW, 1) \
     _(XR_REFERENCE_SPACE_TYPE_LOCAL, 2) \
     _(XR_REFERENCE_SPACE_TYPE_STAGE, 3) \
+    _(XR_REFERENCE_SPACE_TYPE_UNBOUNDED_MSFT, 1000038000) \
     _(XR_REFERENCE_SPACE_TYPE_MAX_ENUM, 0x7FFFFFFF)
 
 #define XR_LIST_ENUM_XrActionType(_) \
@@ -240,6 +244,7 @@ XR_ENUM_STR(XrResult);
     _(XR_OBJECT_TYPE_ACTION_SET, 5) \
     _(XR_OBJECT_TYPE_ACTION, 6) \
     _(XR_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT, 1000019000) \
+    _(XR_OBJECT_TYPE_SPATIAL_ANCHOR_MSFT, 1000039000) \
     _(XR_OBJECT_TYPE_MAX_ENUM, 0x7FFFFFFF)
 
 #define XR_LIST_ENUM_XrAndroidThreadTypeKHR(_) \
@@ -997,6 +1002,19 @@ XR_ENUM_STR(XrResult);
     _(userCallback) \
     _(userData)
 
+#define XR_LIST_STRUCT_XrSpatialAnchorCreateInfoMSFT(_) \
+    _(type) \
+    _(next) \
+    _(space) \
+    _(pose) \
+    _(time)
+
+#define XR_LIST_STRUCT_XrSpatialAnchorSpaceCreateInfoMSFT(_) \
+    _(type) \
+    _(next) \
+    _(anchor) \
+    _(poseInAnchorSpace)
+
 
 
 
diff --git a/specification/registry/xr.xml b/specification/registry/xr.xml
index 5417608..34d03e1 100644
--- a/specification/registry/xr.xml
+++ b/specification/registry/xr.xml
@@ -49,6 +49,7 @@ maintained in the master branch of the Khronos OpenXR GitHub project.
         <tag name="INTEL"      author="Intel"                   contact="Javier Martinez @javier"/>
         <tag name="KHR"        author="Khronos"                 contact="Nick Whiting @whitingn"/>
         <tag name="LUNARG"     author="LunarG"                  contact="Mark Young @marky_lunarg, Karl Schultz @karlschultz"/>
+        <tag name="MND"        author="Monado Project"          contact="Ryan Pavlik @rpavlik"/>
         <tag name="MSFT"       author="Microsoft"               contact="Alex Turner @alexturn, Yin Li @yl_msft, Bryce Hutchings @brycehutchings, Lachlan Ford @laford_msft, Minmin Gong @gongminmin "/>
         <tag name="NV"         author="NVIDIA Corporation"      contact="Satish Salian @ssalian, Robert Menzel"/>
         <tag name="OCULUS"     author="Oculus"                  contact="Cass Everitt @casseveritt, Paul Pedriana @ppedriana"/>
@@ -111,7 +112,7 @@ maintained in the master branch of the Khronos OpenXR GitHub project.
         updates them automatically by processing a line at a time.
         -->
         <type category="define">// OpenXR current version number.
-#define <name>XR_CURRENT_API_VERSION</name> <type>XR_MAKE_VERSION</type>(1, 0, 0)</type>
+#define <name>XR_CURRENT_API_VERSION</name> <type>XR_MAKE_VERSION</type>(1, 0, 1)</type>
 
         <!-- 
         NOTE: For avoidance of ambiguity, there should only be 1 <name> tag immediately in
@@ -232,6 +233,7 @@ maintained in the master branch of the Khronos OpenXR GitHub project.
         <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrSwapchain</name>)</type>
         <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrSpace</name>)</type>
         <type category="handle" parent="XrInstance"><type>XR_DEFINE_HANDLE</type>(<name>XrDebugUtilsMessengerEXT</name>)</type>
+        <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrSpatialAnchorMSFT</name>)</type>
 
         <!-- enums and flag bits generated from corresponding <enums> tags below -->
         <type name="XrStructureType" category="enum"/>
@@ -966,6 +968,22 @@ maintained in the master branch of the Khronos OpenXR GitHub project.
             const <type>XrDebugUtilsMessengerCallbackDataEXT</type>*      callbackData,
             <type>void</type>*                                            userData);
         </type>
+
+        <!-- types for XR_MSFT_spatial_anchor -->
+        <type category="struct" name="XrSpatialAnchorCreateInfoMSFT">
+            <member values="XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_MSFT"><type>XrStructureType</type><name>type</name></member>
+            <member>const <type>void</type>* <name>next</name></member>
+            <member><type>XrSpace</type>     <name>space</name></member>
+            <member><type>XrPosef</type>     <name>pose</name></member>
+            <member><type>XrTime</type>      <name>time</name></member>
+        </type>
+        <type category="struct" name="XrSpatialAnchorSpaceCreateInfoMSFT">
+            <member values="XR_TYPE_ACTION_SPACE_CREATE_INFO"><type>XrStructureType</type> <name>type</name></member>
+            <member>const <type>void</type>*                     <name>next</name></member>
+            <member><type>XrSpatialAnchorMSFT</type>             <name>anchor</name></member>
+            <member><type>XrPosef</type>                         <name>poseInAnchorSpace</name></member>
+        </type>
+
     </types>
 
     <!-- SECTION: OpenXR enumerant (token) definitions. -->
@@ -1764,6 +1782,25 @@ maintained in the master branch of the Khronos OpenXR GitHub project.
             <param><type>XrVisibilityMaskTypeKHR</type> <name>visibilityMaskType</name></param>
             <param><type>XrVisibilityMaskKHR</type>* <name>visibilityMask</name></param>
         </command>
+
+        <!-- commands for XR_MSFT_spatial_anchor -->
+        <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_VALIDATION_FAILURE,XR_ERROR_HANDLE_INVALID,XR_ERROR_POSE_INVALID,XR_ERROR_CREATE_SPATIAL_ANCHOR_FAILED_MSFT,XR_ERROR_TIME_INVALID,XR_ERROR_SESSION_LOST,XR_SESSION_LOSS_PENDING">
+            <proto><type>XrResult</type> <name>xrCreateSpatialAnchorMSFT</name></proto>
+            <param><type>XrSession</type> <name>session</name></param>
+            <param>const <type>XrSpatialAnchorCreateInfoMSFT</type>* <name>createInfo</name></param>
+            <param><type>XrSpatialAnchorMSFT</type>* <name>anchor</name></param>
+        </command>
+        <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_VALIDATION_FAILURE,XR_ERROR_HANDLE_INVALID,XR_ERROR_POSE_INVALID,XR_ERROR_SESSION_LOST,XR_SESSION_LOSS_PENDING">
+            <proto><type>XrResult</type> <name>xrCreateSpatialAnchorSpaceMSFT</name></proto>
+            <param><type>XrSession</type> <name>session</name></param>
+            <param>const <type>XrSpatialAnchorSpaceCreateInfoMSFT</type>* <name>createInfo</name></param>
+            <param><type>XrSpace</type>* <name>space</name></param>
+        </command>
+        <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_FUNCTION_UNSUPPORTED">
+            <proto><type>XrResult</type> <name>xrDestroySpatialAnchorMSFT</name></proto>
+            <param><type>XrSpatialAnchorMSFT</type> <name>anchor</name></param>
+        </command>
+
     </commands>
 
     <!-- SECTION: OpenXR API interface definitions -->
@@ -2263,19 +2300,49 @@ maintained in the master branch of the Khronos OpenXR GitHub project.
         </require>
     </extension>
 
-    <extension name="XR_MSFT_unbounded_reference_space" number="39" type="instance" supported="disabled">
+    <extension name="XR_MSFT_unbounded_reference_space" number="39" type="instance" supported="openxr">
         <require>
             <enum value="1" name="XR_MSFT_unbounded_reference_space_SPEC_VERSION"/>
             <enum value="&quot;XR_MSFT_unbounded_reference_space&quot;" name="XR_MSFT_UNBOUNDED_REFERENCE_SPACE_EXTENSION_NAME"/>
+
+            <enum offset="0" extends="XrReferenceSpaceType" name="XR_REFERENCE_SPACE_TYPE_UNBOUNDED_MSFT"/>
         </require>
     </extension>
 
-    <extension name="XR_MSFT_spatial_anchor" number="40" type="instance" supported="disabled">
+    <extension name="XR_MSFT_spatial_anchor" number="40" type="instance" supported="openxr">
         <require>
             <enum value="1" name="XR_MSFT_spatial_anchor_SPEC_VERSION"/>
             <enum value="&quot;XR_MSFT_spatial_anchor&quot;" name="XR_MSFT_SPATIAL_ANCHOR_EXTENSION_NAME"/>
+
+            <enum offset="0" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_MSFT"/>
+            <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHOR_SPACE_CREATE_INFO_MSFT"/>
+            <command name="xrCreateSpatialAnchorMSFT" />
+            <command name="xrCreateSpatialAnchorSpaceMSFT" />
+            <command name="xrDestroySpatialAnchorMSFT" />
+            <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_SPATIAL_ANCHOR_MSFT" comment="XrSpatialAnchorMSFT" />
+            <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_CREATE_SPATIAL_ANCHOR_FAILED_MSFT" comment="Spatial anchor could not be created at that location." />
+        </require>
+    </extension>
+
+    <extension name="XR_OCULUS_extension_41" number="41" type="instance" supported="disabled">
+        <require>
+            <enum value="1" name="XR_OCULUS_extension_41_SPEC_VERSION"/>
+            <enum value="&quot;XR_OCULUS_extension_41&quot;" name="XR_OCULUS_EXTENSION_41_EXTENSION_NAME"/>
         </require>
     </extension>
 
+    <extension name="XR_OCULUS_extension_42" number="42" type="instance" supported="disabled">
+        <require>
+            <enum value="1" name="XR_OCULUS_extension_42_SPEC_VERSION"/>
+            <enum value="&quot;XR_OCULUS_extension_42&quot;" name="XR_OCULUS_EXTENSION_42_EXTENSION_NAME"/>
+        </require>
+    </extension>
+
+    <extension name="XR_MND_headless" number="43" type="instance" supported="openxr">
+        <require>
+            <enum value="1" name="XR_MND_headless_SPEC_VERSION"/>
+            <enum value="&quot;XR_MND_headless&quot;" name="XR_MND_HEADLESS_EXTENSION_NAME"/>
+        </require>
+    </extension>
     </extensions>
 </registry>
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 429c91c..1d78997 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -87,19 +87,21 @@ if (OPENGL_FOUND)
 endif()
 
 if(CMAKE_SYSTEM_NAME STREQUAL "Windows")
-    add_definitions(-DXR_USE_GRAPHICS_API_D3D)
     add_definitions(-DXR_USE_GRAPHICS_API_D3D11)
     add_definitions(-DXR_USE_GRAPHICS_API_D3D12)
 endif()
 
 if(BUILD_LOADER_WITH_EXCEPTION_HANDLING)
+    # This variable is configured into common_config.h
     set(XRLOADER_ENABLE_EXCEPTION_HANDLING TRUE)
 endif()
 # Check for the existence of the secure_getenv or __secure_getenv commands
 include(CheckFunctionExists)
-CHECK_FUNCTION_EXISTS(secure_getenv HAVE_SECURE_GETENV)
-CHECK_FUNCTION_EXISTS(__secure_getenv HAVE___SECURE_GETENV)
-CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/common_cmake_config.h.in ${CMAKE_CURRENT_BINARY_DIR}/common_cmake_config.h)
+
+check_function_exists(secure_getenv HAVE_SECURE_GETENV)
+check_function_exists(__secure_getenv HAVE___SECURE_GETENV)
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/common_config.h.in ${CMAKE_CURRENT_BINARY_DIR}/common_config.h)
+add_definitions(-DOPENXR_HAVE_COMMON_CONFIG)
 
 # Be able to find pre-generated files, if used.
 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../include
@@ -165,8 +167,6 @@ endmacro()
 set(GENERATED_OUTPUT)
 run_xr_xml_generate(utility_source_generator.py xr_generated_dispatch_table.h)
 run_xr_xml_generate(utility_source_generator.py xr_generated_dispatch_table.c)
-run_xr_xml_generate(utility_source_generator.py xr_generated_utilities.h)
-run_xr_xml_generate(utility_source_generator.py xr_generated_utilities.c)
 add_custom_target(xr_global_generated_files DEPENDS
     ${GENERATED_DEPENDS}
 )
diff --git a/src/common/filesystem_utils.cpp b/src/common/filesystem_utils.cpp
index 6367150..96788fd 100644
--- a/src/common/filesystem_utils.cpp
+++ b/src/common/filesystem_utils.cpp
@@ -22,10 +22,6 @@
 
 #include "platform_utils.hpp"
 
-#ifdef _WIN32
-#include "xr_dependencies.h"
-#endif
-
 #include <cstring>
 
 #if defined DISABLE_STD_FILESYSTEM
diff --git a/src/common/loader_interfaces.h b/src/common/loader_interfaces.h
index 23500d8..29a2f37 100644
--- a/src/common/loader_interfaces.h
+++ b/src/common/loader_interfaces.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2017 The Khronos Group Inc.
+// Copyright (c) 2017-2019 The Khronos Group Inc.
 // Copyright (c) 2017 Valve Corporation
 // Copyright (c) 2017 LunarG, Inc.
 //
@@ -19,6 +19,8 @@
 
 #pragma once
 
+#include <openxr/openxr.h>
+
 #ifdef __cplusplus
 extern "C" {
 #endif
diff --git a/src/common/platform_utils.hpp b/src/common/platform_utils.hpp
index f7b7e8d..491b6e9 100644
--- a/src/common/platform_utils.hpp
+++ b/src/common/platform_utils.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2017 The Khronos Group Inc.
+// Copyright (c) 2017-2019 The Khronos Group Inc.
 // Copyright (c) 2017 Valve Corporation
 // Copyright (c) 2017 LunarG, Inc.
 //
@@ -29,11 +29,15 @@
 #endif
 
 // This is a CMake generated file with #defines for any functions/includes
-// that it found present.  This is currently necessary to properly determine
-// if secure_getenv or __secure_getenv are present
-#if !defined(OPENXR_NON_CMAKE_BUILD)
-#include "common_cmake_config.h"
-#endif  // !defined(OPENXR_NON_CMAKE_BUILD)
+// that it found present and build-time configuration.
+// If you don't have this file, on non-Windows you'll need to define
+// one of HAVE_SECURE_GETENV or HAVE___SECURE_GETENV depending on which
+// of secure_getenv or __secure_getenv are present, as well as defining
+// XRLOADER_ENABLE_EXCEPTION_HANDLING if your standard library can throw exceptions
+// (which most can)
+#ifdef OPENXR_HAVE_COMMON_CONFIG
+#include "common_config.h"
+#endif  // OPENXR_HAVE_COMMON_CONFIG
 
 // Environment variables
 #if defined(XR_OS_LINUX)
diff --git a/src/common/xr_dependencies.h b/src/common/xr_dependencies.h
index 81d0092..7498fbb 100644
--- a/src/common/xr_dependencies.h
+++ b/src/common/xr_dependencies.h
@@ -30,8 +30,14 @@
 #define WINAPI_PARTITION_DESKTOP 1
 #endif
 
+#ifndef NOMINMAX
 #define NOMINMAX
+#endif  // !NOMINMAX
+
+#ifndef WIN32_LEAN_AND_MEAN
 #define WIN32_LEAN_AND_MEAN
+#endif  // !WIN32_LEAN_AND_MEAN
+
 #include <windows.h>
 
 #endif  // XR_USE_PLATFORM_WIN32
diff --git a/src/common_cmake_config.h.in b/src/common_cmake_config.h.in
deleted file mode 100644
index 1cf8fc2..0000000
--- a/src/common_cmake_config.h.in
+++ /dev/null
@@ -1,3 +0,0 @@
-#cmakedefine HAVE_SECURE_GETENV
-#cmakedefine HAVE___SECURE_GETENV
-#cmakedefine XRLOADER_ENABLE_EXCEPTION_HANDLING
diff --git a/src/common_config.h.in b/src/common_config.h.in
new file mode 100644
index 0000000..0431391
--- /dev/null
+++ b/src/common_config.h.in
@@ -0,0 +1,43 @@
+// Copyright (c) 2017-2019 The Khronos Group Inc.
+// Copyright (c) 2017 Valve Corporation
+// Copyright (c) 2017 LunarG, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+
+// If this file has a .h.in extension, it's the input for CMake to generate a header from.
+// If it has a .h extension, THIS IS A GENERATED FILE - DO NOT EDIT
+
+// To include the generated version of this file, make sure OPENXR_HAVE_COMMON_CONFIG is defined.
+// The provided CMake build system does this automatically.
+//
+// If you can't provide the .h version of this file (because you're not using the
+// provided CMake build system and not providing it yourself), you need to do the following:
+//
+// - Define XRLOADER_ENABLE_EXCEPTION_HANDLING if your
+//   standard library can throw exceptions
+//   (most can - it's non-standard for them to not do so.)
+// - On non-Windows, for security purposes, define one of
+//   `HAVE_SECURE_GETENV` or `HAVE___SECURE_GETENV` depending on which
+//   of secure_getenv or __secure_getenv are present, respectively
+
+
+// If defined, secure_getenv is available
+#cmakedefine HAVE_SECURE_GETENV
+
+// If defined, __secure_getenv is available
+#cmakedefine HAVE___SECURE_GETENV
+
+// If defined, the OpenXR loader will catch any standard-library exceptions.
+// Must be defined unless you're using a non-standard standard library build with exceptions disabled.
+#cmakedefine XRLOADER_ENABLE_EXCEPTION_HANDLING
diff --git a/src/loader/CMakeLists.txt b/src/loader/CMakeLists.txt
index 3a857b4..509f9c5 100644
--- a/src/loader/CMakeLists.txt
+++ b/src/loader/CMakeLists.txt
@@ -120,10 +120,6 @@ if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
     add_custom_target(lib${LOADER_NAME}.so.${MAJOR}.${MINOR} ALL
         COMMAND ${CMAKE_COMMAND} -E create_symlink lib${LOADER_NAME}.so.${MAJOR}.${MINOR}.${PATCH} lib${LOADER_NAME}.so.${MAJOR}.${MINOR})
 
-    install(TARGETS ${LOADER_NAME}
-        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-        RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
     set(XR_API_VERSION "${MAJOR}.${MINOR}")
     configure_file("openxr.pc.in" "openxr.pc" @ONLY)
     install(FILES "${CMAKE_CURRENT_BINARY_DIR}/openxr.pc" DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig")
@@ -176,6 +172,7 @@ if(CMAKE_COMPILER_IS_GNUCC OR CMAKE_C_COMPILER_ID MATCHES "Clang")
     endif()
 endif()
 
-install(TARGETS ${LOADER_NAME} DESTINATION lib)
-
-# Custom commands to build dependencies for above targets
+install(TARGETS ${LOADER_NAME}
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
diff --git a/src/loader/exception_handling.hpp b/src/loader/exception_handling.hpp
index 36a63df..4943623 100644
--- a/src/loader/exception_handling.hpp
+++ b/src/loader/exception_handling.hpp
@@ -18,7 +18,9 @@
 
 #pragma once
 
-#include "common_cmake_config.h"
+#ifdef OPENXR_HAVE_COMMON_CONFIG
+#include "common_config.h"
+#endif  // OPENXR_HAVE_COMMON_CONFIG
 
 #ifdef XRLOADER_ENABLE_EXCEPTION_HANDLING
 #include <stdexcept>
@@ -39,6 +41,13 @@
     }
 
 #else
+
+// Make it hard to accidentally build this wrong.
+#ifndef XRLOADER_SILENCE_EXCEPTION_HANDLING_WARNING
+#warning \
+    "Warning: Exception handling disabled in OpenXR loader - exceptions may escape C ABI if standard library can throw exceptions!"
+#endif
+
 #define XRLOADER_ABI_TRY
 #define XRLOADER_ABI_CATCH_BAD_ALLOC_OOM
 #define XRLOADER_ABI_CATCH_FALLBACK
diff --git a/src/loader/loader_core.cpp b/src/loader/loader_core.cpp
index 5086674..ee878e8 100644
--- a/src/loader/loader_core.cpp
+++ b/src/loader/loader_core.cpp
@@ -17,9 +17,9 @@
 // Author: Mark Young <marky@lunarg.com>
 //
 
-#ifdef XR_OS_WINDOWS
+#if defined(_MSC_VER) && !defined(_CRT_SECURE_NO_WARNINGS)
 #define _CRT_SECURE_NO_WARNINGS
-#endif
+#endif  // defined(_MSC_VER) && !defined(_CRT_SECURE_NO_WARNINGS)
 
 #include "api_layer_interface.hpp"
 #include "exception_handling.hpp"
@@ -127,8 +127,7 @@ xrEnumerateInstanceExtensionProperties(const char *layerName, uint32_t propertyC
     // If this is not in reference to a specific layer, then add the loader-specific extension properties as well.
     // These are extensions that the loader directly supports.
     if (!just_layer_properties) {
-        auto loader_extension_props = LoaderInstance::LoaderSpecificExtensions();
-        for (XrExtensionProperties &loader_prop : loader_extension_props) {
+        for (const XrExtensionProperties &loader_prop : LoaderInstance::LoaderSpecificExtensions()) {
             bool found_prop = false;
             for (XrExtensionProperties &existing_prop : extension_properties) {
                 if (0 == strcmp(existing_prop.extensionName, loader_prop.extensionName)) {
diff --git a/src/loader/loader_instance.cpp b/src/loader/loader_instance.cpp
index 67b0ee5..9ffdab8 100644
--- a/src/loader/loader_instance.cpp
+++ b/src/loader/loader_instance.cpp
@@ -17,9 +17,9 @@
 // Author: Mark Young <marky@lunarg.com>
 //
 
-#ifdef XR_OS_WINDOWS
+#if defined(_MSC_VER) && !defined(_CRT_SECURE_NO_WARNINGS)
 #define _CRT_SECURE_NO_WARNINGS
-#endif
+#endif  // defined(_MSC_VER) && !defined(_CRT_SECURE_NO_WARNINGS)
 
 #include "loader_instance.hpp"
 
@@ -42,9 +42,11 @@
 
 // Extensions that are supported by the loader, but may not be supported
 // the the runtime.
-static const XrExtensionProperties g_debug_utils_props = {XR_TYPE_EXTENSION_PROPERTIES, nullptr, XR_EXT_DEBUG_UTILS_EXTENSION_NAME,
-                                                          XR_EXT_debug_utils_SPEC_VERSION};
-const std::vector<XrExtensionProperties> LoaderInstance::_loader_supported_extensions = {g_debug_utils_props};
+const std::array<XrExtensionProperties, 1>& LoaderInstance::LoaderSpecificExtensions() {
+    static const std::array<XrExtensionProperties, 1> extensions = {XrExtensionProperties{
+        XR_TYPE_EXTENSION_PROPERTIES, nullptr, XR_EXT_DEBUG_UTILS_EXTENSION_NAME, XR_EXT_debug_utils_SPEC_VERSION}};
+    return extensions;
+}
 
 // Factory method
 XrResult LoaderInstance::CreateInstance(std::vector<std::unique_ptr<ApiLayerInterface>>&& api_layer_interfaces,
@@ -126,7 +128,7 @@ XrResult LoaderInstance::CreateInstance(std::vector<std::unique_ptr<ApiLayerInte
             }
             // Next check the loader
             if (!found) {
-                for (auto loader_extension : LoaderInstance::_loader_supported_extensions) {
+                for (auto& loader_extension : LoaderInstance::LoaderSpecificExtensions()) {
                     if (strcmp(loader_extension.extensionName, info->enabledExtensionNames[ext]) == 0) {
                         found = true;
                         break;
diff --git a/src/loader/loader_instance.hpp b/src/loader/loader_instance.hpp
index 5aeff39..5f1eb31 100644
--- a/src/loader/loader_instance.hpp
+++ b/src/loader/loader_instance.hpp
@@ -23,6 +23,7 @@
 
 #include <openxr/openxr.h>
 
+#include <array>
 #include <cmath>
 #include <memory>
 #include <mutex>
@@ -80,7 +81,7 @@ class LoaderInstance {
     std::vector<std::unique_ptr<ApiLayerInterface>>& LayerInterfaces() { return _api_layer_interfaces; }
     void AddEnabledExtension(const std::string& extension) { return _enabled_extensions.push_back(extension); }
     bool ExtensionIsEnabled(const std::string& extension);
-    static const std::vector<XrExtensionProperties>& LoaderSpecificExtensions() { return _loader_supported_extensions; }
+    static const std::array<XrExtensionProperties, 1>& LoaderSpecificExtensions();
     XrDebugUtilsMessengerEXT DefaultDebugUtilsMessenger() { return _messenger; }
     void SetDefaultDebugUtilsMessenger(XrDebugUtilsMessengerEXT messenger) { _messenger = messenger; }
 
@@ -91,7 +92,6 @@ class LoaderInstance {
     XrInstance _runtime_instance;
     bool _dispatch_valid;
     std::unique_ptr<XrGeneratedDispatchTable> _dispatch_table;
-    static const std::vector<XrExtensionProperties> _loader_supported_extensions;
     std::vector<std::string> _enabled_extensions;
     // Internal debug messenger created during xrCreateInstance
     XrDebugUtilsMessengerEXT _messenger;
diff --git a/src/loader/manifest_file.cpp b/src/loader/manifest_file.cpp
index ae8830b..ebef98c 100644
--- a/src/loader/manifest_file.cpp
+++ b/src/loader/manifest_file.cpp
@@ -17,13 +17,16 @@
 // Author: Mark Young <marky@lunarg.com>
 //
 
-#ifdef XR_OS_WINDOWS
+#if defined(_MSC_VER) && !defined(_CRT_SECURE_NO_WARNINGS)
 #define _CRT_SECURE_NO_WARNINGS
-#endif
+#endif  // defined(_MSC_VER) && !defined(_CRT_SECURE_NO_WARNINGS)
 
 #include "manifest_file.hpp"
 
-#include "common_cmake_config.h"
+#ifdef OPENXR_HAVE_COMMON_CONFIG
+#include "common_config.h"
+#endif  // OPENXR_HAVE_COMMON_CONFIG
+
 #include "filesystem_utils.hpp"
 #include "loader_platform.hpp"
 #include "platform_utils.hpp"
diff --git a/src/loader/xr_generated_loader.cpp b/src/loader/xr_generated_loader.cpp
index f9c8734..316ffe5 100644
--- a/src/loader/xr_generated_loader.cpp
+++ b/src/loader/xr_generated_loader.cpp
@@ -31,7 +31,6 @@
 #include "loader_platform.hpp"
 #include "runtime_interface.hpp"
 #include "xr_generated_dispatch_table.h"
-#include "xr_generated_utilities.h"
 
 #include "xr_dependencies.h"
 #include <openxr/openxr.h>
@@ -51,6 +50,7 @@ HandleLoaderMap<XrAction> g_action_map;
 HandleLoaderMap<XrSwapchain> g_swapchain_map;
 HandleLoaderMap<XrActionSet> g_actionset_map;
 HandleLoaderMap<XrDebugUtilsMessengerEXT> g_debugutilsmessengerext_map;
+HandleLoaderMap<XrSpatialAnchorMSFT> g_spatialanchormsft_map;
 
 // Function used to clean up any residual map values that point to an instance prior to that
 // instance being deleted.
@@ -62,6 +62,7 @@ void LoaderCleanUpMapsForInstance(LoaderInstance *instance) {
     g_swapchain_map.RemoveHandlesForLoader(*instance);
     g_actionset_map.RemoveHandlesForLoader(*instance);
     g_debugutilsmessengerext_map.RemoveHandlesForLoader(*instance);
+    g_spatialanchormsft_map.RemoveHandlesForLoader(*instance);
 }
 
 #ifdef __cplusplus
@@ -125,21 +126,6 @@ XRAPI_ATTR XrResult XRAPI_CALL xrResultToString(
 }
 XRLOADER_ABI_CATCH_FALLBACK
 
-XRAPI_ATTR XrResult XRAPI_CALL LoaderGenTermXrResultToString(
-    XrInstance                                  instance,
-    XrResult                                    value,
-    char                                        buffer[XR_MAX_RESULT_STRING_SIZE]) {
-    XrResult result = GeneratedXrUtilitiesResultToString(value, buffer);
-    if (XR_SUCCEEDED(result)) {
-        return result;
-    }
-    // If we did not find it in the generated code, ask the runtime.
-    const XrGeneratedDispatchTable* dispatch_table = RuntimeInterface::GetDispatchTable(instance);
-    if (nullptr != dispatch_table->ResultToString) {
-    result = dispatch_table->ResultToString(instance, value, buffer);
-    }
-    return result;
-}
 
 XRAPI_ATTR XrResult XRAPI_CALL xrStructureTypeToString(
     XrInstance                                  instance,
@@ -159,21 +145,6 @@ XRAPI_ATTR XrResult XRAPI_CALL xrStructureTypeToString(
 }
 XRLOADER_ABI_CATCH_FALLBACK
 
-XRAPI_ATTR XrResult XRAPI_CALL LoaderGenTermXrStructureTypeToString(
-    XrInstance                                  instance,
-    XrStructureType                             value,
-    char                                        buffer[XR_MAX_STRUCTURE_NAME_SIZE]) {
-    XrResult result = GeneratedXrUtilitiesStructureTypeToString(value, buffer);
-    if (XR_SUCCEEDED(result)) {
-        return result;
-    }
-    // If we did not find it in the generated code, ask the runtime.
-    const XrGeneratedDispatchTable* dispatch_table = RuntimeInterface::GetDispatchTable(instance);
-    if (nullptr != dispatch_table->StructureTypeToString) {
-    result = dispatch_table->StructureTypeToString(instance, value, buffer);
-    }
-    return result;
-}
 
 XRAPI_ATTR XrResult XRAPI_CALL xrGetSystem(
     XrInstance                                  instance,
@@ -1699,6 +1670,110 @@ XRLOADER_ABI_CATCH_FALLBACK
 
 
 
+// ---- XR_MSFT_spatial_anchor extension commands
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialAnchorMSFT(
+    XrSession                                   session,
+    const XrSpatialAnchorCreateInfoMSFT*        createInfo,
+    XrSpatialAnchorMSFT*                        anchor) XRLOADER_ABI_TRY {
+    LoaderInstance *loader_instance = g_session_map.Get(session);
+    if (nullptr == loader_instance) {
+            LoaderLogger::LogValidationErrorMessage(
+                "VUID-xrCreateSpatialAnchorMSFT-session-parameter",
+                "xrCreateSpatialAnchorMSFT",
+                "session is not a valid XrSession",
+                {XrLoaderLogObjectInfo{session, XR_OBJECT_TYPE_SESSION}});
+        return XR_ERROR_HANDLE_INVALID;
+    }
+    const std::unique_ptr<XrGeneratedDispatchTable>& dispatch_table = loader_instance->DispatchTable();
+        XrResult result = XR_SUCCESS;
+    if (!loader_instance->ExtensionIsEnabled("XR_MSFT_spatial_anchor")) {
+        LoaderLogger::LogValidationErrorMessage("VUID-xrCreateSpatialAnchorMSFT-extension-notenabled",
+                                                "xrCreateSpatialAnchorMSFT",
+                                                "The XR_MSFT_spatial_anchor extension has not been enabled prior to calling xrCreateSpatialAnchorMSFT");
+        return XR_ERROR_FUNCTION_UNSUPPORTED;
+    }
+
+    result = dispatch_table->CreateSpatialAnchorMSFT(session, createInfo, anchor);
+        if (XR_SUCCESS == result && nullptr != anchor) {
+            XrResult insert_result = g_spatialanchormsft_map.Insert(*anchor, *loader_instance);
+            if (XR_FAILED(insert_result)) {
+                LoaderLogger::LogErrorMessage(
+                    "xrCreateSpatialAnchorMSFT",
+                    "Failed inserting new spatialanchormsft into map: may be null or not unique");
+            }
+        }
+    return result;
+}
+XRLOADER_ABI_CATCH_FALLBACK
+
+
+XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialAnchorSpaceMSFT(
+    XrSession                                   session,
+    const XrSpatialAnchorSpaceCreateInfoMSFT*   createInfo,
+    XrSpace*                                    space) XRLOADER_ABI_TRY {
+    LoaderInstance *loader_instance = g_session_map.Get(session);
+    if (nullptr == loader_instance) {
+            LoaderLogger::LogValidationErrorMessage(
+                "VUID-xrCreateSpatialAnchorSpaceMSFT-session-parameter",
+                "xrCreateSpatialAnchorSpaceMSFT",
+                "session is not a valid XrSession",
+                {XrLoaderLogObjectInfo{session, XR_OBJECT_TYPE_SESSION}});
+        return XR_ERROR_HANDLE_INVALID;
+    }
+    const std::unique_ptr<XrGeneratedDispatchTable>& dispatch_table = loader_instance->DispatchTable();
+        XrResult result = XR_SUCCESS;
+    if (!loader_instance->ExtensionIsEnabled("XR_MSFT_spatial_anchor")) {
+        LoaderLogger::LogValidationErrorMessage("VUID-xrCreateSpatialAnchorSpaceMSFT-extension-notenabled",
+                                                "xrCreateSpatialAnchorSpaceMSFT",
+                                                "The XR_MSFT_spatial_anchor extension has not been enabled prior to calling xrCreateSpatialAnchorSpaceMSFT");
+        return XR_ERROR_FUNCTION_UNSUPPORTED;
+    }
+
+    result = dispatch_table->CreateSpatialAnchorSpaceMSFT(session, createInfo, space);
+        if (XR_SUCCESS == result && nullptr != space) {
+            XrResult insert_result = g_space_map.Insert(*space, *loader_instance);
+            if (XR_FAILED(insert_result)) {
+                LoaderLogger::LogErrorMessage(
+                    "xrCreateSpatialAnchorSpaceMSFT",
+                    "Failed inserting new space into map: may be null or not unique");
+            }
+        }
+    return result;
+}
+XRLOADER_ABI_CATCH_FALLBACK
+
+
+XRAPI_ATTR XrResult XRAPI_CALL xrDestroySpatialAnchorMSFT(
+    XrSpatialAnchorMSFT                         anchor) XRLOADER_ABI_TRY {
+    LoaderInstance *loader_instance = g_spatialanchormsft_map.Get(anchor);
+    // Destroy the mapping entry for this item if it was valid.
+    if (nullptr != loader_instance) {
+            g_spatialanchormsft_map.Erase(anchor);
+    }
+    if (nullptr == loader_instance) {
+            LoaderLogger::LogValidationErrorMessage(
+                "VUID-xrDestroySpatialAnchorMSFT-anchor-parameter",
+                "xrDestroySpatialAnchorMSFT",
+                "anchor is not a valid XrSpatialAnchorMSFT",
+                {XrLoaderLogObjectInfo{anchor, XR_OBJECT_TYPE_SPATIAL_ANCHOR_MSFT}});
+        return XR_ERROR_HANDLE_INVALID;
+    }
+    const std::unique_ptr<XrGeneratedDispatchTable>& dispatch_table = loader_instance->DispatchTable();
+        XrResult result = XR_SUCCESS;
+    if (!loader_instance->ExtensionIsEnabled("XR_MSFT_spatial_anchor")) {
+        LoaderLogger::LogValidationErrorMessage("VUID-xrDestroySpatialAnchorMSFT-extension-notenabled",
+                                                "xrDestroySpatialAnchorMSFT",
+                                                "The XR_MSFT_spatial_anchor extension has not been enabled prior to calling xrDestroySpatialAnchorMSFT");
+        return XR_ERROR_FUNCTION_UNSUPPORTED;
+    }
+
+    result = dispatch_table->DestroySpatialAnchorMSFT(anchor);
+    return result;
+}
+XRLOADER_ABI_CATCH_FALLBACK
+
+
+
 LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrGetInstanceProcAddr(XrInstance instance, const char* name,
                                                                    PFN_xrVoidFunction* function) XRLOADER_ABI_TRY {
     if (nullptr == function) {
@@ -2013,6 +2088,21 @@ LOADER_EXPORT XRAPI_ATTR XrResult XRAPI_CALL xrGetInstanceProcAddr(XrInstance in
             if (loader_instance->ExtensionIsEnabled("XR_EXT_debug_utils")) {
                 *function = reinterpret_cast<PFN_xrVoidFunction>(xrSessionInsertDebugUtilsLabelEXT);
             }
+
+        // ---- XR_MSFT_spatial_anchor extension commands
+
+        } else if (func_name == "CreateSpatialAnchorMSFT") {
+            if (loader_instance->ExtensionIsEnabled("XR_MSFT_spatial_anchor")) {
+                *function = reinterpret_cast<PFN_xrVoidFunction>(loader_instance->DispatchTable()->CreateSpatialAnchorMSFT);
+            }
+        } else if (func_name == "CreateSpatialAnchorSpaceMSFT") {
+            if (loader_instance->ExtensionIsEnabled("XR_MSFT_spatial_anchor")) {
+                *function = reinterpret_cast<PFN_xrVoidFunction>(loader_instance->DispatchTable()->CreateSpatialAnchorSpaceMSFT);
+            }
+        } else if (func_name == "DestroySpatialAnchorMSFT") {
+            if (loader_instance->ExtensionIsEnabled("XR_MSFT_spatial_anchor")) {
+                *function = reinterpret_cast<PFN_xrVoidFunction>(loader_instance->DispatchTable()->DestroySpatialAnchorMSFT);
+            }
         }
     }
     if (*function == nullptr) {
@@ -2028,16 +2118,15 @@ XRAPI_ATTR XrResult XRAPI_CALL LoaderXrTermGetInstanceProcAddr(XrInstance instan
 
     // A few instance commands need to go through a loader terminator.
     // Otherwise, go directly to the runtime version of the command if it exists.
+    // But first set the function pointer to NULL so that the fall-through below actually works.
+    *function = nullptr;
+
     if (0 == strcmp(name, "xrGetInstanceProcAddr")) {
         *function = reinterpret_cast<PFN_xrVoidFunction>(LoaderXrTermGetInstanceProcAddr);
     } else if (0 == strcmp(name, "xrCreateInstance")) {
         *function = reinterpret_cast<PFN_xrVoidFunction>(LoaderXrTermCreateInstance);
     } else if (0 == strcmp(name, "xrDestroyInstance")) {
         *function = reinterpret_cast<PFN_xrVoidFunction>(LoaderXrTermDestroyInstance);
-    } else if (0 == strcmp(name, "xrResultToString")) {
-        *function = reinterpret_cast<PFN_xrVoidFunction>(LoaderGenTermXrResultToString);
-    } else if (0 == strcmp(name, "xrStructureTypeToString")) {
-        *function = reinterpret_cast<PFN_xrVoidFunction>(LoaderGenTermXrStructureTypeToString);
     } else if (0 == strcmp(name, "xrSetDebugUtilsObjectNameEXT")) {
         *function = reinterpret_cast<PFN_xrVoidFunction>(LoaderXrTermSetDebugUtilsObjectNameEXT);
     } else if (0 == strcmp(name, "xrCreateDebugUtilsMessengerEXT")) {
@@ -2195,6 +2284,11 @@ void LoaderGenInitInstanceDispatchTable(XrInstance instance, std::unique_ptr<XrG
     LoaderXrTermGetInstanceProcAddr(instance, "xrSessionBeginDebugUtilsLabelRegionEXT", reinterpret_cast<PFN_xrVoidFunction*>(&table->SessionBeginDebugUtilsLabelRegionEXT));
     LoaderXrTermGetInstanceProcAddr(instance, "xrSessionEndDebugUtilsLabelRegionEXT", reinterpret_cast<PFN_xrVoidFunction*>(&table->SessionEndDebugUtilsLabelRegionEXT));
     LoaderXrTermGetInstanceProcAddr(instance, "xrSessionInsertDebugUtilsLabelEXT", reinterpret_cast<PFN_xrVoidFunction*>(&table->SessionInsertDebugUtilsLabelEXT));
+
+    // ---- XR_MSFT_spatial_anchor extension commands
+    LoaderXrTermGetInstanceProcAddr(instance, "xrCreateSpatialAnchorMSFT", reinterpret_cast<PFN_xrVoidFunction*>(&table->CreateSpatialAnchorMSFT));
+    LoaderXrTermGetInstanceProcAddr(instance, "xrCreateSpatialAnchorSpaceMSFT", reinterpret_cast<PFN_xrVoidFunction*>(&table->CreateSpatialAnchorSpaceMSFT));
+    LoaderXrTermGetInstanceProcAddr(instance, "xrDestroySpatialAnchorMSFT", reinterpret_cast<PFN_xrVoidFunction*>(&table->DestroySpatialAnchorMSFT));
 }
 
 // Instance Update Dispatch Table with an API Layer Interface
@@ -2561,6 +2655,20 @@ void ApiLayerInterface::GenUpdateInstanceDispatchTable(XrInstance instance, std:
     if (nullptr != cur_func_ptr) {
         table->SessionInsertDebugUtilsLabelEXT = reinterpret_cast<PFN_xrSessionInsertDebugUtilsLabelEXT>(cur_func_ptr);
     }
+
+    // ---- XR_MSFT_spatial_anchor extension commands
+    _get_instant_proc_addr(instance, "xrCreateSpatialAnchorMSFT", &cur_func_ptr);
+    if (nullptr != cur_func_ptr) {
+        table->CreateSpatialAnchorMSFT = reinterpret_cast<PFN_xrCreateSpatialAnchorMSFT>(cur_func_ptr);
+    }
+    _get_instant_proc_addr(instance, "xrCreateSpatialAnchorSpaceMSFT", &cur_func_ptr);
+    if (nullptr != cur_func_ptr) {
+        table->CreateSpatialAnchorSpaceMSFT = reinterpret_cast<PFN_xrCreateSpatialAnchorSpaceMSFT>(cur_func_ptr);
+    }
+    _get_instant_proc_addr(instance, "xrDestroySpatialAnchorMSFT", &cur_func_ptr);
+    if (nullptr != cur_func_ptr) {
+        table->DestroySpatialAnchorMSFT = reinterpret_cast<PFN_xrDestroySpatialAnchorMSFT>(cur_func_ptr);
+    }
 }
 #ifdef __cplusplus
 } // extern "C"
diff --git a/src/loader/xr_generated_loader.hpp b/src/loader/xr_generated_loader.hpp
index a87116b..1eadc0d 100644
--- a/src/loader/xr_generated_loader.hpp
+++ b/src/loader/xr_generated_loader.hpp
@@ -275,14 +275,6 @@ XRAPI_ATTR XrResult XRAPI_CALL LoaderXrTermCreateApiLayerInstance(const XrInstan
 
 
 // Generated loader terminator prototypes
-XRAPI_ATTR XrResult XRAPI_CALL LoaderGenTermXrResultToString(
-    XrInstance                                  instance,
-    XrResult                                    value,
-    char                                        buffer[XR_MAX_RESULT_STRING_SIZE]);
-XRAPI_ATTR XrResult XRAPI_CALL LoaderGenTermXrStructureTypeToString(
-    XrInstance                                  instance,
-    XrStructureType                             value,
-    char                                        buffer[XR_MAX_STRUCTURE_NAME_SIZE]);
 // Instance Init Dispatch Table (put all terminators in first)
 void LoaderGenInitInstanceDispatchTable(XrInstance runtime_instance,
                                         std::unique_ptr<XrGeneratedDispatchTable>& table);
@@ -299,6 +291,7 @@ extern HandleLoaderMap<XrAction> g_action_map;
 extern HandleLoaderMap<XrSwapchain> g_swapchain_map;
 extern HandleLoaderMap<XrActionSet> g_actionset_map;
 extern HandleLoaderMap<XrDebugUtilsMessengerEXT> g_debugutilsmessengerext_map;
+extern HandleLoaderMap<XrSpatialAnchorMSFT> g_spatialanchormsft_map;
 
 // Function used to clean up any residual map values that point to an instance prior to that
 // instance being deleted.
diff --git a/src/xr_generated_dispatch_table.c b/src/xr_generated_dispatch_table.c
index a2e30e4..eeaed7b 100644
--- a/src/xr_generated_dispatch_table.c
+++ b/src/xr_generated_dispatch_table.c
@@ -21,11 +21,11 @@
 // Author: Mark Young <marky@lunarg.com>
 //
 
+#include "xr_generated_dispatch_table.h"
 #include "xr_dependencies.h"
 #include <openxr/openxr.h>
 #include <openxr/openxr_platform.h>
 
-#include "xr_generated_dispatch_table.h"
 
 #ifdef __cplusplus
 extern "C" { 
@@ -167,8 +167,14 @@ void GeneratedXrPopulateDispatchTable(struct XrGeneratedDispatchTable *table,
     (get_inst_proc_addr(instance, "xrSessionBeginDebugUtilsLabelRegionEXT", (PFN_xrVoidFunction*)&table->SessionBeginDebugUtilsLabelRegionEXT));
     (get_inst_proc_addr(instance, "xrSessionEndDebugUtilsLabelRegionEXT", (PFN_xrVoidFunction*)&table->SessionEndDebugUtilsLabelRegionEXT));
     (get_inst_proc_addr(instance, "xrSessionInsertDebugUtilsLabelEXT", (PFN_xrVoidFunction*)&table->SessionInsertDebugUtilsLabelEXT));
+
+    // ---- XR_MSFT_spatial_anchor extension commands
+    (get_inst_proc_addr(instance, "xrCreateSpatialAnchorMSFT", (PFN_xrVoidFunction*)&table->CreateSpatialAnchorMSFT));
+    (get_inst_proc_addr(instance, "xrCreateSpatialAnchorSpaceMSFT", (PFN_xrVoidFunction*)&table->CreateSpatialAnchorSpaceMSFT));
+    (get_inst_proc_addr(instance, "xrDestroySpatialAnchorMSFT", (PFN_xrVoidFunction*)&table->DestroySpatialAnchorMSFT));
 }
 
+
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/src/xr_generated_dispatch_table.h b/src/xr_generated_dispatch_table.h
index 3203464..75e04d5 100644
--- a/src/xr_generated_dispatch_table.h
+++ b/src/xr_generated_dispatch_table.h
@@ -167,6 +167,11 @@ struct XrGeneratedDispatchTable {
     PFN_xrSessionBeginDebugUtilsLabelRegionEXT SessionBeginDebugUtilsLabelRegionEXT;
     PFN_xrSessionEndDebugUtilsLabelRegionEXT SessionEndDebugUtilsLabelRegionEXT;
     PFN_xrSessionInsertDebugUtilsLabelEXT SessionInsertDebugUtilsLabelEXT;
+
+    // ---- XR_MSFT_spatial_anchor extension commands
+    PFN_xrCreateSpatialAnchorMSFT CreateSpatialAnchorMSFT;
+    PFN_xrCreateSpatialAnchorSpaceMSFT CreateSpatialAnchorSpaceMSFT;
+    PFN_xrDestroySpatialAnchorMSFT DestroySpatialAnchorMSFT;
 };
 
 
diff --git a/src/xr_generated_utilities.c b/src/xr_generated_utilities.c
deleted file mode 100644
index 7bb5b5b..0000000
--- a/src/xr_generated_utilities.c
+++ /dev/null
@@ -1,488 +0,0 @@
-// *********** THIS FILE IS GENERATED - DO NOT EDIT ***********
-//     See utility_source_generator.py for modifications
-// ************************************************************
-
-// Copyright (c) 2017-2019 The Khronos Group Inc.
-// Copyright (c) 2017-2019 Valve Corporation
-// Copyright (c) 2017-2019 LunarG, Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// Author: Mark Young <marky@lunarg.com>
-//
-
-#ifdef _WIN32
-// Disable Windows warning about using strncpy_s instead of strncpy
-#define  _CRT_SECURE_NO_WARNINGS 1
-#endif // _WIN32
-
-#include "xr_generated_utilities.h"
-
-#include <openxr/openxr.h>
-
-#include <stdio.h>
-#include <string.h>
-
-
-#ifdef __cplusplus
-extern "C" { 
-#endif
-
-XrResult GeneratedXrUtilitiesResultToString(XrResult result,
-                                            char buffer[XR_MAX_RESULT_STRING_SIZE]) {
-    if (NULL == buffer) {
-        return XR_ERROR_VALIDATION_FAILURE;
-    }
-    XrResult int_result = XR_SUCCESS;
-    switch (result) {
-        case XR_SUCCESS:
-            strncpy(buffer, "XR_SUCCESS", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        case XR_TIMEOUT_EXPIRED:
-            strncpy(buffer, "XR_TIMEOUT_EXPIRED", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        case XR_SESSION_LOSS_PENDING:
-            strncpy(buffer, "XR_SESSION_LOSS_PENDING", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        case XR_EVENT_UNAVAILABLE:
-            strncpy(buffer, "XR_EVENT_UNAVAILABLE", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        case XR_SPACE_BOUNDS_UNAVAILABLE:
-            strncpy(buffer, "XR_SPACE_BOUNDS_UNAVAILABLE", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        case XR_SESSION_NOT_FOCUSED:
-            strncpy(buffer, "XR_SESSION_NOT_FOCUSED", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        case XR_FRAME_DISCARDED:
-            strncpy(buffer, "XR_FRAME_DISCARDED", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        case XR_ERROR_VALIDATION_FAILURE:
-            strncpy(buffer, "XR_ERROR_VALIDATION_FAILURE", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        case XR_ERROR_RUNTIME_FAILURE:
-            strncpy(buffer, "XR_ERROR_RUNTIME_FAILURE", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        case XR_ERROR_OUT_OF_MEMORY:
-            strncpy(buffer, "XR_ERROR_OUT_OF_MEMORY", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        case XR_ERROR_API_VERSION_UNSUPPORTED:
-            strncpy(buffer, "XR_ERROR_API_VERSION_UNSUPPORTED", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        case XR_ERROR_INITIALIZATION_FAILED:
-            strncpy(buffer, "XR_ERROR_INITIALIZATION_FAILED", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        case XR_ERROR_FUNCTION_UNSUPPORTED:
-            strncpy(buffer, "XR_ERROR_FUNCTION_UNSUPPORTED", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        case XR_ERROR_FEATURE_UNSUPPORTED:
-            strncpy(buffer, "XR_ERROR_FEATURE_UNSUPPORTED", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        case XR_ERROR_EXTENSION_NOT_PRESENT:
-            strncpy(buffer, "XR_ERROR_EXTENSION_NOT_PRESENT", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        case XR_ERROR_LIMIT_REACHED:
-            strncpy(buffer, "XR_ERROR_LIMIT_REACHED", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        case XR_ERROR_SIZE_INSUFFICIENT:
-            strncpy(buffer, "XR_ERROR_SIZE_INSUFFICIENT", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        case XR_ERROR_HANDLE_INVALID:
-            strncpy(buffer, "XR_ERROR_HANDLE_INVALID", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        case XR_ERROR_INSTANCE_LOST:
-            strncpy(buffer, "XR_ERROR_INSTANCE_LOST", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        case XR_ERROR_SESSION_RUNNING:
-            strncpy(buffer, "XR_ERROR_SESSION_RUNNING", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        case XR_ERROR_SESSION_NOT_RUNNING:
-            strncpy(buffer, "XR_ERROR_SESSION_NOT_RUNNING", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        case XR_ERROR_SESSION_LOST:
-            strncpy(buffer, "XR_ERROR_SESSION_LOST", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        case XR_ERROR_SYSTEM_INVALID:
-            strncpy(buffer, "XR_ERROR_SYSTEM_INVALID", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        case XR_ERROR_PATH_INVALID:
-            strncpy(buffer, "XR_ERROR_PATH_INVALID", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        case XR_ERROR_PATH_COUNT_EXCEEDED:
-            strncpy(buffer, "XR_ERROR_PATH_COUNT_EXCEEDED", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        case XR_ERROR_PATH_FORMAT_INVALID:
-            strncpy(buffer, "XR_ERROR_PATH_FORMAT_INVALID", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        case XR_ERROR_PATH_UNSUPPORTED:
-            strncpy(buffer, "XR_ERROR_PATH_UNSUPPORTED", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        case XR_ERROR_LAYER_INVALID:
-            strncpy(buffer, "XR_ERROR_LAYER_INVALID", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        case XR_ERROR_LAYER_LIMIT_EXCEEDED:
-            strncpy(buffer, "XR_ERROR_LAYER_LIMIT_EXCEEDED", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        case XR_ERROR_SWAPCHAIN_RECT_INVALID:
-            strncpy(buffer, "XR_ERROR_SWAPCHAIN_RECT_INVALID", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        case XR_ERROR_SWAPCHAIN_FORMAT_UNSUPPORTED:
-            strncpy(buffer, "XR_ERROR_SWAPCHAIN_FORMAT_UNSUPPORTED", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        case XR_ERROR_ACTION_TYPE_MISMATCH:
-            strncpy(buffer, "XR_ERROR_ACTION_TYPE_MISMATCH", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        case XR_ERROR_SESSION_NOT_READY:
-            strncpy(buffer, "XR_ERROR_SESSION_NOT_READY", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        case XR_ERROR_SESSION_NOT_STOPPING:
-            strncpy(buffer, "XR_ERROR_SESSION_NOT_STOPPING", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        case XR_ERROR_TIME_INVALID:
-            strncpy(buffer, "XR_ERROR_TIME_INVALID", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        case XR_ERROR_REFERENCE_SPACE_UNSUPPORTED:
-            strncpy(buffer, "XR_ERROR_REFERENCE_SPACE_UNSUPPORTED", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        case XR_ERROR_FILE_ACCESS_ERROR:
-            strncpy(buffer, "XR_ERROR_FILE_ACCESS_ERROR", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        case XR_ERROR_FILE_CONTENTS_INVALID:
-            strncpy(buffer, "XR_ERROR_FILE_CONTENTS_INVALID", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        case XR_ERROR_FORM_FACTOR_UNSUPPORTED:
-            strncpy(buffer, "XR_ERROR_FORM_FACTOR_UNSUPPORTED", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        case XR_ERROR_FORM_FACTOR_UNAVAILABLE:
-            strncpy(buffer, "XR_ERROR_FORM_FACTOR_UNAVAILABLE", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        case XR_ERROR_API_LAYER_NOT_PRESENT:
-            strncpy(buffer, "XR_ERROR_API_LAYER_NOT_PRESENT", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        case XR_ERROR_CALL_ORDER_INVALID:
-            strncpy(buffer, "XR_ERROR_CALL_ORDER_INVALID", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        case XR_ERROR_GRAPHICS_DEVICE_INVALID:
-            strncpy(buffer, "XR_ERROR_GRAPHICS_DEVICE_INVALID", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        case XR_ERROR_POSE_INVALID:
-            strncpy(buffer, "XR_ERROR_POSE_INVALID", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        case XR_ERROR_INDEX_OUT_OF_RANGE:
-            strncpy(buffer, "XR_ERROR_INDEX_OUT_OF_RANGE", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        case XR_ERROR_VIEW_CONFIGURATION_TYPE_UNSUPPORTED:
-            strncpy(buffer, "XR_ERROR_VIEW_CONFIGURATION_TYPE_UNSUPPORTED", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        case XR_ERROR_ENVIRONMENT_BLEND_MODE_UNSUPPORTED:
-            strncpy(buffer, "XR_ERROR_ENVIRONMENT_BLEND_MODE_UNSUPPORTED", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        case XR_ERROR_NAME_DUPLICATED:
-            strncpy(buffer, "XR_ERROR_NAME_DUPLICATED", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        case XR_ERROR_NAME_INVALID:
-            strncpy(buffer, "XR_ERROR_NAME_INVALID", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        case XR_ERROR_ACTIONSET_NOT_ATTACHED:
-            strncpy(buffer, "XR_ERROR_ACTIONSET_NOT_ATTACHED", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        case XR_ERROR_ACTIONSETS_ALREADY_ATTACHED:
-            strncpy(buffer, "XR_ERROR_ACTIONSETS_ALREADY_ATTACHED", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        case XR_ERROR_LOCALIZED_NAME_DUPLICATED:
-            strncpy(buffer, "XR_ERROR_LOCALIZED_NAME_DUPLICATED", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        case XR_ERROR_LOCALIZED_NAME_INVALID:
-            strncpy(buffer, "XR_ERROR_LOCALIZED_NAME_INVALID", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        case XR_ERROR_ANDROID_THREAD_SETTINGS_ID_INVALID_KHR:
-            strncpy(buffer, "XR_ERROR_ANDROID_THREAD_SETTINGS_ID_INVALID_KHR", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        case XR_ERROR_ANDROID_THREAD_SETTINGS_FAILURE_KHR:
-            strncpy(buffer, "XR_ERROR_ANDROID_THREAD_SETTINGS_FAILURE_KHR", XR_MAX_RESULT_STRING_SIZE);
-            break;
-        default:
-            // Unknown result type
-            if (XR_SUCCEEDED(result)) {
-                snprintf(buffer, XR_MAX_RESULT_STRING_SIZE, "XR_UNKNOWN_SUCCESS_%d", result);
-            } else {
-                snprintf(buffer, XR_MAX_RESULT_STRING_SIZE, "XR_UNKNOWN_FAILURE_%d", result);
-            }
-            int_result = XR_ERROR_VALIDATION_FAILURE;
-            break;
-    }
-    return int_result;
-}
-
-XrResult GeneratedXrUtilitiesStructureTypeToString(XrStructureType struct_type,
-                                            char buffer[XR_MAX_STRUCTURE_NAME_SIZE]) {
-    if (NULL == buffer) {
-        return XR_ERROR_VALIDATION_FAILURE;
-    }
-    XrResult int_result = XR_SUCCESS;
-    switch (struct_type) {
-        case XR_TYPE_UNKNOWN:
-            strncpy(buffer, "XR_TYPE_UNKNOWN", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_API_LAYER_PROPERTIES:
-            strncpy(buffer, "XR_TYPE_API_LAYER_PROPERTIES", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_EXTENSION_PROPERTIES:
-            strncpy(buffer, "XR_TYPE_EXTENSION_PROPERTIES", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_INSTANCE_CREATE_INFO:
-            strncpy(buffer, "XR_TYPE_INSTANCE_CREATE_INFO", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_SYSTEM_GET_INFO:
-            strncpy(buffer, "XR_TYPE_SYSTEM_GET_INFO", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_SYSTEM_PROPERTIES:
-            strncpy(buffer, "XR_TYPE_SYSTEM_PROPERTIES", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_VIEW_LOCATE_INFO:
-            strncpy(buffer, "XR_TYPE_VIEW_LOCATE_INFO", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_VIEW:
-            strncpy(buffer, "XR_TYPE_VIEW", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_SESSION_CREATE_INFO:
-            strncpy(buffer, "XR_TYPE_SESSION_CREATE_INFO", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_SWAPCHAIN_CREATE_INFO:
-            strncpy(buffer, "XR_TYPE_SWAPCHAIN_CREATE_INFO", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_SESSION_BEGIN_INFO:
-            strncpy(buffer, "XR_TYPE_SESSION_BEGIN_INFO", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_VIEW_STATE:
-            strncpy(buffer, "XR_TYPE_VIEW_STATE", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_FRAME_END_INFO:
-            strncpy(buffer, "XR_TYPE_FRAME_END_INFO", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_HAPTIC_VIBRATION:
-            strncpy(buffer, "XR_TYPE_HAPTIC_VIBRATION", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_EVENT_DATA_BUFFER:
-            strncpy(buffer, "XR_TYPE_EVENT_DATA_BUFFER", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_EVENT_DATA_INSTANCE_LOSS_PENDING:
-            strncpy(buffer, "XR_TYPE_EVENT_DATA_INSTANCE_LOSS_PENDING", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_EVENT_DATA_SESSION_STATE_CHANGED:
-            strncpy(buffer, "XR_TYPE_EVENT_DATA_SESSION_STATE_CHANGED", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_ACTION_STATE_BOOLEAN:
-            strncpy(buffer, "XR_TYPE_ACTION_STATE_BOOLEAN", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_ACTION_STATE_FLOAT:
-            strncpy(buffer, "XR_TYPE_ACTION_STATE_FLOAT", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_ACTION_STATE_VECTOR2F:
-            strncpy(buffer, "XR_TYPE_ACTION_STATE_VECTOR2F", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_ACTION_STATE_POSE:
-            strncpy(buffer, "XR_TYPE_ACTION_STATE_POSE", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_ACTION_SET_CREATE_INFO:
-            strncpy(buffer, "XR_TYPE_ACTION_SET_CREATE_INFO", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_ACTION_CREATE_INFO:
-            strncpy(buffer, "XR_TYPE_ACTION_CREATE_INFO", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_INSTANCE_PROPERTIES:
-            strncpy(buffer, "XR_TYPE_INSTANCE_PROPERTIES", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_FRAME_WAIT_INFO:
-            strncpy(buffer, "XR_TYPE_FRAME_WAIT_INFO", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_COMPOSITION_LAYER_PROJECTION:
-            strncpy(buffer, "XR_TYPE_COMPOSITION_LAYER_PROJECTION", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_COMPOSITION_LAYER_QUAD:
-            strncpy(buffer, "XR_TYPE_COMPOSITION_LAYER_QUAD", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_REFERENCE_SPACE_CREATE_INFO:
-            strncpy(buffer, "XR_TYPE_REFERENCE_SPACE_CREATE_INFO", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_ACTION_SPACE_CREATE_INFO:
-            strncpy(buffer, "XR_TYPE_ACTION_SPACE_CREATE_INFO", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_EVENT_DATA_REFERENCE_SPACE_CHANGE_PENDING:
-            strncpy(buffer, "XR_TYPE_EVENT_DATA_REFERENCE_SPACE_CHANGE_PENDING", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_VIEW_CONFIGURATION_VIEW:
-            strncpy(buffer, "XR_TYPE_VIEW_CONFIGURATION_VIEW", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_SPACE_LOCATION:
-            strncpy(buffer, "XR_TYPE_SPACE_LOCATION", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_SPACE_VELOCITY:
-            strncpy(buffer, "XR_TYPE_SPACE_VELOCITY", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_FRAME_STATE:
-            strncpy(buffer, "XR_TYPE_FRAME_STATE", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_VIEW_CONFIGURATION_PROPERTIES:
-            strncpy(buffer, "XR_TYPE_VIEW_CONFIGURATION_PROPERTIES", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_FRAME_BEGIN_INFO:
-            strncpy(buffer, "XR_TYPE_FRAME_BEGIN_INFO", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_COMPOSITION_LAYER_PROJECTION_VIEW:
-            strncpy(buffer, "XR_TYPE_COMPOSITION_LAYER_PROJECTION_VIEW", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_EVENT_DATA_EVENTS_LOST:
-            strncpy(buffer, "XR_TYPE_EVENT_DATA_EVENTS_LOST", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_INTERACTION_PROFILE_SUGGESTED_BINDING:
-            strncpy(buffer, "XR_TYPE_INTERACTION_PROFILE_SUGGESTED_BINDING", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_EVENT_DATA_INTERACTION_PROFILE_CHANGED:
-            strncpy(buffer, "XR_TYPE_EVENT_DATA_INTERACTION_PROFILE_CHANGED", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_INTERACTION_PROFILE_STATE:
-            strncpy(buffer, "XR_TYPE_INTERACTION_PROFILE_STATE", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_SWAPCHAIN_IMAGE_ACQUIRE_INFO:
-            strncpy(buffer, "XR_TYPE_SWAPCHAIN_IMAGE_ACQUIRE_INFO", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_SWAPCHAIN_IMAGE_WAIT_INFO:
-            strncpy(buffer, "XR_TYPE_SWAPCHAIN_IMAGE_WAIT_INFO", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_SWAPCHAIN_IMAGE_RELEASE_INFO:
-            strncpy(buffer, "XR_TYPE_SWAPCHAIN_IMAGE_RELEASE_INFO", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_ACTION_STATE_GET_INFO:
-            strncpy(buffer, "XR_TYPE_ACTION_STATE_GET_INFO", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_HAPTIC_ACTION_INFO:
-            strncpy(buffer, "XR_TYPE_HAPTIC_ACTION_INFO", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_SESSION_ACTION_SETS_ATTACH_INFO:
-            strncpy(buffer, "XR_TYPE_SESSION_ACTION_SETS_ATTACH_INFO", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_ACTIONS_SYNC_INFO:
-            strncpy(buffer, "XR_TYPE_ACTIONS_SYNC_INFO", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_BOUND_SOURCES_FOR_ACTION_ENUMERATE_INFO:
-            strncpy(buffer, "XR_TYPE_BOUND_SOURCES_FOR_ACTION_ENUMERATE_INFO", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_INPUT_SOURCE_LOCALIZED_NAME_GET_INFO:
-            strncpy(buffer, "XR_TYPE_INPUT_SOURCE_LOCALIZED_NAME_GET_INFO", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_COMPOSITION_LAYER_CUBE_KHR:
-            strncpy(buffer, "XR_TYPE_COMPOSITION_LAYER_CUBE_KHR", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_INSTANCE_CREATE_INFO_ANDROID_KHR:
-            strncpy(buffer, "XR_TYPE_INSTANCE_CREATE_INFO_ANDROID_KHR", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_COMPOSITION_LAYER_DEPTH_INFO_KHR:
-            strncpy(buffer, "XR_TYPE_COMPOSITION_LAYER_DEPTH_INFO_KHR", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_VULKAN_SWAPCHAIN_FORMAT_LIST_CREATE_INFO_KHR:
-            strncpy(buffer, "XR_TYPE_VULKAN_SWAPCHAIN_FORMAT_LIST_CREATE_INFO_KHR", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_EVENT_DATA_PERF_SETTINGS_EXT:
-            strncpy(buffer, "XR_TYPE_EVENT_DATA_PERF_SETTINGS_EXT", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_COMPOSITION_LAYER_CYLINDER_KHR:
-            strncpy(buffer, "XR_TYPE_COMPOSITION_LAYER_CYLINDER_KHR", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_COMPOSITION_LAYER_EQUIRECT_KHR:
-            strncpy(buffer, "XR_TYPE_COMPOSITION_LAYER_EQUIRECT_KHR", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT:
-            strncpy(buffer, "XR_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT:
-            strncpy(buffer, "XR_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
-            strncpy(buffer, "XR_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_DEBUG_UTILS_LABEL_EXT:
-            strncpy(buffer, "XR_TYPE_DEBUG_UTILS_LABEL_EXT", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_GRAPHICS_BINDING_OPENGL_WIN32_KHR:
-            strncpy(buffer, "XR_TYPE_GRAPHICS_BINDING_OPENGL_WIN32_KHR", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_GRAPHICS_BINDING_OPENGL_XLIB_KHR:
-            strncpy(buffer, "XR_TYPE_GRAPHICS_BINDING_OPENGL_XLIB_KHR", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_GRAPHICS_BINDING_OPENGL_XCB_KHR:
-            strncpy(buffer, "XR_TYPE_GRAPHICS_BINDING_OPENGL_XCB_KHR", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_GRAPHICS_BINDING_OPENGL_WAYLAND_KHR:
-            strncpy(buffer, "XR_TYPE_GRAPHICS_BINDING_OPENGL_WAYLAND_KHR", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_SWAPCHAIN_IMAGE_OPENGL_KHR:
-            strncpy(buffer, "XR_TYPE_SWAPCHAIN_IMAGE_OPENGL_KHR", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_GRAPHICS_REQUIREMENTS_OPENGL_KHR:
-            strncpy(buffer, "XR_TYPE_GRAPHICS_REQUIREMENTS_OPENGL_KHR", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_GRAPHICS_BINDING_OPENGL_ES_ANDROID_KHR:
-            strncpy(buffer, "XR_TYPE_GRAPHICS_BINDING_OPENGL_ES_ANDROID_KHR", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_SWAPCHAIN_IMAGE_OPENGL_ES_KHR:
-            strncpy(buffer, "XR_TYPE_SWAPCHAIN_IMAGE_OPENGL_ES_KHR", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_GRAPHICS_REQUIREMENTS_OPENGL_ES_KHR:
-            strncpy(buffer, "XR_TYPE_GRAPHICS_REQUIREMENTS_OPENGL_ES_KHR", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_GRAPHICS_BINDING_VULKAN_KHR:
-            strncpy(buffer, "XR_TYPE_GRAPHICS_BINDING_VULKAN_KHR", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_SWAPCHAIN_IMAGE_VULKAN_KHR:
-            strncpy(buffer, "XR_TYPE_SWAPCHAIN_IMAGE_VULKAN_KHR", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_GRAPHICS_REQUIREMENTS_VULKAN_KHR:
-            strncpy(buffer, "XR_TYPE_GRAPHICS_REQUIREMENTS_VULKAN_KHR", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_GRAPHICS_BINDING_D3D11_KHR:
-            strncpy(buffer, "XR_TYPE_GRAPHICS_BINDING_D3D11_KHR", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_SWAPCHAIN_IMAGE_D3D11_KHR:
-            strncpy(buffer, "XR_TYPE_SWAPCHAIN_IMAGE_D3D11_KHR", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_GRAPHICS_REQUIREMENTS_D3D11_KHR:
-            strncpy(buffer, "XR_TYPE_GRAPHICS_REQUIREMENTS_D3D11_KHR", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_GRAPHICS_BINDING_D3D12_KHR:
-            strncpy(buffer, "XR_TYPE_GRAPHICS_BINDING_D3D12_KHR", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_SWAPCHAIN_IMAGE_D3D12_KHR:
-            strncpy(buffer, "XR_TYPE_SWAPCHAIN_IMAGE_D3D12_KHR", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_GRAPHICS_REQUIREMENTS_D3D12_KHR:
-            strncpy(buffer, "XR_TYPE_GRAPHICS_REQUIREMENTS_D3D12_KHR", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_VISIBILITY_MASK_KHR:
-            strncpy(buffer, "XR_TYPE_VISIBILITY_MASK_KHR", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        case XR_TYPE_EVENT_DATA_VISIBILITY_MASK_CHANGED_KHR:
-            strncpy(buffer, "XR_TYPE_EVENT_DATA_VISIBILITY_MASK_CHANGED_KHR", XR_MAX_STRUCTURE_NAME_SIZE);
-            break;
-        default:
-            // Unknown structure type
-            snprintf(buffer, XR_MAX_STRUCTURE_NAME_SIZE, "XR_UNKNOWN_STRUCTURE_TYPE_%d", struct_type);
-            int_result = XR_ERROR_VALIDATION_FAILURE;
-            break;
-    }
-    return int_result;
-}
-
-#ifdef __cplusplus
-} // extern "C"
-#endif
-
diff --git a/src/xr_generated_utilities.h b/src/xr_generated_utilities.h
deleted file mode 100644
index 11ae94f..0000000
--- a/src/xr_generated_utilities.h
+++ /dev/null
@@ -1,43 +0,0 @@
-// *********** THIS FILE IS GENERATED - DO NOT EDIT ***********
-//     See utility_source_generator.py for modifications
-// ************************************************************
-
-// Copyright (c) 2017-2019 The Khronos Group Inc.
-// Copyright (c) 2017-2019 Valve Corporation
-// Copyright (c) 2017-2019 LunarG, Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// Author: Mark Young <marky@lunarg.com>
-//
-
-#pragma once
-
-#include <openxr/openxr.h>
-
-
-#ifdef __cplusplus
-extern "C" { 
-#endif
-
-XrResult GeneratedXrUtilitiesResultToString(XrResult result,
-                                            char buffer[XR_MAX_RESULT_STRING_SIZE]);
-XrResult GeneratedXrUtilitiesStructureTypeToString(XrStructureType struct_type,
-                                                   char buffer[XR_MAX_STRUCTURE_NAME_SIZE]);
-#ifdef __cplusplus
-} // extern "C"
-#endif
-
-// Current API version of the utililties
-#define XR_UTILITIES_API_VERSION XR_CURRENT_API_VERSION
-