diff --git a/VulkanHppGenerator.cpp b/VulkanHppGenerator.cpp
index 0ce3b5f..055d9d6 100644
--- a/VulkanHppGenerator.cpp
+++ b/VulkanHppGenerator.cpp
@@ -15124,6 +15124,32 @@ int main( int argc, char ** argv )
       , m_ptr( data.data() )
     {}
 
+#if defined( VULKAN_HPP_SUPPORT_SPAN )
+    template <size_t N = std::dynamic_extent>
+    ArrayProxy( std::span<T, N> const & data ) VULKAN_HPP_NOEXCEPT
+      : m_count( static_cast<uint32_t>( data.size() ) )
+      , m_ptr( data.data() )
+    {}
+
+    template <size_t N = std::dynamic_extent, typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
+    ArrayProxy( std::span<typename std::remove_const<T>::type, N> const & data ) VULKAN_HPP_NOEXCEPT
+      : m_count( static_cast<uint32_t>( data.size() ) )
+      , m_ptr( data.data() )
+    {}
+
+    template <size_t N = std::dynamic_extent>
+    ArrayProxy( std::span<T, N> & data ) VULKAN_HPP_NOEXCEPT
+      : m_count( static_cast<uint32_t>( data.size() ) )
+      , m_ptr( data.data() )
+    {}
+
+    template <size_t N = std::dynamic_extent, typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
+    ArrayProxy( std::span<typename std::remove_const<T>::type, N> & data ) VULKAN_HPP_NOEXCEPT
+      : m_count( static_cast<uint32_t>( data.size() ) )
+      , m_ptr( data.data() )
+    {}
+#endif
+
     const T * begin() const VULKAN_HPP_NOEXCEPT
     {
       return m_ptr;
@@ -15321,6 +15347,32 @@ int main( int argc, char ** argv )
               typename std::enable_if<std::is_const<B>::value, int>::type = 0>
     ArrayProxyNoTemporaries( std::vector<typename std::remove_const<T>::type, Allocator> && data ) = delete;
 
+#if defined( VULKAN_HPP_SUPPORT_SPAN )
+    template <size_t N = std::dynamic_extent>
+    ArrayProxyNoTemporaries( std::span<T, N> const & data ) VULKAN_HPP_NOEXCEPT
+      : m_count( static_cast<uint32_t>( data.size() ) )
+      , m_ptr( data.data() )
+    {}
+
+    template <size_t N = std::dynamic_extent, typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
+    ArrayProxyNoTemporaries( std::span<typename std::remove_const<T>::type, N> const & data ) VULKAN_HPP_NOEXCEPT
+      : m_count( static_cast<uint32_t>( data.size() ) )
+      , m_ptr( data.data() )
+    {}
+
+    template <size_t N = std::dynamic_extent>
+    ArrayProxyNoTemporaries( std::span<T, N> & data ) VULKAN_HPP_NOEXCEPT
+      : m_count( static_cast<uint32_t>( data.size() ) )
+      , m_ptr( data.data() )
+    {}
+
+    template <size_t N = std::dynamic_extent, typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
+    ArrayProxyNoTemporaries( std::span<typename std::remove_const<T>::type, N> & data ) VULKAN_HPP_NOEXCEPT
+      : m_count( static_cast<uint32_t>( data.size() ) )
+      , m_ptr( data.data() )
+    {}
+#endif
+
     const T * begin() const VULKAN_HPP_NOEXCEPT
     {
       return m_ptr;
@@ -16670,7 +16722,6 @@ int main( int argc, char ** argv )
 #include <tuple>
 #include <type_traits>
 #include <vulkan/vulkan.h>
-
 #if 17 <= VULKAN_HPP_CPP_VERSION
 #  include <string_view>
 #endif
@@ -16742,6 +16793,11 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
 #  include <compare>
 #endif
 
+#if ( 201803 <= __cpp_lib_span )
+#  define VULKAN_HPP_SUPPORT_SPAN
+#  include <span>
+#endif
+
 )";
 
   static const std::string structResultValue = R"(
diff --git a/tests/ArrayProxy/ArrayProxy.cpp b/tests/ArrayProxy/ArrayProxy.cpp
index 6302bfa..bcedaea 100644
--- a/tests/ArrayProxy/ArrayProxy.cpp
+++ b/tests/ArrayProxy/ArrayProxy.cpp
@@ -16,153 +16,175 @@
 //                     Compile test on using vk::ArrayProxy
 
 #include "vulkan/vulkan.hpp"
+
 #include <iostream>
+#if ( 20 <= VULKAN_HPP_CPP_VERSION )
+#  include <span>
+#endif
 
-void fct(vk::ArrayProxy<int> /*ap*/)
-{}
+void fct( vk::ArrayProxy<int> /*ap*/ ) {}
 
-void fctc(vk::ArrayProxy<const int> /*ap*/)
-{}
+void fctc( vk::ArrayProxy<const int> /*ap*/ ) {}
 
-int main(int /*argc*/, char ** /*argv*/)
+int main( int /*argc*/, char ** /*argv*/ )
 {
   try
   {
     // nullptr_t
-    fct(nullptr);
-    fctc(nullptr);
+    fct( nullptr );
+    fctc( nullptr );
 
     vk::ArrayProxy<int> ap0 = nullptr;
-    assert(ap0.size() == 0);
+    assert( ap0.size() == 0 );
 
     // Type
-    //fct(2);  // not supported: cannot convert from 'const int *' to 'T *'
-    fctc(1);
+    // fct(2);  // not supported: cannot convert from 'const int *' to 'T *'
+    fctc( 1 );
 
     int i0 = 1;
-    fct(i0);
-    fctc(i0);
+    fct( i0 );
+    fctc( i0 );
 
     const int i1 = 2;
-    //fct(i1);   // not supported: cannot convert from 'const int *' to 'T *'
-    fctc(i1);
+    // fct(i1);   // not supported: cannot convert from 'const int *' to 'T *'
+    fctc( i1 );
 
     // count, T *
-    int* i0p = &i0;
-    fct({ 1, i0p });
-    fctc({ 1, i0p });
+    int * i0p = &i0;
+    fct( { 1, i0p } );
+    fctc( { 1, i0p } );
 
     // count, T const*
-    int const* i1p = &i1;
-    //fct({ 1, i1p });   // not supported: cannot convert from 'const int *' to 'T *'
-    fctc({ 1, i1p });
+    int const * i1p = &i1;
+    // fct({ 1, i1p });   // not supported: cannot convert from 'const int *' to 'T *'
+    fctc( { 1, i1p } );
 
     // std::array<T,N>
     std::array<int, 2> sa0 = { 0, 1 };
-    fct(sa0);
-    fctc(sa0);
+    fct( sa0 );
+    fctc( sa0 );
 
     // std::array<T,N> const
     std::array<const int, 2> sa1 = { 0, 1 };
-    //fct(sa1); // not supported: cannot convert from '_Ty *' to 'T *'
-    fctc(sa1);
+    // fct(sa1); // not supported: cannot convert from '_Ty *' to 'T *'
+    fctc( sa1 );
 
     std::array<int, 2> const sa2 = { 1, 2 };
-    //fct(sa2);    // not supported: cannot convert from 'const _Ty *' to 'T *'
-    fctc(sa2);
+    // fct(sa2);    // not supported: cannot convert from 'const _Ty *' to 'T *'
+    fctc( sa2 );
 
     std::array<const int, 2> const sa3 = { 1, 2 };
-    //fct(sa3); // not supported: cannot convert from '_Ty *' to 'T *'
-    fctc(sa3);
+    // fct(sa3); // not supported: cannot convert from '_Ty *' to 'T *'
+    fctc( sa3 );
 
     vk::ArrayProxy<int> ap2 = sa0;
-    assert(ap2.size() == 2);
-    //vk::ArrayProxy<int> ap3 = sa1;  // not supported: cannot convert from '_Ty *' to 'T *'
-    //vk::ArrayProxy<int> ap4 = sa2;  // not supported: cannot convert from '_Ty *' to 'T *'
-    //vk::ArrayProxy<int> ap5 = sa3;  // not supported: cannot convert from '_Ty *' to 'T *'
+    assert( ap2.size() == 2 );
+    // vk::ArrayProxy<int> ap3 = sa1;  // not supported: cannot convert from '_Ty *' to 'T *'
+    // vk::ArrayProxy<int> ap4 = sa2;  // not supported: cannot convert from '_Ty *' to 'T *'
+    // vk::ArrayProxy<int> ap5 = sa3;  // not supported: cannot convert from '_Ty *' to 'T *'
 
     vk::ArrayProxy<const int> ap6 = sa0;
-    assert(ap6.size() == 2);
+    assert( ap6.size() == 2 );
     vk::ArrayProxy<const int> ap7 = sa1;
-    assert(ap7.size() == 2);
+    assert( ap7.size() == 2 );
     vk::ArrayProxy<const int> ap8 = sa2;
-    assert(ap8.size() == 2);
+    assert( ap8.size() == 2 );
     vk::ArrayProxy<const int> ap9 = sa3;
-    assert(ap9.size() == 2);
+    assert( ap9.size() == 2 );
 
     // std::vector<T>
     std::vector<int> sv0 = { 0, 1 };
-    fct(sv0);
-    fctc(sv0);
+    fct( sv0 );
+    fctc( sv0 );
 
     std::vector<int> const sv1 = { 0, 1 };
-    //fct(sv1); // not supported:  cannot convert from 'const _Ty *' to 'T *'
-    fctc(sv1);
+    // fct(sv1); // not supported:  cannot convert from 'const _Ty *' to 'T *'
+    fctc( sv1 );
 
     vk::ArrayProxy<int> ap10 = sv0;
-    assert(ap10.size() == 2);
-    //vk::ArrayProxy<int> ap11 = sv1;  // not supported: cannot convert from '_Ty *' to 'T *'
+    assert( ap10.size() == 2 );
+    // vk::ArrayProxy<int> ap11 = sv1;  // not supported: cannot convert from '_Ty *' to 'T *'
 
     vk::ArrayProxy<const int> ap12 = sv0;
-    assert(ap12.size() == 2);
+    assert( ap12.size() == 2 );
     vk::ArrayProxy<const int> ap13 = sv1;
-    assert(ap13.size() == 2);
+    assert( ap13.size() == 2 );
 
     // std::initializer_list
-    fct({});
-    fctc({});
+    fct( {} );
+    fctc( {} );
 
-    //fct({ 0, 1 });   // not supported: cannot convert from 'const _Elem *' to 'T *'
-    fctc({ 0, 1 });
+    // fct({ 0, 1 });   // not supported: cannot convert from 'const _Elem *' to 'T *'
+    fctc( { 0, 1 } );
 
     int a = 0;
     int b = 1;
-    //fct({ a, b });  // not supported: cannot convert from 'const _Elem *' to 'T *'
-    fctc({ a,b });
+    // fct({ a, b });  // not supported: cannot convert from 'const _Elem *' to 'T *'
+    fctc( { a, b } );
 
-    auto il0 = { 0, 1 };   // -> std::initializer_list<int>
-    //fct(il0);  // not supported: cannot convert from 'const _Elem *' to 'T *'
-    fctc(il0);
+    auto il0 = { 0, 1 };  // -> std::initializer_list<int>
+    // fct(il0);  // not supported: cannot convert from 'const _Elem *' to 'T *'
+    fctc( il0 );
 
     std::initializer_list<int> il1 = { 0, 1 };
-    //fct(il1);  // not supported: cannot convert from 'const _Elem *' to 'T *'
-    fctc(il1);
+    // fct(il1);  // not supported: cannot convert from 'const _Elem *' to 'T *'
+    fctc( il1 );
 
     std::initializer_list<const int> il2 = { 0, 1 };
-    //fct(il2);  // not supported: cannot convert from '_Elem *' to 'T *'
-    fctc(il2);
+    // fct(il2);  // not supported: cannot convert from '_Elem *' to 'T *'
+    fctc( il2 );
 
     std::initializer_list<int> const il3 = { 0, 1 };
-    //fct(il3);  // not supported: cannot convert from 'const _Elem *' to 'T *'
-    fctc(il3);
+    // fct(il3);  // not supported: cannot convert from 'const _Elem *' to 'T *'
+    fctc( il3 );
 
     std::initializer_list<const int> const il4 = { 0, 1 };
-    //fct(il4);  // not supported: cannot convert from 'const _Elem *' to 'T *'
-    fctc(il4);
+    // fct(il4);  // not supported: cannot convert from 'const _Elem *' to 'T *'
+    fctc( il4 );
 
-    //vk::ArrayProxy<int> ap14 = il1;   // not supported: cannot convert from 'const _Elem *' to 'T *'
-    //vk::ArrayProxy<int> ap15 = il2;   // not supported: cannot convert from '_Ty *' to 'T *'
-    //vk::ArrayProxy<int> ap16 = il3;   // not supported: cannot convert from '_Ty *' to 'T *'
-    //vk::ArrayProxy<int> ap17 = il4;   // not supported: cannot convert from '_Ty *' to 'T *'
+    // vk::ArrayProxy<int> ap14 = il1;   // not supported: cannot convert from 'const _Elem *' to 'T *'
+    // vk::ArrayProxy<int> ap15 = il2;   // not supported: cannot convert from '_Ty *' to 'T *'
+    // vk::ArrayProxy<int> ap16 = il3;   // not supported: cannot convert from '_Ty *' to 'T *'
+    // vk::ArrayProxy<int> ap17 = il4;   // not supported: cannot convert from '_Ty *' to 'T *'
 
     vk::ArrayProxy<const int> ap18 = il1;
-    assert(ap18.size() == 2);
+    assert( ap18.size() == 2 );
     vk::ArrayProxy<const int> ap19 = il2;
-    assert(ap19.size() == 2);
+    assert( ap19.size() == 2 );
     vk::ArrayProxy<const int> ap20 = il3;
-    assert(ap20.size() == 2);
+    assert( ap20.size() == 2 );
     vk::ArrayProxy<const int> ap21 = il4;
-    assert(ap21.size() == 2);
+    assert( ap21.size() == 2 );
+
+#if defined( VULKAN_HPP_SUPPORT_SPAN )
+    // std::span<T, N>
+    std::span<int> ss0( sa0.begin(), sa0.size() );
+    fct( ss0 );
+    fctc( ss0 );
+
+    // std::span<T,N> const
+    std::span<const int> ss1( sa1.begin(), sa1.size() );
+    // fct(ss1); // not supported: cannot convert from 'std::span<const int>' to 'vk::ArrayProxy<int>'
+    fctc( ss1 );
+
+    std::span<int> const ss2;
+    fct( ss2 );
+    fctc( ss2 );
+
+    std::span<const int> const ss3( sa3.begin(), sa3.end() );
+    // fct(ss3); // not supported: cannot convert from 'const std::span<const int>' to 'vk::ArrayProxy<int>'
+    fctc( ss3 );
+#endif
   }
-  catch (vk::SystemError const& err)
+  catch ( vk::SystemError const & err )
   {
     std::cout << "vk::SystemError: " << err.what() << std::endl;
-    exit(-1);
+    exit( -1 );
   }
-  catch (...)
+  catch ( ... )
   {
     std::cout << "unknown error\n";
-    exit(-1);
+    exit( -1 );
   }
 
   return 0;
diff --git a/vulkan/vulkan.hpp b/vulkan/vulkan.hpp
index a93ebe4..d18c020 100644
--- a/vulkan/vulkan.hpp
+++ b/vulkan/vulkan.hpp
@@ -39,7 +39,6 @@
 #include <tuple>
 #include <type_traits>
 #include <vulkan/vulkan.h>
-
 #if 17 <= VULKAN_HPP_CPP_VERSION
 #  include <string_view>
 #endif
@@ -111,6 +110,11 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
 #  include <compare>
 #endif
 
+#if ( 201803 <= __cpp_lib_span )
+#  define VULKAN_HPP_SUPPORT_SPAN
+#  include <span>
+#endif
+
 static_assert( VK_HEADER_VERSION == 187, "Wrong VK_HEADER_VERSION!" );
 
 // 32-bit vulkan is not typesafe for handles, so don't allow copy constructors on this platform by default.
@@ -352,6 +356,36 @@ namespace VULKAN_HPP_NAMESPACE
       , m_ptr( data.data() )
     {}
 
+#  if defined( VULKAN_HPP_SUPPORT_SPAN )
+    template <size_t N = std::dynamic_extent>
+    ArrayProxy( std::span<T, N> const & data ) VULKAN_HPP_NOEXCEPT
+      : m_count( static_cast<uint32_t>( data.size() ) )
+      , m_ptr( data.data() )
+    {}
+
+    template <size_t N                                                    = std::dynamic_extent,
+              typename B                                                  = T,
+              typename std::enable_if<std::is_const<B>::value, int>::type = 0>
+    ArrayProxy( std::span<typename std::remove_const<T>::type, N> const & data ) VULKAN_HPP_NOEXCEPT
+      : m_count( static_cast<uint32_t>( data.size() ) )
+      , m_ptr( data.data() )
+    {}
+
+    template <size_t N = std::dynamic_extent>
+    ArrayProxy( std::span<T, N> & data ) VULKAN_HPP_NOEXCEPT
+      : m_count( static_cast<uint32_t>( data.size() ) )
+      , m_ptr( data.data() )
+    {}
+
+    template <size_t N                                                    = std::dynamic_extent,
+              typename B                                                  = T,
+              typename std::enable_if<std::is_const<B>::value, int>::type = 0>
+    ArrayProxy( std::span<typename std::remove_const<T>::type, N> & data ) VULKAN_HPP_NOEXCEPT
+      : m_count( static_cast<uint32_t>( data.size() ) )
+      , m_ptr( data.data() )
+    {}
+#  endif
+
     const T * begin() const VULKAN_HPP_NOEXCEPT
     {
       return m_ptr;
@@ -549,6 +583,36 @@ namespace VULKAN_HPP_NAMESPACE
               typename std::enable_if<std::is_const<B>::value, int>::type = 0>
     ArrayProxyNoTemporaries( std::vector<typename std::remove_const<T>::type, Allocator> && data ) = delete;
 
+#  if defined( VULKAN_HPP_SUPPORT_SPAN )
+    template <size_t N = std::dynamic_extent>
+    ArrayProxyNoTemporaries( std::span<T, N> const & data ) VULKAN_HPP_NOEXCEPT
+      : m_count( static_cast<uint32_t>( data.size() ) )
+      , m_ptr( data.data() )
+    {}
+
+    template <size_t N                                                    = std::dynamic_extent,
+              typename B                                                  = T,
+              typename std::enable_if<std::is_const<B>::value, int>::type = 0>
+    ArrayProxyNoTemporaries( std::span<typename std::remove_const<T>::type, N> const & data ) VULKAN_HPP_NOEXCEPT
+      : m_count( static_cast<uint32_t>( data.size() ) )
+      , m_ptr( data.data() )
+    {}
+
+    template <size_t N = std::dynamic_extent>
+    ArrayProxyNoTemporaries( std::span<T, N> & data ) VULKAN_HPP_NOEXCEPT
+      : m_count( static_cast<uint32_t>( data.size() ) )
+      , m_ptr( data.data() )
+    {}
+
+    template <size_t N                                                    = std::dynamic_extent,
+              typename B                                                  = T,
+              typename std::enable_if<std::is_const<B>::value, int>::type = 0>
+    ArrayProxyNoTemporaries( std::span<typename std::remove_const<T>::type, N> & data ) VULKAN_HPP_NOEXCEPT
+      : m_count( static_cast<uint32_t>( data.size() ) )
+      , m_ptr( data.data() )
+    {}
+#  endif
+
     const T * begin() const VULKAN_HPP_NOEXCEPT
     {
       return m_ptr;