diff --git a/Docs/Whats_New.md b/Docs/Whats_New.md
index 4271434..f2b1c38 100644
--- a/Docs/Whats_New.md
+++ b/Docs/Whats_New.md
@@ -13,6 +13,28 @@
 
 
 
+MoltenVK 1.1.2
+--------------
+
+Released TBD
+
+- Add support for using Metal argument buffers for shader resources, by setting 
+  `MVK_CONFIG_USE_METAL_ARGUMENT_BUFFERS` environment variable (enabled by default).
+- To improve performance during descriptor set allocations, preallocate memory for descriptor sets, descriptors, 
+  and the Metal argument buffer (one `MTLBuffer` per descriptor pool) during `vkCreateDescriptorPool()`.
+- Add support for embedding inline uniform content directly in Metal argument buffers, by setting 
+  `MVK_CONFIG_EMBED_INLINE_BLOCKS_IN_METAL_ARGUMENT_BUFFER` environment variable (disabled by default).
+- Support fast math on MSL compiler via `MVKConfiguration::fastMathEnabled` configuration 
+  setting and `MVK_CONFIG_FAST_MATH_ENABLED` environment variable (both disabled by default).
+  - Add ability to automatically capture first GPU frame by setting `MVK_CONFIG_AUTO_GPU_CAPTURE_SCOPE` to `2`.
+  - Add `MVKBitArray` and remove `MVKVector`.
+- Support _GitHub Actions_ for CI builds on pull requests.
+- Remove support for _Travis-CI_.
+- `Makefile` and `fetchDependencies` support `xcpretty` (if available)
+- Update `VK_MVK_MOLTENVK_SPEC_VERSION` to `30`.
+
+
+
 MoltenVK 1.1.1
 --------------
 
@@ -21,7 +43,7 @@
 - Add support for extensions:
 	- `VK_KHR_sampler_mirror_clamp_to_edge` (iOS)
 	- `VK_KHR_timeline_semaphore`
-	- `VK_EXT_descriptor_indexing` (initial release limited to Metal Tier 1: 96/128 textures, 16 samplers)
+	- `VK_EXT_descriptor_indexing`
 	- `VK_EXT_post_depth_coverage` (macOS)
 	- `VK_EXT_private_data`
 	- `VK_EXT_subgroup_size_control`
diff --git a/MoltenVK/MoltenVK.xcodeproj/project.pbxproj b/MoltenVK/MoltenVK.xcodeproj/project.pbxproj
index d84c521..2cafeea 100644
--- a/MoltenVK/MoltenVK.xcodeproj/project.pbxproj
+++ b/MoltenVK/MoltenVK.xcodeproj/project.pbxproj
@@ -27,13 +27,11 @@
 		2FEA0A5224902F9F00EEF3AD /* MVKLogging.h in Headers */ = {isa = PBXBuildFile; fileRef = A9F0429E1FB4CF82009FCCB8 /* MVKLogging.h */; };
 		2FEA0A5324902F9F00EEF3AD /* MVKQueue.h in Headers */ = {isa = PBXBuildFile; fileRef = A94FB7911C7DFB4800632CA3 /* MVKQueue.h */; };
 		2FEA0A5424902F9F00EEF3AD /* MVKFramebuffer.h in Headers */ = {isa = PBXBuildFile; fileRef = A94FB7871C7DFB4800632CA3 /* MVKFramebuffer.h */; };
-		2FEA0A5524902F9F00EEF3AD /* MVKVectorAllocator.h in Headers */ = {isa = PBXBuildFile; fileRef = 83A4AD2921BD75570006C935 /* MVKVectorAllocator.h */; };
 		2FEA0A5624902F9F00EEF3AD /* MVKWatermarkShaderSource.h in Headers */ = {isa = PBXBuildFile; fileRef = A981494B1FB6A3F7005F00B4 /* MVKWatermarkShaderSource.h */; };
 		2FEA0A5724902F9F00EEF3AD /* MTLSamplerDescriptor+MoltenVK.h in Headers */ = {isa = PBXBuildFile; fileRef = A9E53DD32100B197002781DD /* MTLSamplerDescriptor+MoltenVK.h */; };
 		2FEA0A5824902F9F00EEF3AD /* MVKSync.h in Headers */ = {isa = PBXBuildFile; fileRef = A94FB79D1C7DFB4800632CA3 /* MVKSync.h */; };
 		2FEA0A5924902F9F00EEF3AD /* MVKDevice.h in Headers */ = {isa = PBXBuildFile; fileRef = A94FB7831C7DFB4800632CA3 /* MVKDevice.h */; };
 		2FEA0A5A24902F9F00EEF3AD /* MVKSmallVector.h in Headers */ = {isa = PBXBuildFile; fileRef = A9F3D9DB24732A4D00745190 /* MVKSmallVector.h */; };
-		2FEA0A5B24902F9F00EEF3AD /* MVKVector.h in Headers */ = {isa = PBXBuildFile; fileRef = 83A4AD2521BD75570006C935 /* MVKVector.h */; };
 		2FEA0A5C24902F9F00EEF3AD /* MVKCommandPool.h in Headers */ = {isa = PBXBuildFile; fileRef = A94FB77A1C7DFB4800632CA3 /* MVKCommandPool.h */; };
 		2FEA0A5D24902F9F00EEF3AD /* MVKShaderModule.h in Headers */ = {isa = PBXBuildFile; fileRef = A94FB7971C7DFB4800632CA3 /* MVKShaderModule.h */; };
 		2FEA0A5E24902F9F00EEF3AD /* MVKVulkanAPIObject.h in Headers */ = {isa = PBXBuildFile; fileRef = A99C91012295FAC500A061DA /* MVKVulkanAPIObject.h */; };
@@ -142,10 +140,6 @@
 		45557A5321C9EFF3008868BD /* MVKCodec.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 45557A4D21C9EFF3008868BD /* MVKCodec.cpp */; };
 		45557A5421C9EFF3008868BD /* MVKCodec.h in Headers */ = {isa = PBXBuildFile; fileRef = 45557A5121C9EFF3008868BD /* MVKCodec.h */; };
 		45557A5521C9EFF3008868BD /* MVKCodec.h in Headers */ = {isa = PBXBuildFile; fileRef = 45557A5121C9EFF3008868BD /* MVKCodec.h */; };
-		83A4AD2A21BD75570006C935 /* MVKVector.h in Headers */ = {isa = PBXBuildFile; fileRef = 83A4AD2521BD75570006C935 /* MVKVector.h */; };
-		83A4AD2B21BD75570006C935 /* MVKVector.h in Headers */ = {isa = PBXBuildFile; fileRef = 83A4AD2521BD75570006C935 /* MVKVector.h */; };
-		83A4AD2C21BD75570006C935 /* MVKVectorAllocator.h in Headers */ = {isa = PBXBuildFile; fileRef = 83A4AD2921BD75570006C935 /* MVKVectorAllocator.h */; };
-		83A4AD2D21BD75570006C935 /* MVKVectorAllocator.h in Headers */ = {isa = PBXBuildFile; fileRef = 83A4AD2921BD75570006C935 /* MVKVectorAllocator.h */; };
 		A9096E5E1F81E16300DFBEA6 /* MVKCmdDispatch.mm in Sources */ = {isa = PBXBuildFile; fileRef = A9096E5D1F81E16300DFBEA6 /* MVKCmdDispatch.mm */; };
 		A9096E5F1F81E16300DFBEA6 /* MVKCmdDispatch.mm in Sources */ = {isa = PBXBuildFile; fileRef = A9096E5D1F81E16300DFBEA6 /* MVKCmdDispatch.mm */; };
 		A909F65F213B190700FCD6BE /* MVKExtensions.h in Headers */ = {isa = PBXBuildFile; fileRef = A909F65A213B190600FCD6BE /* MVKExtensions.h */; };
@@ -310,6 +304,9 @@
 		A98149641FB6A3F7005F00B4 /* MVKWatermarkTextureContent.h in Headers */ = {isa = PBXBuildFile; fileRef = A981494C1FB6A3F7005F00B4 /* MVKWatermarkTextureContent.h */; };
 		A981496B1FB6A998005F00B4 /* MVKStrings.h in Headers */ = {isa = PBXBuildFile; fileRef = A981496A1FB6A998005F00B4 /* MVKStrings.h */; };
 		A981496C1FB6A998005F00B4 /* MVKStrings.h in Headers */ = {isa = PBXBuildFile; fileRef = A981496A1FB6A998005F00B4 /* MVKStrings.h */; };
+		A98C81A1257AD5C1006A9F80 /* MVKBitArray.h in Headers */ = {isa = PBXBuildFile; fileRef = A98C819F257AD5C0006A9F80 /* MVKBitArray.h */; };
+		A98C81A2257AD5C1006A9F80 /* MVKBitArray.h in Headers */ = {isa = PBXBuildFile; fileRef = A98C819F257AD5C0006A9F80 /* MVKBitArray.h */; };
+		A98C81A3257AD5C1006A9F80 /* MVKBitArray.h in Headers */ = {isa = PBXBuildFile; fileRef = A98C819F257AD5C0006A9F80 /* MVKBitArray.h */; };
 		A99C90EE229455B300A061DA /* MVKCmdDebug.h in Headers */ = {isa = PBXBuildFile; fileRef = A99C90EC229455B200A061DA /* MVKCmdDebug.h */; };
 		A99C90EF229455B300A061DA /* MVKCmdDebug.h in Headers */ = {isa = PBXBuildFile; fileRef = A99C90EC229455B200A061DA /* MVKCmdDebug.h */; };
 		A99C90F0229455B300A061DA /* MVKCmdDebug.mm in Sources */ = {isa = PBXBuildFile; fileRef = A99C90ED229455B300A061DA /* MVKCmdDebug.mm */; };
@@ -428,8 +425,6 @@
 		45557A4D21C9EFF3008868BD /* MVKCodec.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = MVKCodec.cpp; sourceTree = "<group>"; };
 		45557A5121C9EFF3008868BD /* MVKCodec.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MVKCodec.h; sourceTree = "<group>"; };
 		45557A5721CD83C3008868BD /* MVKDXTnCodec.def */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.h; fileEncoding = 4; path = MVKDXTnCodec.def; sourceTree = "<group>"; };
-		83A4AD2521BD75570006C935 /* MVKVector.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MVKVector.h; sourceTree = "<group>"; };
-		83A4AD2921BD75570006C935 /* MVKVectorAllocator.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MVKVectorAllocator.h; sourceTree = "<group>"; };
 		A9096E5C1F81E16300DFBEA6 /* MVKCmdDispatch.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = MVKCmdDispatch.h; sourceTree = "<group>"; };
 		A9096E5D1F81E16300DFBEA6 /* MVKCmdDispatch.mm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.objcpp; path = MVKCmdDispatch.mm; sourceTree = "<group>"; };
 		A909F65A213B190600FCD6BE /* MVKExtensions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MVKExtensions.h; sourceTree = "<group>"; };
@@ -513,6 +508,7 @@
 		A981494B1FB6A3F7005F00B4 /* MVKWatermarkShaderSource.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MVKWatermarkShaderSource.h; sourceTree = "<group>"; };
 		A981494C1FB6A3F7005F00B4 /* MVKWatermarkTextureContent.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MVKWatermarkTextureContent.h; sourceTree = "<group>"; };
 		A981496A1FB6A998005F00B4 /* MVKStrings.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MVKStrings.h; sourceTree = "<group>"; };
+		A98C819F257AD5C0006A9F80 /* MVKBitArray.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MVKBitArray.h; sourceTree = "<group>"; };
 		A99C90EC229455B200A061DA /* MVKCmdDebug.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MVKCmdDebug.h; sourceTree = "<group>"; };
 		A99C90ED229455B300A061DA /* MVKCmdDebug.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = MVKCmdDebug.mm; sourceTree = "<group>"; };
 		A99C91002295FAC500A061DA /* MVKVulkanAPIObject.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = MVKVulkanAPIObject.mm; sourceTree = "<group>"; };
@@ -682,6 +678,7 @@
 			children = (
 				A98149421FB6A3F7005F00B4 /* MVKBaseObject.h */,
 				A98149411FB6A3F7005F00B4 /* MVKBaseObject.mm */,
+				A98C819F257AD5C0006A9F80 /* MVKBitArray.h */,
 				4553AEFA2251617100E8EBCD /* MVKBlockObserver.h */,
 				4553AEF62251617100E8EBCD /* MVKBlockObserver.m */,
 				45557A4D21C9EFF3008868BD /* MVKCodec.cpp */,
@@ -693,8 +690,6 @@
 				A98149461FB6A3F7005F00B4 /* MVKObjectPool.h */,
 				A9F3D9DB24732A4D00745190 /* MVKSmallVector.h */,
 				A9F3D9D924732A4C00745190 /* MVKSmallVectorAllocator.h */,
-				83A4AD2521BD75570006C935 /* MVKVector.h */,
-				83A4AD2921BD75570006C935 /* MVKVectorAllocator.h */,
 				A98149491FB6A3F7005F00B4 /* MVKWatermark.h */,
 				A981494A1FB6A3F7005F00B4 /* MVKWatermark.mm */,
 				A981494B1FB6A3F7005F00B4 /* MVKWatermarkShaderSource.h */,
@@ -807,15 +802,14 @@
 				2FEA0A5024902F9F00EEF3AD /* MVKCodec.h in Headers */,
 				2FEA0A5124902F9F00EEF3AD /* MVKRenderPass.h in Headers */,
 				2FEA0A5224902F9F00EEF3AD /* MVKLogging.h in Headers */,
+				A98C81A2257AD5C1006A9F80 /* MVKBitArray.h in Headers */,
 				2FEA0A5324902F9F00EEF3AD /* MVKQueue.h in Headers */,
 				2FEA0A5424902F9F00EEF3AD /* MVKFramebuffer.h in Headers */,
-				2FEA0A5524902F9F00EEF3AD /* MVKVectorAllocator.h in Headers */,
 				2FEA0A5624902F9F00EEF3AD /* MVKWatermarkShaderSource.h in Headers */,
 				2FEA0A5724902F9F00EEF3AD /* MTLSamplerDescriptor+MoltenVK.h in Headers */,
 				2FEA0A5824902F9F00EEF3AD /* MVKSync.h in Headers */,
 				2FEA0A5924902F9F00EEF3AD /* MVKDevice.h in Headers */,
 				2FEA0A5A24902F9F00EEF3AD /* MVKSmallVector.h in Headers */,
-				2FEA0A5B24902F9F00EEF3AD /* MVKVector.h in Headers */,
 				2FEA0A5C24902F9F00EEF3AD /* MVKCommandPool.h in Headers */,
 				2FEA0A5D24902F9F00EEF3AD /* MVKShaderModule.h in Headers */,
 				2FEA0A5E24902F9F00EEF3AD /* MVKVulkanAPIObject.h in Headers */,
@@ -883,19 +877,18 @@
 				453638322508A4C7000EFFD3 /* MTLRenderPassStencilAttachmentDescriptor+MoltenVK.h in Headers */,
 				A94FB8001C7DFB4800632CA3 /* MVKQueue.h in Headers */,
 				A94FB7EC1C7DFB4800632CA3 /* MVKFramebuffer.h in Headers */,
-				83A4AD2C21BD75570006C935 /* MVKVectorAllocator.h in Headers */,
 				A98149611FB6A3F7005F00B4 /* MVKWatermarkShaderSource.h in Headers */,
 				A9E53DE32100B197002781DD /* MTLSamplerDescriptor+MoltenVK.h in Headers */,
 				A94FB8181C7DFB4800632CA3 /* MVKSync.h in Headers */,
 				A94FB7E41C7DFB4800632CA3 /* MVKDevice.h in Headers */,
 				A9F3D9DE24732A4D00745190 /* MVKSmallVector.h in Headers */,
-				83A4AD2A21BD75570006C935 /* MVKVector.h in Headers */,
 				A94FB7D41C7DFB4800632CA3 /* MVKCommandPool.h in Headers */,
 				A94FB80C1C7DFB4800632CA3 /* MVKShaderModule.h in Headers */,
 				A99C91042295FAC600A061DA /* MVKVulkanAPIObject.h in Headers */,
 				A94FB7C01C7DFB4800632CA3 /* MVKCmdQueries.h in Headers */,
 				A94FB7CC1C7DFB4800632CA3 /* MVKCommand.h in Headers */,
 				A981494F1FB6A3F7005F00B4 /* MVKBaseObject.h in Headers */,
+				A98C81A1257AD5C1006A9F80 /* MVKBitArray.h in Headers */,
 				A9C96DD01DDC20C20053187F /* MVKMTLBufferAllocation.h in Headers */,
 				A98149571FB6A3F7005F00B4 /* MVKObjectPool.h in Headers */,
 				A94FB8141C7DFB4800632CA3 /* MVKSwapchain.h in Headers */,
@@ -957,19 +950,18 @@
 				453638342508A4C7000EFFD3 /* MTLRenderPassStencilAttachmentDescriptor+MoltenVK.h in Headers */,
 				A94FB8011C7DFB4800632CA3 /* MVKQueue.h in Headers */,
 				A94FB7ED1C7DFB4800632CA3 /* MVKFramebuffer.h in Headers */,
-				83A4AD2D21BD75570006C935 /* MVKVectorAllocator.h in Headers */,
 				A98149621FB6A3F7005F00B4 /* MVKWatermarkShaderSource.h in Headers */,
 				A9E53DE42100B197002781DD /* MTLSamplerDescriptor+MoltenVK.h in Headers */,
 				A94FB8191C7DFB4800632CA3 /* MVKSync.h in Headers */,
 				A94FB7E51C7DFB4800632CA3 /* MVKDevice.h in Headers */,
 				A9F3D9DF24732A4D00745190 /* MVKSmallVector.h in Headers */,
-				83A4AD2B21BD75570006C935 /* MVKVector.h in Headers */,
 				A94FB7D51C7DFB4800632CA3 /* MVKCommandPool.h in Headers */,
 				A94FB80D1C7DFB4800632CA3 /* MVKShaderModule.h in Headers */,
 				A99C91052295FAC600A061DA /* MVKVulkanAPIObject.h in Headers */,
 				A94FB7C11C7DFB4800632CA3 /* MVKCmdQueries.h in Headers */,
 				A94FB7CD1C7DFB4800632CA3 /* MVKCommand.h in Headers */,
 				A98149501FB6A3F7005F00B4 /* MVKBaseObject.h in Headers */,
+				A98C81A3257AD5C1006A9F80 /* MVKBitArray.h in Headers */,
 				A9C96DD11DDC20C20053187F /* MVKMTLBufferAllocation.h in Headers */,
 				A98149581FB6A3F7005F00B4 /* MVKObjectPool.h in Headers */,
 				A94FB8151C7DFB4800632CA3 /* MVKSwapchain.h in Headers */,
diff --git a/MoltenVK/MoltenVK/API/mvk_datatypes.h b/MoltenVK/MoltenVK/API/mvk_datatypes.h
index 611e9d6..3cf55e7 100644
--- a/MoltenVK/MoltenVK/API/mvk_datatypes.h
+++ b/MoltenVK/MoltenVK/API/mvk_datatypes.h
@@ -323,7 +323,7 @@
 	kMVKShaderStageTessEval,
 	kMVKShaderStageFragment,
 	kMVKShaderStageCompute,
-	kMVKShaderStageMax
+	kMVKShaderStageCount
 } MVKShaderStage;
 
 /** Returns the Metal MTLColorWriteMask corresponding to the specified Vulkan VkColorComponentFlags. */
diff --git a/MoltenVK/MoltenVK/API/vk_mvk_moltenvk.h b/MoltenVK/MoltenVK/API/vk_mvk_moltenvk.h
index 9b667a7..56578fd 100644
--- a/MoltenVK/MoltenVK/API/vk_mvk_moltenvk.h
+++ b/MoltenVK/MoltenVK/API/vk_mvk_moltenvk.h
@@ -50,12 +50,12 @@
  */
 #define MVK_VERSION_MAJOR   1
 #define MVK_VERSION_MINOR   1
-#define MVK_VERSION_PATCH   1
+#define MVK_VERSION_PATCH   2
 
 #define MVK_MAKE_VERSION(major, minor, patch)    (((major) * 10000) + ((minor) * 100) + (patch))
 #define MVK_VERSION     MVK_MAKE_VERSION(MVK_VERSION_MAJOR, MVK_VERSION_MINOR, MVK_VERSION_PATCH)
 
-#define VK_MVK_MOLTENVK_SPEC_VERSION            29
+#define VK_MVK_MOLTENVK_SPEC_VERSION            30
 #define VK_MVK_MOLTENVK_EXTENSION_NAME          "VK_MVK_moltenvk"
 
 /**
@@ -137,14 +137,26 @@
  *     Xcode user interface.
  *       0: No automatic GPU capture.
  *       1: Capture all GPU commands issued during the lifetime of the VkDevice.
- *     If MVK_CONFIG_AUTO_GPU_CAPTURE_OUTPUT_FILE is also set, it is a filename where the automatic
- *     GPU capture should be saved. In this case, the Xcode scheme need not have Metal GPU capture
- *     enabled, and in fact the app need not be run under Xcode's control at all. This is useful
- *     in case the app cannot be run under Xcode's control. A path starting with '~' can be used
- *     to place it in a user's home directory, as in the shell. This feature requires Metal 3.0
- *     (macOS 10.15, iOS 13).
+ *       2: Capture all GPU commands issued during the rendering of the first frame.
  *     If none of these is set, no automatic GPU capture will occur.
  *
+ *     If MVK_CONFIG_AUTO_GPU_CAPTURE_SCOPE is set to 2, to enable capturing the first frame,
+ *     the command queue from which the frame is captured is determined by the values of
+ *     defaultGPUCaptureScopeQueueFamilyIndex and defaultGPUCaptureScopeQueueIndex from MVKConfiguration,
+ *     or the corresponding MVK_CONFIG_DEFAULT_GPU_CAPTURE_SCOPE_QUEUE_FAMILY_INDEX and
+ *     MVK_CONFIG_DEFAULT_GPU_CAPTURE_SCOPE_QUEUE_INDEX runtime environment variable or
+ *     MoltenVK compile-time build settings.
+ *
+ *     If MVK_CONFIG_AUTO_GPU_CAPTURE_OUTPUT_FILE is also set, it is a filename (with a file
+ *     extension of .gputrace) where the automatic GPU capture should be saved. In this case,
+ *     the Xcode scheme need not have Metal GPU capture enabled, and in fact the app need not
+ *     be run under Xcode's control at all. This is useful in case the app cannot be run under
+ *     Xcode's control. A path starting with '~' can be used to place it in a user's home
+ *     directory, as in the shell. This feature requires Metal 3.0 (macOS 10.15, iOS 13).
+ *     In addition, for automatic file capture, the app requires at least a minimal Info.plist
+ *     file with the MetalCaptureEnabled key set to true. For command line executables (like
+ *     Vulkan CTS), the Info.plist file can be placed in the same directory as the executable.
+ *
  * 6.  The MVK_CONFIG_TEXTURE_1D_AS_2D runtime environment variable or MoltenVK compile-time build
  *     setting controls whether MoltenVK should use a Metal 2D texture with a height of 1 for a
  *     Vulkan 1D image, or use a native Metal 1D texture. Metal imposes significant restrictions
@@ -152,14 +164,14 @@
  *     Using a Metal 2D texture allows Vulkan 1D textures to support this additional functionality.
  *     This setting is enabled by default, and MoltenVK will use a Metal 2D texture for each Vulkan 1D image.
  *
- * 7.  The MVK_CONFIG_PREALLOCATE_DESCRIPTORS runtime environment variable or MoltenVK compile-time
- *     build setting controls whether MoltenVK should preallocate memory in each VkDescriptorPool
- *     according to the values of the VkDescriptorPoolSize parameters. Doing so may improve
- *     descriptor set allocation performance at a cost of preallocated application memory.
- *     If this setting is disabled, the descriptors required for a descriptor set will
- *     be dynamically allocated in application memory when the descriptor set itself is allocated.
- *     This setting is disabled by default, and MoltenVK will dynamically allocate descriptors
- *     when the containing descriptor set is allocated.
+ * 7.  The MVK_CONFIG_PREALLOCATE_DESCRIPTORS runtime environment variable or MoltenVK
+ *     compile-time build setting controls whether MoltenVK should preallocate memory during
+ *     vkCreateDescriptorPool() according to the values of the VkDescriptorPoolSize parameters.
+ *     Doing so may improve descriptor set allocation performance at a cost of preallocated
+ *     application memory. If this setting is disabled, the descriptors required for
+ *     a descriptor set will be dynamically allocated in application memory when the
+ *     descriptor set itself is allocated. This setting is enabled by default,
+ *     and MoltenVK will preallocate descriptors during vkCreateDescriptorPool().
  *
  * 8.  The MVK_CONFIG_USE_COMMAND_POOLING runtime environment variable or MoltenVK compile-time
  *     build setting controls whether MoltenVK should use pools to manage memory used when
@@ -190,6 +202,29 @@
  *     MVK_CONFIG_PERFORMANCE_LOGGING_FRAME_COUNT environment variable or MoltenVK
  *     compile-time build setting. This setting is disabled by default, and activity
  *     performance will be logged only when frame activity is logged.
+ *
+ * 11. The MVK_CONFIG_USE_METAL_ARGUMENT_BUFFERS runtime environment variable or MoltenVK
+ *     compile-time build setting controls whether MoltenVK should use Metal argument
+ *     buffers for resources defined in descriptor sets. Using Metal argument buffers
+ *     dramatically increases the number of buffers, textures and samplers that can be
+ *     bound to a pipeline shader, and in most cases improves performance.
+ *     If this setting is enabled, MoltenVK will use Metal argument buffers to bind
+ *     resources to the shaders. If this setting is disabled, MoltenVK will bind
+ *     resources to shaders discretely. This setting is enabled by default, and MoltenVK
+ *     will use Metal argument buffers.
+ *
+ * 12. The MVK_CONFIG_EMBED_INLINE_BLOCKS_IN_METAL_ARGUMENT_BUFFER runtime environment variable
+ *     or MoltenVK compile-time build setting controls whether MoltenVK should embed the contents
+ *     of inline-block descriptors directly in the Metal argument buffer, instead of writing the
+ *     contents of the descriptor in an intermediary MTLBuffer, which is then inserted into the
+ *     Metal argument buffer. Embedding inline-block descriptor content directly into the Metal
+ *     argument buffer improves efficiency and reduces resources, but currently does not cover
+ *     all types of possible inline content, and may cause errors in some cases. If this setting
+ *     is enabled, MoltenVK will embed inline-block descriptor content directly into the Metal
+ *     argument buffers. If this setting is disabled, MoltenVK will write inline-block content
+ *     to an intermediary MTLBuffer, and then insert that MTLBuffer into the Metal argument buffer.
+ *     This setting is disabled by default, and MoltenVK will use an intermediary MTLBuffer.
+ *     This setting only takes effect if the MVK_CONFIG_USE_METAL_ARGUMENT_BUFFERS setting is enabled.
  */
 typedef struct {
 
@@ -648,6 +683,7 @@
 	VkBool32 simdPermute;						/**< If true, SIMD-group permutation functions (vote, ballot, shuffle) are supported in shaders. */
 	VkBool32 simdReduction;						/**< If true, SIMD-group reduction functions (arithmetic) are supported in shaders. */
     uint32_t minSubgroupSize;			        /**< The minimum number of threads in a SIMD-group. */
+	VkBool32 argumentBuffers;					/**< If true, argument buffers are supported and will be used for descriptor sets. */
 } MVKPhysicalDeviceMetalFeatures;
 
 /** MoltenVK performance of a particular type of activity. */
diff --git a/MoltenVK/MoltenVK/Commands/MVKCommandBuffer.h b/MoltenVK/MoltenVK/Commands/MVKCommandBuffer.h
index 9e2ef99..3fe84d1 100644
--- a/MoltenVK/MoltenVK/Commands/MVKCommandBuffer.h
+++ b/MoltenVK/MoltenVK/Commands/MVKCommandBuffer.h
@@ -302,6 +302,18 @@
     /** Binds a pipeline to a bind point. */
     void bindPipeline(VkPipelineBindPoint pipelineBindPoint, MVKPipeline* pipeline);
 
+	/** Indicate to either the graphic or compute encoder that a resource is being used within an argument buffer. */
+	void useArgumentBufferResource(const MVKMTLArgumentBufferResourceUsage& resourceUsage, bool isComputeStage);
+
+	/** Bind a buffer to either the graphic or compute encoder, based on the stage. */
+	void bindBuffer(const MVKMTLBufferBinding& binding, MVKShaderStage stage);
+
+	/** Bind a texture to either the graphic or compute encoder, based on the stage. */
+	void bindTexture(const MVKMTLTextureBinding& binding, MVKShaderStage stage);
+
+	/** Bind a sampler to either the graphic or compute encoder, based on the stage. */
+	void bindSamplerState(const MVKMTLSamplerStateBinding& binding, MVKShaderStage stage);
+
 	/** Encodes an operation to signal an event to a status. */
 	void signalEvent(MVKEvent* mvkEvent, bool status);
 
diff --git a/MoltenVK/MoltenVK/Commands/MVKCommandBuffer.mm b/MoltenVK/MoltenVK/Commands/MVKCommandBuffer.mm
index 65f06a6..19585da 100644
--- a/MoltenVK/MoltenVK/Commands/MVKCommandBuffer.mm
+++ b/MoltenVK/MoltenVK/Commands/MVKCommandBuffer.mm
@@ -422,6 +422,38 @@
     }
 }
 
+void MVKCommandEncoder::useArgumentBufferResource(const MVKMTLArgumentBufferResourceUsage& resourceUsage, bool isComputeStage) {
+	if (isComputeStage) {
+		_computeResourcesState.useArgumentBufferResource(resourceUsage);
+	} else {
+		_graphicsResourcesState.useArgumentBufferResource(resourceUsage);
+	}
+}
+
+void MVKCommandEncoder::bindBuffer(const MVKMTLBufferBinding& binding, MVKShaderStage stage) {
+	if (stage == kMVKShaderStageCompute) {
+		_computeResourcesState.bindBuffer(binding);
+	} else {
+		_graphicsResourcesState.bindBuffer(stage, binding);
+	}
+}
+
+void MVKCommandEncoder::bindTexture(const MVKMTLTextureBinding& binding, MVKShaderStage stage) {
+	if (stage == kMVKShaderStageCompute) {
+		_computeResourcesState.bindTexture(binding);
+	} else {
+		_graphicsResourcesState.bindTexture(stage, binding);
+	}
+}
+
+void MVKCommandEncoder::bindSamplerState(const MVKMTLSamplerStateBinding& binding, MVKShaderStage stage) {
+	if (stage == kMVKShaderStageCompute) {
+		_computeResourcesState.bindSamplerState(binding);
+	} else {
+		_graphicsResourcesState.bindSamplerState(stage, binding);
+	}
+}
+
 void MVKCommandEncoder::signalEvent(MVKEvent* mvkEvent, bool status) {
 	endCurrentMetalEncoding();
 	mvkEvent->encodeSignal(_mtlCmdBuffer, status);
diff --git a/MoltenVK/MoltenVK/Commands/MVKCommandEncoderState.h b/MoltenVK/MoltenVK/Commands/MVKCommandEncoderState.h
index 62d4a8a..cfdd69b 100644
--- a/MoltenVK/MoltenVK/Commands/MVKCommandEncoderState.h
+++ b/MoltenVK/MoltenVK/Commands/MVKCommandEncoderState.h
@@ -352,7 +352,9 @@
 
 public:
 
-    /** Constructs this instance for the specified command encoder. */
+	/** Indicates that a resource is being used within an argument buffer. */
+	void useArgumentBufferResource(const MVKMTLArgumentBufferResourceUsage& resourceUsage);
+
     MVKResourcesCommandEncoderState(MVKCommandEncoder* cmdEncoder) : MVKCommandEncoderState(cmdEncoder) {}
 
 protected:
@@ -454,6 +456,11 @@
 		}
 	};
 
+	void resetImpl() override;
+	void markDirty() override;
+
+	MVKSmallVector<MVKMTLArgumentBufferResourceUsage, 8> _argumentBufferResourceUsage;
+	bool _areArgumentBufferResourceUsageDirty = false;
 };
 
 
@@ -521,6 +528,7 @@
     void encodeImpl(uint32_t stage) override;
     void resetImpl() override;
     void markDirty() override;
+	void encodeArgumentBufferResources();
 
     ResourceBindings<8> _shaderStageResourceBindings[4];
 };
@@ -559,6 +567,7 @@
 protected:
     void encodeImpl(uint32_t) override;
     void resetImpl() override;
+	void encodeArgumentBufferResources();
 
 	ResourceBindings<4> _resourceBindings;
 };
diff --git a/MoltenVK/MoltenVK/Commands/MVKCommandEncoderState.mm b/MoltenVK/MoltenVK/Commands/MVKCommandEncoderState.mm
index 671ed45..caa896b 100644
--- a/MoltenVK/MoltenVK/Commands/MVKCommandEncoderState.mm
+++ b/MoltenVK/MoltenVK/Commands/MVKCommandEncoderState.mm
@@ -513,6 +513,38 @@
 	}
 }
 
+#pragma mark -
+#pragma mark MVKGraphicsResourcesCommandEncoderState
+
+void MVKResourcesCommandEncoderState::useArgumentBufferResource(const MVKMTLArgumentBufferResourceUsage& resourceUsage) {
+
+	if ( !resourceUsage.mtlResource ) { return; }
+
+	MVKMTLArgumentBufferResourceUsage dru = resourceUsage;   // Copy that can be marked dirty
+	MVKCommandEncoderState::markDirty();
+	_areArgumentBufferResourceUsageDirty = true;
+	dru.isDirty = true;
+
+	for (auto iter = _argumentBufferResourceUsage.begin(), end = _argumentBufferResourceUsage.end(); iter != end; ++iter) {
+		if( iter->mtlResource == dru.mtlResource ) {
+			*iter = dru;
+			return;
+		}
+	}
+	_argumentBufferResourceUsage.push_back(dru);
+}
+
+// Mark everything as dirty
+void MVKResourcesCommandEncoderState::markDirty() {
+	MVKCommandEncoderState::markDirty();
+	markDirty(_argumentBufferResourceUsage, _areArgumentBufferResourceUsageDirty);
+}
+
+void MVKResourcesCommandEncoderState::resetImpl() {
+	_argumentBufferResourceUsage.clear();
+	_areArgumentBufferResourceUsageDirty = false;
+}
+
 
 #pragma mark -
 #pragma mark MVKGraphicsResourcesCommandEncoderState
@@ -636,7 +668,7 @@
 
 // Mark everything as dirty
 void MVKGraphicsResourcesCommandEncoderState::markDirty() {
-    MVKCommandEncoderState::markDirty();
+	MVKResourcesCommandEncoderState::markDirty();
     for (uint32_t i = kMVKShaderStageVertex; i <= kMVKShaderStageFragment; i++) {
         MVKResourcesCommandEncoderState::markDirty(_shaderStageResourceBindings[i].bufferBindings, _shaderStageResourceBindings[i].areBufferBindingsDirty);
         MVKResourcesCommandEncoderState::markDirty(_shaderStageResourceBindings[i].textureBindings, _shaderStageResourceBindings[i].areTextureBindingsDirty);
@@ -646,7 +678,9 @@
 
 void MVKGraphicsResourcesCommandEncoderState::encodeImpl(uint32_t stage) {
 
-    MVKGraphicsPipeline* pipeline = (MVKGraphicsPipeline*)_cmdEncoder->_graphicsPipelineState.getPipeline();
+	encodeArgumentBufferResources();
+
+	MVKGraphicsPipeline* pipeline = (MVKGraphicsPipeline*)_cmdEncoder->_graphicsPipelineState.getPipeline();
     bool fullImageViewSwizzle = pipeline->fullImageViewSwizzle() || _cmdEncoder->getDevice()->_pMetalFeatures->nativeTextureSwizzle;
     bool forTessellation = pipeline->isTessellationPipeline();
 
@@ -809,7 +843,24 @@
     }
 }
 
+void MVKGraphicsResourcesCommandEncoderState::encodeArgumentBufferResources() {
+
+	encodeBinding<MVKMTLArgumentBufferResourceUsage>(_argumentBufferResourceUsage,
+													 _areArgumentBufferResourceUsageDirty,
+													 [](MVKCommandEncoder* cmdEncoder, MVKMTLArgumentBufferResourceUsage& abru)->void {
+														 if (abru.mtlStages) {
+															 auto* mtlEnc = cmdEncoder->_mtlRenderEncoder;
+															 if ([mtlEnc respondsToSelector: @selector(useResource:usage:stages:)]) {
+																 [mtlEnc useResource: abru.mtlResource usage: abru.mtlUsage stages: abru.mtlStages];
+															 } else {
+																 [mtlEnc useResource: abru.mtlResource usage: abru.mtlUsage];
+															 }
+														 }
+													 });
+}
+
 void MVKGraphicsResourcesCommandEncoderState::resetImpl() {
+	MVKResourcesCommandEncoderState::resetImpl();
 	for (uint32_t i = kMVKShaderStageVertex; i <= kMVKShaderStageFragment; i++) {
 		_shaderStageResourceBindings[i].reset();
 	}
@@ -845,7 +896,7 @@
 
 // Mark everything as dirty
 void MVKComputeResourcesCommandEncoderState::markDirty() {
-    MVKCommandEncoderState::markDirty();
+	MVKResourcesCommandEncoderState::markDirty();
     MVKResourcesCommandEncoderState::markDirty(_resourceBindings.bufferBindings, _resourceBindings.areBufferBindingsDirty);
     MVKResourcesCommandEncoderState::markDirty(_resourceBindings.textureBindings, _resourceBindings.areTextureBindingsDirty);
     MVKResourcesCommandEncoderState::markDirty(_resourceBindings.samplerStateBindings, _resourceBindings.areSamplerStateBindingsDirty);
@@ -853,6 +904,8 @@
 
 void MVKComputeResourcesCommandEncoderState::encodeImpl(uint32_t) {
 
+	encodeArgumentBufferResources();
+
     MVKPipeline* pipeline = _cmdEncoder->_computePipelineState.getPipeline();
 	bool fullImageViewSwizzle = pipeline ? pipeline->fullImageViewSwizzle() : false;
 
@@ -908,8 +961,18 @@
 																												   atIndex: b.index];
                                              });
 }
+void MVKComputeResourcesCommandEncoderState::encodeArgumentBufferResources() {
+
+	encodeBinding<MVKMTLArgumentBufferResourceUsage>(_argumentBufferResourceUsage,
+													 _areArgumentBufferResourceUsageDirty,
+													 [](MVKCommandEncoder* cmdEncoder, MVKMTLArgumentBufferResourceUsage& abru)->void {
+														 auto* mtlEnc = cmdEncoder->getMTLComputeEncoder(kMVKCommandUseDispatch);
+														 [mtlEnc useResource: abru.mtlResource usage: abru.mtlUsage];
+													 });
+}
 
 void MVKComputeResourcesCommandEncoderState::resetImpl() {
+	MVKResourcesCommandEncoderState::resetImpl();
 	_resourceBindings.reset();
 }
 
diff --git a/MoltenVK/MoltenVK/Commands/MVKMTLBufferAllocation.mm b/MoltenVK/MoltenVK/Commands/MVKMTLBufferAllocation.mm
index a09386b..789aa0a 100644
--- a/MoltenVK/MoltenVK/Commands/MVKMTLBufferAllocation.mm
+++ b/MoltenVK/MoltenVK/Commands/MVKMTLBufferAllocation.mm
@@ -18,6 +18,7 @@
 
 #include "MVKMTLBufferAllocation.h"
 #include "MVKLogging.h"
+#include <algorithm>
 
 
 #pragma mark -
@@ -80,6 +81,9 @@
 const MVKMTLBufferAllocation* MVKMTLBufferAllocator::acquireMTLBufferRegion(NSUInteger length) {
 	MVKAssert(length <= _maxAllocationLength, "This MVKMTLBufferAllocator has been configured to dispense MVKMTLBufferRegions no larger than %lu bytes.", (unsigned long)_maxAllocationLength);
 
+	// Can't allocate a segment smaller than the minimum MTLBuffer alignment.
+	length = std::max<NSUInteger>(length, _device->_pMetalFeatures->mtlBufferAlignment);
+
     // Convert max length to the next power-of-two exponent to use as a lookup
     NSUInteger p2Exp = mvkPowerOfTwoExponent(length);
 	MVKMTLBufferAllocationPool* pRP = _regionPools[p2Exp];
@@ -87,7 +91,7 @@
 }
 
 MVKMTLBufferAllocator::MVKMTLBufferAllocator(MVKDevice* device, NSUInteger maxRegionLength, bool makeThreadSafe) : MVKBaseDeviceObject(device) {
-    _maxAllocationLength = maxRegionLength;
+	_maxAllocationLength = std::max<NSUInteger>(maxRegionLength, _device->_pMetalFeatures->mtlBufferAlignment);
 	_makeThreadSafe = makeThreadSafe;
 
     // Convert max length to the next power-of-two exponent
diff --git a/MoltenVK/MoltenVK/Commands/MVKMTLResourceBindings.h b/MoltenVK/MoltenVK/Commands/MVKMTLResourceBindings.h
index a530288..bf96e5e 100644
--- a/MoltenVK/MoltenVK/Commands/MVKMTLResourceBindings.h
+++ b/MoltenVK/MoltenVK/Commands/MVKMTLResourceBindings.h
@@ -53,6 +53,14 @@
     bool isInline = false;
 } MVKMTLBufferBinding;
 
+/** Describes a MTLResource binding used in a Metal argument buffer. */
+typedef struct {
+	id<MTLResource> mtlResource = nil;
+	MTLResourceUsage mtlUsage = 0;
+	MTLRenderStages mtlStages = 0;
+	bool isDirty = true;
+} MVKMTLArgumentBufferResourceUsage;
+
 /** Describes a MTLBuffer resource binding as used for an index buffer. */
 typedef struct {
     union { id<MTLBuffer> mtlBuffer = nil; id<MTLBuffer> mtlResource; }; // aliases
diff --git a/MoltenVK/MoltenVK/GPUObjects/MVKDescriptor.h b/MoltenVK/MoltenVK/GPUObjects/MVKDescriptor.h
index 1339972..0065408 100644
--- a/MoltenVK/MoltenVK/GPUObjects/MVKDescriptor.h
+++ b/MoltenVK/MoltenVK/GPUObjects/MVKDescriptor.h
@@ -19,6 +19,7 @@
 #pragma once
 
 #include "MVKImage.h"
+#include "MVKMTLBufferAllocation.h"
 #include "MVKSmallVector.h"
 
 class MVKDescriptorSet;
@@ -30,12 +31,14 @@
 
 /** Indicates the Metal resource indexes used by a single shader stage in a descriptor. */
 typedef struct MVKShaderStageResourceBinding {
+	uint16_t resourceIndex = 0;
 	uint16_t bufferIndex = 0;
 	uint16_t textureIndex = 0;
 	uint16_t samplerIndex = 0;
 
 	MVKShaderStageResourceBinding operator+ (const MVKShaderStageResourceBinding& rhs);
 	MVKShaderStageResourceBinding& operator+= (const MVKShaderStageResourceBinding& rhs);
+	void addArgumentBuffer(const MVKShaderStageResourceBinding& rhs);
 
 } MVKShaderStageResourceBinding;
 
@@ -44,7 +47,7 @@
 
 /** Indicates the Metal resource indexes used by each shader stage in a descriptor. */
 typedef struct MVKShaderResourceBinding {
-	MVKShaderStageResourceBinding stages[kMVKShaderStageMax];
+	MVKShaderStageResourceBinding stages[kMVKShaderStageCount];
 
 	uint16_t getMaxBufferIndex();
 	uint16_t getMaxTextureIndex();
@@ -52,9 +55,25 @@
 
 	MVKShaderResourceBinding operator+ (const MVKShaderResourceBinding& rhs);
 	MVKShaderResourceBinding& operator+= (const MVKShaderResourceBinding& rhs);
+	void addArgumentBuffer(const MVKShaderResourceBinding& rhs);
 
 } MVKShaderResourceBinding;
 
+/**
+ * If the shader stage binding has a binding defined for the specified stage, populates
+ * the context at the descriptor set binding from the shader stage resource binding.
+ */
+void mvkPopulateShaderConverterContext(mvk::SPIRVToMSLConversionConfiguration& context,
+									   MVKShaderStageResourceBinding& ssRB,
+									   spv::ExecutionModel stage,
+									   uint32_t descriptorSetIndex,
+									   uint32_t bindingIndex,
+									   uint32_t count,
+									   MVKSampler* immutableSampler);
+
+/** Returns a bitwise OR of Metal render stages from the array of shader stages, which must have a length of kMVKShaderStageCount. */
+MTLRenderStages mvkMTLRenderStagesFromMVKShaderStages(bool stageEnabled[]);
+
 
 #pragma mark -
 #pragma mark MVKDescriptorSetLayoutBinding
@@ -83,7 +102,7 @@
 	 * count provided to that descriptor set is returned. Otherwise returns the value
 	 * defined in VkDescriptorSetLayoutBinding::descriptorCount.
 	 */
-	uint32_t getDescriptorCount(MVKDescriptorSet* descSet);
+	uint32_t getDescriptorCount(MVKDescriptorSet* descSet = nullptr);
 
 	/** Returns the descriptor type of this layout. */
 	inline VkDescriptorType getDescriptorType() { return _info.descriptorType; }
@@ -108,33 +127,68 @@
               const void* pData,
               MVKShaderResourceBinding& dslMTLRezIdxOffsets);
 
-	/** Populates the specified shader converter context, at the specified descriptor set binding. */
-	void populateShaderConverterContext(mvk::SPIRVToMSLConversionConfiguration& context,
-                                        MVKShaderResourceBinding& dslMTLRezIdxOffsets,
-                                        uint32_t dslIndex);
+	/** Returns whether this binding layout is using an argument buffer. */
+	bool isUsingMetalArgumentBuffer() const;
+
+	/** Writes the buffer content to the Metal argument buffer. */
+	void writeToMetalArgumentBuffer(id<MTLBuffer> mtlBuffer,
+									NSUInteger offset,
+									uint32_t elementIndex);
+
+	/** Writes the texture content to the Metal argument buffer. */
+	void writeToMetalArgumentBuffer(id<MTLTexture> mtlTexture,
+									uint32_t planeCount,
+									uint32_t planeIndex,
+									uint32_t elementIndex);
+
+	/** Writes the sampler content to the Metal argument buffer. */
+	void writeToMetalArgumentBuffer(id<MTLSamplerState> mtlSamplerState,
+									uint32_t elementIndex);
+
+	/** Writes the inline data content to the Metal argument buffer. */
+	void writeToMetalArgumentBuffer(uint8_t* pSrcData,
+									NSUInteger dstOffset,
+									NSUInteger dataLen);
 
 	MVKDescriptorSetLayoutBinding(MVKDevice* device,
 								  MVKDescriptorSetLayout* layout,
 								  const VkDescriptorSetLayoutBinding* pBinding,
-								  VkDescriptorBindingFlagsEXT bindingFlags);
+								  VkDescriptorBindingFlagsEXT bindingFlags,
+								  uint32_t descriptorIndex);
 
 	MVKDescriptorSetLayoutBinding(const MVKDescriptorSetLayoutBinding& binding);
 
 	~MVKDescriptorSetLayoutBinding() override;
 
 protected:
-    friend class MVKInlineUniformBlockDescriptor;
+    friend class MVKDescriptorSetLayout;
+	friend class MVKInlineUniformBlockDescriptor;
+
+	inline uint32_t getDescriptorIndex(uint32_t elementIndex = 0) { return _descriptorIndex + elementIndex; }
+	inline uint32_t getMTLArgumentBufferIndex(uint32_t mvkShaderStage, uint32_t elementIndex = 0) {
+		return _argumentBufferIndex[mvkShaderStage] + elementIndex;
+	}
 	void initMetalResourceIndexOffsets(MVKShaderStageResourceBinding* pBindingIndexes,
 									   MVKShaderStageResourceBinding* pDescSetCounts,
 									   const VkDescriptorSetLayoutBinding* pBinding);
+	void addMTLArgumentDescriptors(uint32_t stage, NSMutableArray<MTLArgumentDescriptor*>* args, uint32_t& argIdx);
+	void addMTLArgumentDescriptor(NSMutableArray<MTLArgumentDescriptor*>* args,
+								  MTLDataType dataType,
+								  MTLArgumentAccess access,
+								  uint32_t& argIdx);
 	bool validate(MVKSampler* mvkSampler);
+	void populateShaderConverterContext(mvk::SPIRVToMSLConversionConfiguration& context,
+										MVKShaderResourceBinding& dslMTLRezIdxOffsets,
+										uint32_t dslIndex);
 
 	MVKDescriptorSetLayout* _layout;
 	VkDescriptorSetLayoutBinding _info;
 	VkDescriptorBindingFlagsEXT _flags;
 	MVKSmallVector<MVKSampler*> _immutableSamplers;
+	uint32_t _descriptorIndex;
 	MVKShaderResourceBinding _mtlResourceIndexOffsets;
-	bool _applyToStage[kMVKShaderStageMax];
+	uint32_t _argumentBufferIndex[kMVKShaderStageCount];
+	bool _applyToStage[kMVKShaderStageCount];
 };
 
 
@@ -153,6 +207,7 @@
 
 	/** Encodes this descriptor (based on its layout binding index) on the the command encoder. */
 	virtual void bind(MVKCommandEncoder* cmdEncoder,
+					  MVKDescriptorSetLayoutBinding* mvkDSLBind,
 					  uint32_t descriptorIndex,
 					  bool stages[],
 					  MVKShaderResourceBinding& mtlIndexes,
@@ -161,11 +216,13 @@
 
 	/**
 	 * Updates the internal binding from the specified content. The format of the content depends
-	 * on the descriptor type, and is extracted from pData at the location given by index * stride.
+	 * on the descriptor type, and is extracted from pData at the location given by srcIndex * stride.
 	 * MVKInlineUniformBlockDescriptor uses the index as byte offset to write to.
 	 */
-	virtual void write(MVKDescriptorSet* mvkDescSet,
-					   uint32_t index,
+	virtual void write(MVKDescriptorSetLayoutBinding* mvkDSLBind,
+					   MVKDescriptorSet* descSet,
+					   uint32_t srcIndex,
+					   uint32_t dstIndex,
 					   size_t stride,
 					   const void* pData) = 0;
 
@@ -180,8 +237,7 @@
 	 * at which to start writing.
 	 * MVKInlineUniformBlockDescriptor uses the index as byte offset to read from.
 	 */
-	virtual void read(MVKDescriptorSet* mvkDescSet,
-					  uint32_t index,
+	virtual void read(uint32_t index,
 					  VkDescriptorImageInfo* pImageInfo,
 					  VkDescriptorBufferInfo* pBufferInfo,
 					  VkBufferView* pTexelBufferView,
@@ -195,9 +251,13 @@
 
 	~MVKDescriptor() { reset(); }
 
+protected:
+	MTLResourceUsage getMTLResourceUsage();
+
 };
 
 
+
 #pragma mark -
 #pragma mark MVKBufferDescriptor
 
@@ -206,19 +266,21 @@
 
 public:
 	void bind(MVKCommandEncoder* cmdEncoder,
+			  MVKDescriptorSetLayoutBinding* mvkDSLBind,
 			  uint32_t descriptorIndex,
 			  bool stages[],
 			  MVKShaderResourceBinding& mtlIndexes,
 			  MVKArrayRef<uint32_t> dynamicOffsets,
 			  uint32_t& dynamicOffsetIndex) override;
 
-	void write(MVKDescriptorSet* mvkDescSet,
+	void write(MVKDescriptorSetLayoutBinding* mvkDSLBind,
+			   MVKDescriptorSet* descSet,
 			   uint32_t srcIndex,
+			   uint32_t dstIndex,
 			   size_t stride,
 			   const void* pData) override;
 
-	void read(MVKDescriptorSet* mvkDescSet,
-			  uint32_t dstIndex,
+	void read(uint32_t dstIndex,
 			  VkDescriptorImageInfo* pImageInfo,
 			  VkDescriptorBufferInfo* pBufferInfo,
 			  VkBufferView* pTexelBufferView,
@@ -281,33 +343,42 @@
 	VkDescriptorType getDescriptorType() override { return VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT; }
 
 	void bind(MVKCommandEncoder* cmdEncoder,
+			  MVKDescriptorSetLayoutBinding* mvkDSLBind,
 			  uint32_t descriptorIndex,
 			  bool stages[],
 			  MVKShaderResourceBinding& mtlIndexes,
 			  MVKArrayRef<uint32_t> dynamicOffsets,
 			  uint32_t& dynamicOffsetIndex) override;
 
-	void write(MVKDescriptorSet* mvkDescSet,
+	void write(MVKDescriptorSetLayoutBinding* mvkDSLBind,
+			   MVKDescriptorSet* descSet,
 			   uint32_t dstOffset, // For inline buffers we are using this parameter as dst offset not as src descIdx
+			   uint32_t dstIndex,
 			   size_t stride,
 			   const void* pData) override;
 
-	void read(MVKDescriptorSet* mvkDescSet,
-			  uint32_t srcOffset, // For inline buffers we are using this parameter as src offset not as dst descIdx
+	void read(uint32_t srcOffset, // For inline buffers we are using this parameter as src offset not as dst descIdx
 			  VkDescriptorImageInfo* pImageInfo,
 			  VkDescriptorBufferInfo* pBufferInfo,
 			  VkBufferView* pTexelBufferView,
 			  VkWriteDescriptorSetInlineUniformBlockEXT* inlineUniformBlock) override;
-    
-    void setLayout(MVKDescriptorSetLayoutBinding* dslBinding, uint32_t index) override;
 
 	void reset() override;
 
+	/**
+	 * Returns whether inline blocks should be embedded directly into a Metal argument buffer, instead of
+	 * being held in an intermediaary MTLBuffer, with that MTLBuffer inserted into the Metal argument buffer.
+	 */
+	static bool shouldEmbedInlineBlocksInMetalAgumentBuffer();
+
 	~MVKInlineUniformBlockDescriptor() { reset(); }
 
 protected:
-	uint8_t* _buffer = nullptr;
-    uint32_t _length;
+	uint8_t* getData();
+
+	void* _buffer = nullptr;
+    uint32_t _length = 0;
+	bool _isUsingIntermediaryMTLBuffer = false;
 };
 
 
@@ -319,19 +390,21 @@
 
 public:
 	void bind(MVKCommandEncoder* cmdEncoder,
+			  MVKDescriptorSetLayoutBinding* mvkDSLBind,
 			  uint32_t descriptorIndex,
 			  bool stages[],
 			  MVKShaderResourceBinding& mtlIndexes,
 			  MVKArrayRef<uint32_t> dynamicOffsets,
 			  uint32_t& dynamicOffsetIndex) override;
 
-	void write(MVKDescriptorSet* mvkDescSet,
+	void write(MVKDescriptorSetLayoutBinding* mvkDSLBind,
+			   MVKDescriptorSet* descSet,
 			   uint32_t srcIndex,
+			   uint32_t dstIndex,
 			   size_t stride,
 			   const void* pData) override;
 
-	void read(MVKDescriptorSet* mvkDescSet,
-			  uint32_t dstIndex,
+	void read(uint32_t dstIndex,
 			  VkDescriptorImageInfo* pImageInfo,
 			  VkDescriptorBufferInfo* pBufferInfo,
 			  VkBufferView* pTexelBufferView,
@@ -388,19 +461,21 @@
 
 protected:
 	void bind(MVKCommandEncoder* cmdEncoder,
+			  MVKDescriptorSetLayoutBinding* mvkDSLBind,
 			  uint32_t descriptorIndex,
 			  bool stages[],
 			  MVKShaderResourceBinding& mtlIndexes,
 			  MVKArrayRef<uint32_t> dynamicOffsets,
 			  uint32_t& dynamicOffsetIndex);
 
-	void write(MVKDescriptorSet* mvkDescSet,
+	void write(MVKDescriptorSetLayoutBinding* mvkDSLBind,
+			   MVKDescriptorSet* descSet,
 			   uint32_t srcIndex,
+			   uint32_t dstIndex,
 			   size_t stride,
 			   const void* pData);
 
-	void read(MVKDescriptorSet* mvkDescSet,
-			  uint32_t dstIndex,
+	void read(uint32_t dstIndex,
 			  VkDescriptorImageInfo* pImageInfo,
 			  VkDescriptorBufferInfo* pBufferInfo,
 			  VkBufferView* pTexelBufferView,
@@ -408,6 +483,12 @@
 
 	void setLayout(MVKDescriptorSetLayoutBinding* dslBinding, uint32_t index);
 
+	/**
+	 * Offset to the first sampler index in the argument buffer. Defaults to zero for simple sampler
+	 * descriptors, but combined image/sampler descriptor will override to index samplers after textures.
+	 */
+	virtual uint32_t getSamplerArgBufferIndexOffset(MVKDescriptorSetLayoutBinding* dslBinding) { return 0; }
+
 	void reset();
 
 	~MVKSamplerDescriptorMixin() { reset(); }
@@ -427,19 +508,21 @@
 	VkDescriptorType getDescriptorType() override { return VK_DESCRIPTOR_TYPE_SAMPLER; }
 
 	void bind(MVKCommandEncoder* cmdEncoder,
+			  MVKDescriptorSetLayoutBinding* mvkDSLBind,
 			  uint32_t descriptorIndex,
 			  bool stages[],
 			  MVKShaderResourceBinding& mtlIndexes,
 			  MVKArrayRef<uint32_t> dynamicOffsets,
 			  uint32_t& dynamicOffsetIndex) override;
 
-	void write(MVKDescriptorSet* mvkDescSet,
+	void write(MVKDescriptorSetLayoutBinding* mvkDSLBind,
+			   MVKDescriptorSet* descSet,
 			   uint32_t srcIndex,
+			   uint32_t dstIndex,
 			   size_t stride,
 			   const void* pData) override;
 
-	void read(MVKDescriptorSet* mvkDescSet,
-			  uint32_t dstIndex,
+	void read(uint32_t dstIndex,
 			  VkDescriptorImageInfo* pImageInfo,
 			  VkDescriptorBufferInfo* pBufferInfo,
 			  VkBufferView* pTexelBufferView,
@@ -464,19 +547,21 @@
 	VkDescriptorType getDescriptorType() override { return VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; }
 
 	void bind(MVKCommandEncoder* cmdEncoder,
+			  MVKDescriptorSetLayoutBinding* mvkDSLBind,
 			  uint32_t descriptorIndex,
 			  bool stages[],
 			  MVKShaderResourceBinding& mtlIndexes,
 			  MVKArrayRef<uint32_t> dynamicOffsets,
 			  uint32_t& dynamicOffsetIndex) override;
 
-	void write(MVKDescriptorSet* mvkDescSet,
+	void write(MVKDescriptorSetLayoutBinding* mvkDSLBind,
+			   MVKDescriptorSet* descSet,
 			   uint32_t srcIndex,
+			   uint32_t dstIndex,
 			   size_t stride,
 			   const void* pData) override;
 
-	void read(MVKDescriptorSet* mvkDescSet,
-			  uint32_t dstIndex,
+	void read(uint32_t dstIndex,
 			  VkDescriptorImageInfo* pImageInfo,
 			  VkDescriptorBufferInfo* pBufferInfo,
 			  VkBufferView* pTexelBufferView,
@@ -484,6 +569,8 @@
 
 	void setLayout(MVKDescriptorSetLayoutBinding* dslBinding, uint32_t index) override;
 
+	uint32_t getSamplerArgBufferIndexOffset(MVKDescriptorSetLayoutBinding* dslBinding) override;
+
 	void reset() override;
 
 	~MVKCombinedImageSamplerDescriptor() { reset(); }
@@ -499,19 +586,21 @@
 
 public:
 	void bind(MVKCommandEncoder* cmdEncoder,
+			  MVKDescriptorSetLayoutBinding* mvkDSLBind,
 			  uint32_t descriptorIndex,
 			  bool stages[],
 			  MVKShaderResourceBinding& mtlIndexes,
 			  MVKArrayRef<uint32_t> dynamicOffsets,
 			  uint32_t& dynamicOffsetIndex) override;
 
-	void write(MVKDescriptorSet* mvkDescSet,
+	void write(MVKDescriptorSetLayoutBinding* mvkDSLBind,
+			   MVKDescriptorSet* descSet,
 			   uint32_t srcIndex,
+			   uint32_t dstIndex,
 			   size_t stride,
 			   const void* pData) override;
 
-	void read(MVKDescriptorSet* mvkDescSet,
-			  uint32_t dstIndex,
+	void read(uint32_t dstIndex,
 			  VkDescriptorImageInfo* pImageInfo,
 			  VkDescriptorBufferInfo* pBufferInfo,
 			  VkBufferView* pTexelBufferView,
diff --git a/MoltenVK/MoltenVK/GPUObjects/MVKDescriptor.mm b/MoltenVK/MoltenVK/GPUObjects/MVKDescriptor.mm
index 189be4d..88ae6c5 100644
--- a/MoltenVK/MoltenVK/GPUObjects/MVKDescriptor.mm
+++ b/MoltenVK/MoltenVK/GPUObjects/MVKDescriptor.mm
@@ -18,6 +18,7 @@
 
 #include "MVKDescriptor.h"
 #include "MVKDescriptorSet.h"
+#include "MVKCommandBuffer.h"
 #include "MVKBuffer.h"
 
 
@@ -25,6 +26,7 @@
 
 MVKShaderStageResourceBinding MVKShaderStageResourceBinding::operator+ (const MVKShaderStageResourceBinding& rhs) {
 	MVKShaderStageResourceBinding rslt;
+	rslt.resourceIndex = this->resourceIndex + rhs.resourceIndex;
 	rslt.bufferIndex = this->bufferIndex + rhs.bufferIndex;
 	rslt.textureIndex = this->textureIndex + rhs.textureIndex;
 	rslt.samplerIndex = this->samplerIndex + rhs.samplerIndex;
@@ -32,12 +34,19 @@
 }
 
 MVKShaderStageResourceBinding& MVKShaderStageResourceBinding::operator+= (const MVKShaderStageResourceBinding& rhs) {
+	this->resourceIndex += rhs.resourceIndex;
 	this->bufferIndex += rhs.bufferIndex;
 	this->textureIndex += rhs.textureIndex;
 	this->samplerIndex += rhs.samplerIndex;
 	return *this;
 }
 
+void MVKShaderStageResourceBinding::addArgumentBuffer(const MVKShaderStageResourceBinding& rhs) {
+	bool isUsed = rhs.resourceIndex > 0;
+	this->bufferIndex += isUsed;
+	this->resourceIndex += isUsed;
+}
+
 
 #pragma mark MVKShaderResourceBinding
 
@@ -55,19 +64,71 @@
 
 MVKShaderResourceBinding MVKShaderResourceBinding::operator+ (const MVKShaderResourceBinding& rhs) {
 	MVKShaderResourceBinding rslt;
-	for (uint32_t i = kMVKShaderStageVertex; i < kMVKShaderStageMax; i++) {
+	for (uint32_t i = kMVKShaderStageVertex; i < kMVKShaderStageCount; i++) {
 		rslt.stages[i] = this->stages[i] + rhs.stages[i];
 	}
 	return rslt;
 }
 
 MVKShaderResourceBinding& MVKShaderResourceBinding::operator+= (const MVKShaderResourceBinding& rhs) {
-	for (uint32_t i = kMVKShaderStageVertex; i < kMVKShaderStageMax; i++) {
+	for (uint32_t i = kMVKShaderStageVertex; i < kMVKShaderStageCount; i++) {
 		this->stages[i] += rhs.stages[i];
 	}
 	return *this;
 }
 
+void MVKShaderResourceBinding::addArgumentBuffer(const MVKShaderResourceBinding& rhs) {
+	for (uint32_t i = kMVKShaderStageVertex; i < kMVKShaderStageCount; i++) {
+		this->stages[i].addArgumentBuffer(rhs.stages[i]);
+	}
+}
+
+void mvkPopulateShaderConverterContext(mvk::SPIRVToMSLConversionConfiguration& context,
+									   MVKShaderStageResourceBinding& ssRB,
+									   spv::ExecutionModel stage,
+									   uint32_t descriptorSetIndex,
+									   uint32_t bindingIndex,
+									   uint32_t count,
+									   MVKSampler* immutableSampler) {
+	mvk::MSLResourceBinding rb;
+
+	auto& rbb = rb.resourceBinding;
+	rbb.stage = stage;
+	rbb.desc_set = descriptorSetIndex;
+	rbb.binding = bindingIndex;
+	rbb.count = count;
+	rbb.msl_buffer = ssRB.bufferIndex;
+	rbb.msl_texture = ssRB.textureIndex;
+	rbb.msl_sampler = ssRB.samplerIndex;
+
+	if (immutableSampler) { immutableSampler->getConstexprSampler(rb); }
+
+	context.resourceBindings.push_back(rb);
+}
+
+MTLRenderStages mvkMTLRenderStagesFromMVKShaderStages(bool stageEnabled[]) {
+	MTLRenderStages mtlStages = 0;
+	for (uint32_t stage = kMVKShaderStageVertex; stage < kMVKShaderStageCount; stage++) {
+		if (stageEnabled[stage]) {
+			switch (stage) {
+				case kMVKShaderStageVertex:
+				case kMVKShaderStageTessCtl:
+				case kMVKShaderStageTessEval:
+					mtlStages |= MTLRenderStageVertex;
+					break;
+
+				case kMVKShaderStageFragment:
+					mtlStages |= MTLRenderStageFragment;
+					break;
+
+				default:
+					break;
+			}
+		}
+	}
+	return mtlStages;
+}
+
 
 #pragma mark -
 #pragma mark MVKDescriptorSetLayoutBinding
@@ -80,7 +141,7 @@
 		return 1;
 	}
 
-	if (descSet && hasVariableDescriptorCount()) {
+	if (descSet && mvkIsAnyFlagEnabled(_flags, VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT)) {
 		return descSet->_variableDescriptorCount;
 	}
 
@@ -106,7 +167,7 @@
     for (uint32_t descIdx = 0; descIdx < descCnt; descIdx++) {
 		MVKDescriptor* mvkDesc = descSet->getDescriptor(getBinding(), descIdx);
 		if (mvkDesc->getDescriptorType() == descType) {
-			mvkDesc->bind(cmdEncoder, descIdx, _applyToStage, mtlIdxs, dynamicOffsets, dynamicOffsetIndex);
+			mvkDesc->bind(cmdEncoder, this, descIdx, _applyToStage, mtlIdxs, dynamicOffsets, dynamicOffsetIndex);
 		}
     }
 }
@@ -166,14 +227,10 @@
                 else
                     bb.size = (uint32_t)bufferInfo.range;
 
-                for (uint32_t i = kMVKShaderStageVertex; i < kMVKShaderStageMax; i++) {
+                for (uint32_t i = kMVKShaderStageVertex; i < kMVKShaderStageCount; i++) {
                     if (_applyToStage[i]) {
                         bb.index = mtlIdxs.stages[i].bufferIndex + rezIdx;
-                        if (i == kMVKShaderStageCompute) {
-							if (cmdEncoder) { cmdEncoder->_computeResourcesState.bindBuffer(bb); }
-                        } else {
-							if (cmdEncoder) { cmdEncoder->_graphicsResourcesState.bindBuffer(MVKShaderStage(i), bb); }
-                        }
+						if (cmdEncoder) { cmdEncoder->bindBuffer(bb, MVKShaderStage(i)); }
                     }
                 }
                 break;
@@ -184,14 +241,10 @@
                 bb.mtlBytes = inlineUniformBlock.pData;
                 bb.size = inlineUniformBlock.dataSize;
                 bb.isInline = true;
-                for (uint32_t i = kMVKShaderStageVertex; i < kMVKShaderStageMax; i++) {
+                for (uint32_t i = kMVKShaderStageVertex; i < kMVKShaderStageCount; i++) {
                     if (_applyToStage[i]) {
                         bb.index = mtlIdxs.stages[i].bufferIndex;
-                        if (i == kMVKShaderStageCompute) {
-                            if (cmdEncoder) { cmdEncoder->_computeResourcesState.bindBuffer(bb); }
-                        } else {
-                            if (cmdEncoder) { cmdEncoder->_graphicsResourcesState.bindBuffer(MVKShaderStage(i), bb); }
-                        }
+						if (cmdEncoder) { cmdEncoder->bindBuffer(bb, MVKShaderStage(i)); }
                     }
                 }
                 break;
@@ -213,21 +266,13 @@
                         bb.offset = mtlTex.bufferOffset;
                         bb.size = (uint32_t)(mtlTex.height * mtlTex.bufferBytesPerRow);
                     }
-                    for (uint32_t i = kMVKShaderStageVertex; i < kMVKShaderStageMax; i++) {
+                    for (uint32_t i = kMVKShaderStageVertex; i < kMVKShaderStageCount; i++) {
                         if (_applyToStage[i]) {
                             tb.index = mtlIdxs.stages[i].textureIndex + rezIdx + planeIndex;
-                            if (i == kMVKShaderStageCompute) {
-                                if (cmdEncoder) { cmdEncoder->_computeResourcesState.bindTexture(tb); }
-                            } else {
-                                if (cmdEncoder) { cmdEncoder->_graphicsResourcesState.bindTexture(MVKShaderStage(i), tb); }
-                            }
+							if (cmdEncoder) { cmdEncoder->bindTexture(tb, MVKShaderStage(i)); }
                             if (_info.descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE) {
                                 bb.index = mtlIdxs.stages[i].bufferIndex + rezIdx;
-                                if (i == kMVKShaderStageCompute) {
-                                    if (cmdEncoder) { cmdEncoder->_computeResourcesState.bindBuffer(bb); }
-                                } else {
-                                    if (cmdEncoder) { cmdEncoder->_graphicsResourcesState.bindBuffer(MVKShaderStage(i), bb); }
-                                }
+								if (cmdEncoder) { cmdEncoder->bindBuffer(bb, MVKShaderStage(i)); }
                             }
                         }
                     }
@@ -246,21 +291,13 @@
                     bb.offset = mtlTex.bufferOffset;
                     bb.size = (uint32_t)(mtlTex.height * mtlTex.bufferBytesPerRow);
                 }
-                for (uint32_t i = kMVKShaderStageVertex; i < kMVKShaderStageMax; i++) {
+                for (uint32_t i = kMVKShaderStageVertex; i < kMVKShaderStageCount; i++) {
                     if (_applyToStage[i]) {
                         tb.index = mtlIdxs.stages[i].textureIndex + rezIdx;
-                        if (i == kMVKShaderStageCompute) {
-							if (cmdEncoder) { cmdEncoder->_computeResourcesState.bindTexture(tb); }
-                        } else {
-							if (cmdEncoder) { cmdEncoder->_graphicsResourcesState.bindTexture(MVKShaderStage(i), tb); }
-                        }
+						if (cmdEncoder) { cmdEncoder->bindTexture(tb, MVKShaderStage(i)); }
                         if (_info.descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER) {
                             bb.index = mtlIdxs.stages[i].bufferIndex + rezIdx;
-                            if (i == kMVKShaderStageCompute) {
-                                if (cmdEncoder) { cmdEncoder->_computeResourcesState.bindBuffer(bb); }
-                            } else {
-                                if (cmdEncoder) { cmdEncoder->_graphicsResourcesState.bindBuffer(MVKShaderStage(i), bb); }
-                            }
+							if (cmdEncoder) { cmdEncoder->bindBuffer(bb, MVKShaderStage(i)); }
                         }
                     }
                 }
@@ -276,14 +313,10 @@
                     sampler = _immutableSamplers[rezIdx];
 				}
                 sb.mtlSamplerState = sampler->getMTLSamplerState();
-                for (uint32_t i = kMVKShaderStageVertex; i < kMVKShaderStageMax; i++) {
+                for (uint32_t i = kMVKShaderStageVertex; i < kMVKShaderStageCount; i++) {
                     if (_applyToStage[i]) {
                         sb.index = mtlIdxs.stages[i].samplerIndex + rezIdx;
-                        if (i == kMVKShaderStageCompute) {
-							if (cmdEncoder) { cmdEncoder->_computeResourcesState.bindSamplerState(sb); }
-                        } else {
-							if (cmdEncoder) { cmdEncoder->_graphicsResourcesState.bindSamplerState(MVKShaderStage(i), sb); }
-                        }
+						if (cmdEncoder) { cmdEncoder->bindSamplerState(sb, MVKShaderStage(i)); }
                     }
                 }
                 break;
@@ -304,17 +337,14 @@
                         sampler = _immutableSamplers[rezIdx];
                     }
                     sb.mtlSamplerState = sampler->getMTLSamplerState();
-                    for (uint32_t i = kMVKShaderStageVertex; i < kMVKShaderStageMax; i++) {
+                    for (uint32_t i = kMVKShaderStageVertex; i < kMVKShaderStageCount; i++) {
                         if (_applyToStage[i]) {
                             tb.index = mtlIdxs.stages[i].textureIndex + rezIdx + planeIndex;
                             sb.index = mtlIdxs.stages[i].samplerIndex + rezIdx;
-                            if (i == kMVKShaderStageCompute) {
-                                if (cmdEncoder) { cmdEncoder->_computeResourcesState.bindTexture(tb); }
-                                if (cmdEncoder) { cmdEncoder->_computeResourcesState.bindSamplerState(sb); }
-                            } else {
-                                if (cmdEncoder) { cmdEncoder->_graphicsResourcesState.bindTexture(MVKShaderStage(i), tb); }
-                                if (cmdEncoder) { cmdEncoder->_graphicsResourcesState.bindSamplerState(MVKShaderStage(i), sb); }
-                            }
+							if (cmdEncoder) {
+								cmdEncoder->bindTexture(tb, MVKShaderStage(i));
+								cmdEncoder->bindSamplerState(sb, MVKShaderStage(i));
+							}
                         }
                     }
                 }
@@ -335,6 +365,146 @@
     }
 }
 
+bool MVKDescriptorSetLayoutBinding::isUsingMetalArgumentBuffer() const  { return _layout->isUsingMetalArgumentBuffer(); };
+
+// Adds MTLArgumentDescriptors to the array, and updates resource indexes consumed.
+void MVKDescriptorSetLayoutBinding::addMTLArgumentDescriptors(uint32_t stage,
+															  NSMutableArray<MTLArgumentDescriptor*>* args,
+															  uint32_t& argIdx) {
+	if ( !_applyToStage[stage]) { return; }
+
+	_argumentBufferIndex[stage] = argIdx;
+
+	switch (getDescriptorType()) {
+
+		case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+		case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+			addMTLArgumentDescriptor(args, MTLDataTypePointer, MTLArgumentAccessReadOnly, argIdx);
+			break;
+
+		case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
+		case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
+			addMTLArgumentDescriptor(args, MTLDataTypePointer, MTLArgumentAccessReadWrite, argIdx);
+			break;
+
+		case VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT:
+			if (MVKInlineUniformBlockDescriptor::shouldEmbedInlineBlocksInMetalAgumentBuffer()) {
+				addMTLArgumentDescriptor(args, MTLDataTypeUChar, MTLArgumentAccessReadOnly, argIdx);
+			} else {
+				addMTLArgumentDescriptor(args, MTLDataTypePointer, MTLArgumentAccessReadOnly, argIdx);
+			}
+			break;
+
+		case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
+		case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
+			addMTLArgumentDescriptor(args, MTLDataTypeTexture, MTLArgumentAccessReadOnly, argIdx);
+			break;
+
+		case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
+			addMTLArgumentDescriptor(args, MTLDataTypeTexture, MTLArgumentAccessReadWrite, argIdx);
+//			addMTLArgumentDescriptor(args, MTLDataTypePointer, MTLArgumentAccessReadWrite, argIdx);		// Needed for atomic operations
+			break;
+
+		case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
+			addMTLArgumentDescriptor(args, MTLDataTypeTexture, MTLArgumentAccessReadOnly, argIdx);
+			break;
+
+		case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
+			addMTLArgumentDescriptor(args, MTLDataTypeTexture, MTLArgumentAccessReadWrite, argIdx);
+//			addMTLArgumentDescriptor(args, MTLDataTypePointer, MTLArgumentAccessReadWrite, argIdx);		// Needed for atomic operations
+			break;
+
+		case VK_DESCRIPTOR_TYPE_SAMPLER:
+			addMTLArgumentDescriptor(args, MTLDataTypeSampler, MTLArgumentAccessReadOnly, argIdx);
+			break;
+
+		case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
+			addMTLArgumentDescriptor(args, MTLDataTypeTexture, MTLArgumentAccessReadOnly, argIdx);
+			addMTLArgumentDescriptor(args, MTLDataTypeSampler, MTLArgumentAccessReadOnly, argIdx);
+			break;
+
+		default:
+			break;
+	}
+}
+
+// Adds an MTLArgumentDescriptor if the specified type to the array, and updates resource indexes consumed.
+void MVKDescriptorSetLayoutBinding::addMTLArgumentDescriptor(NSMutableArray<MTLArgumentDescriptor*>* args,
+															 MTLDataType dataType,
+															 MTLArgumentAccess access,
+															 uint32_t& argIdx) {
+
+	NSUInteger mtlArgDescAryLen = ((_info.descriptorType == VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT &&
+									MVKInlineUniformBlockDescriptor::shouldEmbedInlineBlocksInMetalAgumentBuffer())
+								   ? _info.descriptorCount : getDescriptorCount());
+
+	auto* argDesc = [MTLArgumentDescriptor argumentDescriptor];
+	argDesc.dataType = dataType;
+	argDesc.access = access;
+	argDesc.index = argIdx;
+	argDesc.arrayLength = mtlArgDescAryLen;
+	argDesc.textureType = MTLTextureType2D;
+
+	[args addObject: argDesc];
+	argIdx += getDescriptorCount();
+}
+
+void MVKDescriptorSetLayoutBinding::writeToMetalArgumentBuffer(id<MTLBuffer> mtlBuffer,
+															   NSUInteger offset,
+															   uint32_t elementIndex) {
+	if ( !isUsingMetalArgumentBuffer() || !mtlBuffer ) { return; }
+
+	for (uint32_t stage = kMVKShaderStageVertex; stage < kMVKShaderStageCount; stage++) {
+		if (_applyToStage[stage]) {
+			uint32_t argIdx = getMTLArgumentBufferIndex(stage, elementIndex);
+			[_layout->_argumentEncoder[stage].mtlArgumentEncoder setBuffer: mtlBuffer offset: offset atIndex: argIdx];
+		}
+	}
+}
+
+void MVKDescriptorSetLayoutBinding::writeToMetalArgumentBuffer(id<MTLTexture> mtlTexture,
+															   uint32_t planeCount,
+															   uint32_t planeIndex,
+															   uint32_t elementIndex) {
+	if ( !isUsingMetalArgumentBuffer() || !mtlTexture ) { return; }
+
+	for (uint32_t stage = kMVKShaderStageVertex; stage < kMVKShaderStageCount; stage++) {
+		if (_applyToStage[stage]) {
+			uint32_t argIdx = getMTLArgumentBufferIndex(stage, elementIndex * planeCount + planeIndex);
+			[_layout->_argumentEncoder[stage].mtlArgumentEncoder setTexture: mtlTexture atIndex: argIdx];
+		}
+	}
+}
+
+void MVKDescriptorSetLayoutBinding::writeToMetalArgumentBuffer(id<MTLSamplerState> mtlSamplerState,
+															   uint32_t elementIndex) {
+	if ( !isUsingMetalArgumentBuffer() ) { return; }
+
+	// Metal requires sampler, so get default if not provided.
+	if ( !mtlSamplerState ) { mtlSamplerState = getDevice()->getDefaultMTLSamplerState(); }
+
+	for (uint32_t stage = kMVKShaderStageVertex; stage < kMVKShaderStageCount; stage++) {
+		if (_applyToStage[stage]) {
+			uint32_t argIdx = getMTLArgumentBufferIndex(stage, elementIndex);
+			[_layout->_argumentEncoder[stage].mtlArgumentEncoder setSamplerState: mtlSamplerState atIndex: argIdx];
+		}
+	}
+}
+
+void MVKDescriptorSetLayoutBinding::writeToMetalArgumentBuffer(uint8_t* pSrcData,
+															   NSUInteger dstOffset,
+															   NSUInteger dataLen) {
+	if ( !isUsingMetalArgumentBuffer() || !pSrcData ) { return; }
+
+	for (uint32_t stage = kMVKShaderStageVertex; stage < kMVKShaderStageCount; stage++) {
+		if (_applyToStage[stage]) {
+			uint32_t argIdx = getMTLArgumentBufferIndex(stage);
+			uint8_t* pDstData = (uint8_t*)[_layout->_argumentEncoder[stage].mtlArgumentEncoder constantDataAtIndex: argIdx];
+			if (pDstData) { memcpy(pDstData + dstOffset, pSrcData, dataLen); }
+		}
+	}
+}
+
 // If depth compare is required, but unavailable on the device, the sampler can only be used as an immutable sampler
 bool MVKDescriptorSetLayoutBinding::validate(MVKSampler* mvkSampler) {
 	if (mvkSampler->getRequiresConstExprSampler()) {
@@ -360,31 +530,44 @@
         spv::ExecutionModelFragment,
         spv::ExecutionModelGLCompute
     };
-    for (uint32_t i = kMVKShaderStageVertex; i < kMVKShaderStageMax; i++) {
+    for (uint32_t i = kMVKShaderStageVertex; i < kMVKShaderStageCount; i++) {
         if (_applyToStage[i]) {
             mvkPopulateShaderConverterContext(context,
                                               mtlIdxs.stages[i],
                                               models[i],
                                               dslIndex,
                                               _info.binding,
-											  getDescriptorCount(nullptr),
+											  getDescriptorCount(),
 											  mvkSamp);
-        }
+
+			// If Metal argument buffers are in use, identify any inline uniform block bindings.
+			if (_info.descriptorType == VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT &&
+				isUsingMetalArgumentBuffer() &&
+				MVKInlineUniformBlockDescriptor::shouldEmbedInlineBlocksInMetalAgumentBuffer()) {
+
+				mvk::DescriptorBinding db;
+				db.descriptorSet = dslIndex;
+				db.binding = _info.binding;
+				context.inlineUniformBlocks.push_back(db);
+			}
+		}
     }
 }
 
 MVKDescriptorSetLayoutBinding::MVKDescriptorSetLayoutBinding(MVKDevice* device,
 															 MVKDescriptorSetLayout* layout,
 															 const VkDescriptorSetLayoutBinding* pBinding,
-															 VkDescriptorBindingFlagsEXT bindingFlags) :
+															 VkDescriptorBindingFlagsEXT bindingFlags,
+															 uint32_t descriptorIndex) :
 	MVKBaseDeviceObject(device),
 	_layout(layout),
 	_info(*pBinding),
-	_flags(bindingFlags) {
+	_flags(bindingFlags),
+	_descriptorIndex(descriptorIndex) {
 
 	_info.pImmutableSamplers = nullptr;     // Remove dangling pointer
 
-	for (uint32_t i = kMVKShaderStageVertex; i < kMVKShaderStageMax; i++) {
+	for (uint32_t i = kMVKShaderStageVertex; i < kMVKShaderStageCount; i++) {
         // Determine if this binding is used by this shader stage
         _applyToStage[i] = mvkAreAllFlagsEnabled(pBinding->stageFlags, mvkVkShaderStageFlagBitsFromMVKShaderStage(MVKShaderStage(i)));
 	    // If this binding is used by the shader, set the Metal resource index
@@ -412,10 +595,11 @@
 	_layout(binding._layout),
 	_info(binding._info),
 	_flags(binding._flags),
+	_descriptorIndex(binding._descriptorIndex),
 	_immutableSamplers(binding._immutableSamplers),
 	_mtlResourceIndexOffsets(binding._mtlResourceIndexOffsets) {
 
-	for (uint32_t i = kMVKShaderStageVertex; i < kMVKShaderStageMax; i++) {
+	for (uint32_t i = kMVKShaderStageVertex; i < kMVKShaderStageCount; i++) {
         _applyToStage[i] = binding._applyToStage[i];
     }
 	for (MVKSampler* sampler : _immutableSamplers) {
@@ -434,10 +618,21 @@
 void MVKDescriptorSetLayoutBinding::initMetalResourceIndexOffsets(MVKShaderStageResourceBinding* pBindingIndexes,
 																  MVKShaderStageResourceBinding* pDescSetCounts,
 																  const VkDescriptorSetLayoutBinding* pBinding) {
+
+	// Sets an index offset and updates both that index and the general resource index.
+	// Can be used multiply for combined multi-resource descriptor types.
+#	define setResourceIndexOffset(rezIdx) \
+	do { \
+		pBindingIndexes->rezIdx = isUsingMetalArgumentBuffer() ?  pDescSetCounts->resourceIndex : pDescSetCounts->rezIdx; \
+		pDescSetCounts->rezIdx += descCnt; \
+		pBindingIndexes->resourceIndex = pDescSetCounts->resourceIndex; \
+		pDescSetCounts->resourceIndex += descCnt; \
+	} while(false)
+
+	uint32_t descCnt = pBinding->descriptorType == VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT ? 1 : pBinding->descriptorCount;
     switch (pBinding->descriptorType) {
         case VK_DESCRIPTOR_TYPE_SAMPLER:
-            pBindingIndexes->samplerIndex = pDescSetCounts->samplerIndex;
-            pDescSetCounts->samplerIndex += pBinding->descriptorCount;
+			setResourceIndexOffset(samplerIndex);
 
 			if (pBinding->descriptorCount > 1 && !_device->_pMetalFeatures->arrayOfSamplers) {
 				_layout->setConfigurationResult(reportError(VK_ERROR_FEATURE_NOT_PRESENT, "Device %s does not support arrays of samplers.", _device->getName()));
@@ -445,10 +640,8 @@
             break;
 
         case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
-            pBindingIndexes->textureIndex = pDescSetCounts->textureIndex;
-            pDescSetCounts->textureIndex += pBinding->descriptorCount;
-            pBindingIndexes->samplerIndex = pDescSetCounts->samplerIndex;
-            pDescSetCounts->samplerIndex += pBinding->descriptorCount;
+			setResourceIndexOffset(textureIndex);
+			setResourceIndexOffset(samplerIndex);
 
 			if (pBinding->descriptorCount > 1) {
 				if ( !_device->_pMetalFeatures->arrayOfTextures ) {
@@ -474,14 +667,12 @@
 
         case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
         case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
-            pBindingIndexes->bufferIndex = pDescSetCounts->bufferIndex;
-            pDescSetCounts->bufferIndex += pBinding->descriptorCount;
+			setResourceIndexOffset(bufferIndex);
             // fallthrough
         case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
         case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
         case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
-            pBindingIndexes->textureIndex = pDescSetCounts->textureIndex;
-            pDescSetCounts->textureIndex += pBinding->descriptorCount;
+			setResourceIndexOffset(textureIndex);
 
 			if (pBinding->descriptorCount > 1 && !_device->_pMetalFeatures->arrayOfTextures) {
 				_layout->setConfigurationResult(reportError(VK_ERROR_FEATURE_NOT_PRESENT, "Device %s does not support arrays of textures.", _device->getName()));
@@ -492,13 +683,8 @@
         case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
         case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
         case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
-            pBindingIndexes->bufferIndex = pDescSetCounts->bufferIndex;
-            pDescSetCounts->bufferIndex += pBinding->descriptorCount;
-            break;
-
-        case VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT:
-            pBindingIndexes->bufferIndex = pDescSetCounts->bufferIndex;
-            pDescSetCounts->bufferIndex += 1;
+		case VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT:
+			setResourceIndexOffset(bufferIndex);
             break;
 
         default:
@@ -508,10 +694,36 @@
 
 
 #pragma mark -
+#pragma mark MVKDescriptor
+
+MTLResourceUsage MVKDescriptor::getMTLResourceUsage() {
+	MTLResourceUsage mtlUsage = MTLResourceUsageRead;
+	switch (getDescriptorType()) {
+		case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
+		case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
+			mtlUsage |= MTLResourceUsageSample;
+			break;
+
+		case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
+		case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
+		case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
+		case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
+			mtlUsage |= MTLResourceUsageWrite;
+			break;
+
+		default:
+			break;
+	}
+	return mtlUsage;
+}
+
+
+#pragma mark -
 #pragma mark MVKBufferDescriptor
 
 // A null cmdEncoder can be passed to perform a validation pass
 void MVKBufferDescriptor::bind(MVKCommandEncoder* cmdEncoder,
+							   MVKDescriptorSetLayoutBinding* mvkDSLBind,
 							   uint32_t descriptorIndex,
 							   bool stages[],
 							   MVKShaderResourceBinding& mtlIndexes,
@@ -534,20 +746,33 @@
 		else
 			bb.size = (uint32_t)_buffRange;
 	}
-	for (uint32_t i = kMVKShaderStageVertex; i < kMVKShaderStageMax; i++) {
-		if (stages[i]) {
-			bb.index = mtlIndexes.stages[i].bufferIndex + descriptorIndex;
-			if (i == kMVKShaderStageCompute) {
-				if (cmdEncoder) { cmdEncoder->_computeResourcesState.bindBuffer(bb); }
-			} else {
-				if (cmdEncoder) { cmdEncoder->_graphicsResourcesState.bindBuffer(MVKShaderStage(i), bb); }
+
+	// Update the Metal argument buffer entry with the dynamic offset
+	if (descType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC || descType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC) {
+		mvkDSLBind->writeToMetalArgumentBuffer(bb.mtlBuffer, bb.offset, descriptorIndex);
+	}
+
+	if (mvkDSLBind->isUsingMetalArgumentBuffer()) {
+		MVKMTLArgumentBufferResourceUsage abru;
+		abru.mtlResource = bb.mtlResource;
+		abru.mtlUsage = getMTLResourceUsage();
+		abru.mtlStages = mvkMTLRenderStagesFromMVKShaderStages(stages);
+		if (cmdEncoder) { cmdEncoder->useArgumentBufferResource(abru, stages[kMVKShaderStageCompute]); }
+	} else {
+		// If not using Metal argument buffer, bind discretely
+		for (uint32_t i = kMVKShaderStageVertex; i < kMVKShaderStageCount; i++) {
+			if (stages[i]) {
+				bb.index = mtlIndexes.stages[i].bufferIndex + descriptorIndex;
+				if (cmdEncoder) { cmdEncoder->bindBuffer(bb, MVKShaderStage(i)); }
 			}
 		}
 	}
 }
 
-void MVKBufferDescriptor::write(MVKDescriptorSet* mvkDescSet,
+void MVKBufferDescriptor::write(MVKDescriptorSetLayoutBinding* mvkDSLBind,
+								MVKDescriptorSet* descSet,
 								uint32_t srcIndex,
+								uint32_t dstIndex,
 								size_t stride,
 								const void* pData) {
 	auto* oldBuff = _mvkBuffer;
@@ -559,10 +784,14 @@
 
 	if (_mvkBuffer) { _mvkBuffer->retain(); }
 	if (oldBuff) { oldBuff->release(); }
+
+	// Update the Metal argument buffer entry
+	id<MTLBuffer> mtlBuffer = _mvkBuffer ? _mvkBuffer->getMTLBuffer() : nil;
+	NSUInteger mtlBuffOffset = _mvkBuffer ? _mvkBuffer->getMTLBufferOffset() + _buffOffset : 0;
+	mvkDSLBind->writeToMetalArgumentBuffer(mtlBuffer, mtlBuffOffset, dstIndex);
 }
 
-void MVKBufferDescriptor::read(MVKDescriptorSet* mvkDescSet,
-							   uint32_t dstIndex,
+void MVKBufferDescriptor::read(uint32_t dstIndex,
 							   VkDescriptorImageInfo* pImageInfo,
 							   VkDescriptorBufferInfo* pBufferInfo,
 							   VkBufferView* pTexelBufferView,
@@ -587,66 +816,120 @@
 
 // A null cmdEncoder can be passed to perform a validation pass
 void MVKInlineUniformBlockDescriptor::bind(MVKCommandEncoder* cmdEncoder,
+										   MVKDescriptorSetLayoutBinding* mvkDSLBind,
 										   uint32_t descriptorIndex,
 										   bool stages[],
 										   MVKShaderResourceBinding& mtlIndexes,
 										   MVKArrayRef<uint32_t> dynamicOffsets,
 										   uint32_t& dynamicOffsetIndex) {
-	MVKMTLBufferBinding bb;
-	bb.mtlBytes = _buffer;
-	bb.size = _length;
-	bb.isInline = true;
-	for (uint32_t i = kMVKShaderStageVertex; i < kMVKShaderStageMax; i++) {
-		if (stages[i]) {
-			bb.index = mtlIndexes.stages[i].bufferIndex;
-			if (i == kMVKShaderStageCompute) {
-				if (cmdEncoder) { cmdEncoder->_computeResourcesState.bindBuffer(bb); }
-			} else {
-				if (cmdEncoder) { cmdEncoder->_graphicsResourcesState.bindBuffer(MVKShaderStage(i), bb); }
+
+	if (mvkDSLBind->isUsingMetalArgumentBuffer()) {
+		if (cmdEncoder && _isUsingIntermediaryMTLBuffer) {
+			MVKMTLArgumentBufferResourceUsage abru;
+			abru.mtlResource = ((MVKMTLBufferAllocation*)_buffer)->_mtlBuffer;
+			abru.mtlUsage = getMTLResourceUsage();
+			abru.mtlStages = mvkMTLRenderStagesFromMVKShaderStages(stages);
+			cmdEncoder->useArgumentBufferResource(abru, stages[kMVKShaderStageCompute]);
+		}
+	} else {
+		// If not using Metal argument buffer, bind discretely
+		MVKMTLBufferBinding bb;
+		bb.mtlBytes = getData();
+		bb.size = _length;
+		bb.isInline = true;
+		for (uint32_t i = kMVKShaderStageVertex; i < kMVKShaderStageCount; i++) {
+			if (stages[i]) {
+				bb.index = mtlIndexes.stages[i].bufferIndex;
+				if (cmdEncoder) { cmdEncoder->bindBuffer(bb, MVKShaderStage(i)); }
 			}
 		}
 	}
 }
 
-void MVKInlineUniformBlockDescriptor::write(MVKDescriptorSet* mvkDescSet,
+void MVKInlineUniformBlockDescriptor::write(MVKDescriptorSetLayoutBinding* mvkDSLBind,
+											MVKDescriptorSet* descSet,
                                             uint32_t dstOffset,
+											uint32_t dstIndex,
                                             size_t stride,
                                             const void* pData) {
+	// Ensure there is a destination to write to
+	if ( !_buffer ) {
+		_length = mvkDSLBind->_info.descriptorCount;
+		_isUsingIntermediaryMTLBuffer = mvkDSLBind->supportsMetalArgumentBuffers() && !shouldEmbedInlineBlocksInMetalAgumentBuffer();
+		if (_isUsingIntermediaryMTLBuffer) {
+			// Acquire an intermediary buffer and write it to the Metal argument buffer
+			auto* mtlBuffRgn = descSet->acquireMTLBufferRegion(_length);
+			_buffer = (void*)mtlBuffRgn;
+			mvkDSLBind->writeToMetalArgumentBuffer(mtlBuffRgn->_mtlBuffer, mtlBuffRgn->_offset, dstIndex);
+		} else {
+			_buffer = malloc(_length);
+		}
+	}
+
 	const auto& pInlineUniformBlock = *(VkWriteDescriptorSetInlineUniformBlockEXT*)pData;
-	if (pInlineUniformBlock.pData && _buffer) {
-		memcpy(_buffer + dstOffset, pInlineUniformBlock.pData, pInlineUniformBlock.dataSize);
+	uint8_t* data = getData();
+	if (data && pInlineUniformBlock.pData && dstOffset < _length) {
+		uint32_t dataLen = std::min(pInlineUniformBlock.dataSize, _length - dstOffset);
+		memcpy(data + dstOffset, pInlineUniformBlock.pData, dataLen);
+
+		// If using intermediary buffer, it only needs to be written to Metal argument buffer once.
+		// If writing content directly to Metal argument buffer, update that content.
+		if ( !_isUsingIntermediaryMTLBuffer ) {
+			mvkDSLBind->writeToMetalArgumentBuffer((uint8_t*)pInlineUniformBlock.pData, dstOffset, dataLen);
+		}
 	}
 }
 
-void MVKInlineUniformBlockDescriptor::read(MVKDescriptorSet* mvkDescSet,
-                                           uint32_t srcOffset,
+void MVKInlineUniformBlockDescriptor::read(uint32_t srcOffset,
                                            VkDescriptorImageInfo* pImageInfo,
                                            VkDescriptorBufferInfo* pBufferInfo,
                                            VkBufferView* pTexelBufferView,
                                            VkWriteDescriptorSetInlineUniformBlockEXT* pInlineUniformBlock) {
-	if (_buffer && pInlineUniformBlock->pData) {
-		memcpy((void*)pInlineUniformBlock->pData, _buffer + srcOffset, pInlineUniformBlock->dataSize);
+	uint8_t* data = getData();
+	if (data && pInlineUniformBlock->pData && srcOffset < _length) {
+		uint32_t dataLen = std::min(pInlineUniformBlock->dataSize, _length - srcOffset);
+		memcpy((void*)pInlineUniformBlock->pData, data + srcOffset, dataLen);
 	}
 }
 
-void MVKInlineUniformBlockDescriptor::setLayout(MVKDescriptorSetLayoutBinding* dslBinding, uint32_t index) {
-    _length = dslBinding->_info.descriptorCount;
-    _buffer = (uint8_t*)malloc(_length);
-}
-
 void MVKInlineUniformBlockDescriptor::reset() {
-    free(_buffer);
+	if (_isUsingIntermediaryMTLBuffer) {
+		if (_buffer) { ((MVKMTLBufferAllocation*)_buffer)->returnToPool(); }
+	} else {
+		free(_buffer);
+	}
 	_buffer = nullptr;
     _length = 0;
+	_isUsingIntermediaryMTLBuffer = false;
 	MVKDescriptor::reset();
 }
 
+uint8_t* MVKInlineUniformBlockDescriptor::getData() {
+	return (uint8_t*)((_isUsingIntermediaryMTLBuffer && _buffer) ? ((MVKMTLBufferAllocation*)_buffer)->getContents() : _buffer);
+}
+
+// We do this once lazily instead of in a library constructor function to
+// ensure the NSProcessInfo environment is available when called upon.
+bool MVKInlineUniformBlockDescriptor::shouldEmbedInlineBlocksInMetalAgumentBuffer() {
+#	ifndef MVK_CONFIG_EMBED_INLINE_BLOCKS_IN_METAL_ARGUMENT_BUFFER
+#   	define MVK_CONFIG_EMBED_INLINE_BLOCKS_IN_METAL_ARGUMENT_BUFFER    0
+#	endif
+	static bool _shouldEmbedInlineBlocksInMetalAgumentBuffer = MVK_CONFIG_EMBED_INLINE_BLOCKS_IN_METAL_ARGUMENT_BUFFER;
+	static bool _shouldEmbedInlineBlocksInMetalAgumentBufferInitialized = false;
+	if ( !_shouldEmbedInlineBlocksInMetalAgumentBufferInitialized ) {
+		_shouldEmbedInlineBlocksInMetalAgumentBufferInitialized = true;
+		MVK_SET_FROM_ENV_OR_BUILD_BOOL(_shouldEmbedInlineBlocksInMetalAgumentBuffer, MVK_CONFIG_EMBED_INLINE_BLOCKS_IN_METAL_ARGUMENT_BUFFER);
+	}
+	return _shouldEmbedInlineBlocksInMetalAgumentBuffer;
+}
+
 
 #pragma mark -
 #pragma mark MVKImageDescriptor
 
 // A null cmdEncoder can be passed to perform a validation pass
 void MVKImageDescriptor::bind(MVKCommandEncoder* cmdEncoder,
+							  MVKDescriptorSetLayoutBinding* mvkDSLBind,
 							  uint32_t descriptorIndex,
 							  bool stages[],
 							  MVKShaderResourceBinding& mtlIndexes,
@@ -654,7 +937,7 @@
 							  uint32_t& dynamicOffsetIndex) {
 
 	VkDescriptorType descType = getDescriptorType();
-	uint8_t planeCount = (_mvkImageView) ? _mvkImageView->getPlaneCount() : 1;
+	uint8_t planeCount = _mvkImageView ? _mvkImageView->getPlaneCount() : 1;
     for (uint8_t planeIndex = 0; planeIndex < planeCount; planeIndex++) {
         MVKMTLTextureBinding tb;
         MVKMTLBufferBinding bb;
@@ -672,29 +955,39 @@
             bb.offset = mtlTex.bufferOffset;
             bb.size = (uint32_t)(mtlTex.height * mtlTex.bufferBytesPerRow);
         }
-        for (uint32_t i = kMVKShaderStageVertex; i < kMVKShaderStageMax; i++) {
-            if (stages[i]) {
-                tb.index = mtlIndexes.stages[i].textureIndex + descriptorIndex + planeIndex;
-                if (i == kMVKShaderStageCompute) {
-                    if (cmdEncoder) { cmdEncoder->_computeResourcesState.bindTexture(tb); }
-                } else {
-                    if (cmdEncoder) { cmdEncoder->_graphicsResourcesState.bindTexture(MVKShaderStage(i), tb); }
-                }
-                if (descType == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE) {
-                    bb.index = mtlIndexes.stages[i].bufferIndex + descriptorIndex + planeIndex;
-                    if (i == kMVKShaderStageCompute) {
-                        if (cmdEncoder) { cmdEncoder->_computeResourcesState.bindBuffer(bb); }
-                    } else {
-                        if (cmdEncoder) { cmdEncoder->_graphicsResourcesState.bindBuffer(MVKShaderStage(i), bb); }
-                    }
-                }
-            }
-        }
+
+		if (mvkDSLBind->isUsingMetalArgumentBuffer()) {
+			MVKMTLArgumentBufferResourceUsage abru;
+			abru.mtlResource = tb.mtlResource;
+			abru.mtlUsage = getMTLResourceUsage();
+			abru.mtlStages = mvkMTLRenderStagesFromMVKShaderStages(stages);
+			if (cmdEncoder) { cmdEncoder->useArgumentBufferResource(abru, stages[kMVKShaderStageCompute]); }
+
+// Needed for atomic operations
+//			if (descType == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE) {
+//				abru.mtlResource = bb.mtlResource;
+//				if (cmdEncoder) { cmdEncoder->useArgumentBufferResource(abru, stages[kMVKShaderStageCompute]); }
+//			}
+		} else {
+			// If not using Metal argument buffer, bind discretely
+			for (uint32_t i = kMVKShaderStageVertex; i < kMVKShaderStageCount; i++) {
+				if (stages[i]) {
+					tb.index = mtlIndexes.stages[i].textureIndex + (descriptorIndex * planeCount) + planeIndex;
+					if (cmdEncoder) { cmdEncoder->bindTexture(tb, MVKShaderStage(i)); }
+					if (descType == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE) {
+						bb.index = mtlIndexes.stages[i].bufferIndex + (descriptorIndex * planeCount) + planeIndex;
+						if (cmdEncoder) { cmdEncoder->bindBuffer(bb, MVKShaderStage(i)); }
+					}
+				}
+			}
+		}
     }
 }
 
-void MVKImageDescriptor::write(MVKDescriptorSet* mvkDescSet,
+void MVKImageDescriptor::write(MVKDescriptorSetLayoutBinding* mvkDSLBind,
+							   MVKDescriptorSet* descSet,
 							   uint32_t srcIndex,
+							   uint32_t dstIndex,
 							   size_t stride,
 							   const void* pData) {
 	auto* oldImgView = _mvkImageView;
@@ -705,10 +998,23 @@
 
 	if (_mvkImageView) { _mvkImageView->retain(); }
 	if (oldImgView) { oldImgView->release(); }
+
+	// Update the Metal argument buffer entry
+	uint8_t planeCount = _mvkImageView ? _mvkImageView->getPlaneCount() : 1;
+	for (uint8_t planeIndex = 0; planeIndex < planeCount; planeIndex++) {
+		id<MTLTexture> mtlTexture = _mvkImageView ? _mvkImageView->getMTLTexture(planeIndex) : nil;
+		mvkDSLBind->writeToMetalArgumentBuffer(mtlTexture, planeCount, planeIndex, dstIndex);
+
+// Needed for atomic operations
+//		if (getDescriptorType() == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE) {
+//			id<MTLTexture> baseMTLTex = mtlTexture.parentTexture ? mtlTexture.parentTexture : mtlTexture;
+//			uint32_t buffArgIdx = mvkDSLBind->getDescriptorCount() * planeCount + dstIndex;
+//			mvkDSLBind->writeToMetalArgumentBuffer(baseMTLTex.buffer, baseMTLTex.bufferOffset, buffArgIdx);
+//		}
+	}
 }
 
-void MVKImageDescriptor::read(MVKDescriptorSet* mvkDescSet,
-							  uint32_t dstIndex,
+void MVKImageDescriptor::read(uint32_t dstIndex,
 							  VkDescriptorImageInfo* pImageInfo,
 							  VkDescriptorBufferInfo* pBufferInfo,
 							  VkBufferView* pTexelBufferView,
@@ -733,29 +1039,38 @@
 // Metal validation requires each sampler in an array of samplers to be populated,
 // even if not used, so populate a default if one hasn't been set.
 void MVKSamplerDescriptorMixin::bind(MVKCommandEncoder* cmdEncoder,
+									 MVKDescriptorSetLayoutBinding* mvkDSLBind,
 									 uint32_t descriptorIndex,
 									 bool stages[],
 									 MVKShaderResourceBinding& mtlIndexes,
 									 MVKArrayRef<uint32_t> dynamicOffsets,
 									 uint32_t& dynamicOffsetIndex) {
-	MVKMTLSamplerStateBinding sb;
-	sb.mtlSamplerState = (_mvkSampler
-						  ? _mvkSampler->getMTLSamplerState()
-						  : cmdEncoder->getDevice()->getDefaultMTLSamplerState());
-	for (uint32_t i = kMVKShaderStageVertex; i < kMVKShaderStageMax; i++) {
-		if (stages[i]) {
-			sb.index = mtlIndexes.stages[i].samplerIndex + descriptorIndex;
-			if (i == kMVKShaderStageCompute) {
-				if (cmdEncoder) { cmdEncoder->_computeResourcesState.bindSamplerState(sb); }
-			} else {
-				if (cmdEncoder) { cmdEncoder->_graphicsResourcesState.bindSamplerState(MVKShaderStage(i), sb); }
+
+	if (mvkDSLBind->isUsingMetalArgumentBuffer()) {
+		// Write any immutable sampler to the argument buffer now
+		if ( !_hasDynamicSampler ) {
+			id<MTLSamplerState> mtlSampler = _mvkSampler ? _mvkSampler->getMTLSamplerState() : nil;
+			uint32_t argBuffIdx = getSamplerArgBufferIndexOffset(mvkDSLBind) + descriptorIndex;
+			mvkDSLBind->writeToMetalArgumentBuffer(mtlSampler, argBuffIdx);
+		}
+	} else {
+		MVKMTLSamplerStateBinding sb;
+		sb.mtlSamplerState = (_mvkSampler
+							  ? _mvkSampler->getMTLSamplerState()
+							  : cmdEncoder->getDevice()->getDefaultMTLSamplerState());
+		for (uint32_t i = kMVKShaderStageVertex; i < kMVKShaderStageCount; i++) {
+			if (stages[i]) {
+				sb.index = mtlIndexes.stages[i].samplerIndex + descriptorIndex;
+				if (cmdEncoder) { cmdEncoder->bindSamplerState(sb, MVKShaderStage(i)); }
 			}
 		}
 	}
 }
 
-void MVKSamplerDescriptorMixin::write(MVKDescriptorSet* mvkDescSet,
+void MVKSamplerDescriptorMixin::write(MVKDescriptorSetLayoutBinding* mvkDSLBind,
+									  MVKDescriptorSet* descSet,
 									  uint32_t srcIndex,
+									  uint32_t dstIndex,
 									  size_t stride,
 									  const void* pData) {
 	if (_hasDynamicSampler) {
@@ -769,11 +1084,15 @@
 
 		if (_mvkSampler) { _mvkSampler->retain(); }
 		if (oldSamp) { oldSamp->release(); }
+
+		// Update the Metal argument buffer entry
+		id<MTLSamplerState> mtlSampler = _mvkSampler ? _mvkSampler->getMTLSamplerState() : nil;
+		uint32_t argBuffIdx = getSamplerArgBufferIndexOffset(mvkDSLBind) + dstIndex;
+		mvkDSLBind->writeToMetalArgumentBuffer(mtlSampler, argBuffIdx);
 	}
 }
 
-void MVKSamplerDescriptorMixin::read(MVKDescriptorSet* mvkDescSet,
-									 uint32_t dstIndex,
+void MVKSamplerDescriptorMixin::read(uint32_t dstIndex,
 									 VkDescriptorImageInfo* pImageInfo,
 									 VkDescriptorBufferInfo* pBufferInfo,
 									 VkBufferView* pTexelBufferView,
@@ -806,28 +1125,30 @@
 
 // A null cmdEncoder can be passed to perform a validation pass
 void MVKSamplerDescriptor::bind(MVKCommandEncoder* cmdEncoder,
+								MVKDescriptorSetLayoutBinding* mvkDSLBind,
 								uint32_t descriptorIndex,
 								bool stages[],
 								MVKShaderResourceBinding& mtlIndexes,
 								MVKArrayRef<uint32_t> dynamicOffsets,
 								uint32_t& dynamicOffsetIndex) {
-	MVKSamplerDescriptorMixin::bind(cmdEncoder, descriptorIndex, stages, mtlIndexes, dynamicOffsets, dynamicOffsetIndex);
+	MVKSamplerDescriptorMixin::bind(cmdEncoder, mvkDSLBind, descriptorIndex, stages, mtlIndexes, dynamicOffsets, dynamicOffsetIndex);
 }
 
-void MVKSamplerDescriptor::write(MVKDescriptorSet* mvkDescSet,
+void MVKSamplerDescriptor::write(MVKDescriptorSetLayoutBinding* mvkDSLBind,
+								 MVKDescriptorSet* descSet,
 								 uint32_t srcIndex,
+								 uint32_t dstIndex,
 								 size_t stride,
 								 const void* pData) {
-	MVKSamplerDescriptorMixin::write(mvkDescSet, srcIndex, stride, pData);
+	MVKSamplerDescriptorMixin::write(mvkDSLBind, descSet, srcIndex, dstIndex, stride, pData);
 }
 
-void MVKSamplerDescriptor::read(MVKDescriptorSet* mvkDescSet,
-								uint32_t dstIndex,
+void MVKSamplerDescriptor::read(uint32_t dstIndex,
 								VkDescriptorImageInfo* pImageInfo,
 								VkDescriptorBufferInfo* pBufferInfo,
 								VkBufferView* pTexelBufferView,
 								VkWriteDescriptorSetInlineUniformBlockEXT* pInlineUniformBlock) {
-	MVKSamplerDescriptorMixin::read(mvkDescSet, dstIndex, pImageInfo, pBufferInfo, pTexelBufferView, pInlineUniformBlock);
+	MVKSamplerDescriptorMixin::read(dstIndex, pImageInfo, pBufferInfo, pTexelBufferView, pInlineUniformBlock);
 }
 
 void MVKSamplerDescriptor::setLayout(MVKDescriptorSetLayoutBinding* dslBinding, uint32_t index) {
@@ -846,31 +1167,33 @@
 
 // A null cmdEncoder can be passed to perform a validation pass
 void MVKCombinedImageSamplerDescriptor::bind(MVKCommandEncoder* cmdEncoder,
+											 MVKDescriptorSetLayoutBinding* mvkDSLBind,
 											 uint32_t descriptorIndex,
 											 bool stages[],
 											 MVKShaderResourceBinding& mtlIndexes,
 											 MVKArrayRef<uint32_t> dynamicOffsets,
 											 uint32_t& dynamicOffsetIndex) {
-	MVKImageDescriptor::bind(cmdEncoder, descriptorIndex, stages, mtlIndexes, dynamicOffsets, dynamicOffsetIndex);
-	MVKSamplerDescriptorMixin::bind(cmdEncoder, descriptorIndex, stages, mtlIndexes, dynamicOffsets, dynamicOffsetIndex);
+	MVKImageDescriptor::bind(cmdEncoder, mvkDSLBind, descriptorIndex, stages, mtlIndexes, dynamicOffsets, dynamicOffsetIndex);
+	MVKSamplerDescriptorMixin::bind(cmdEncoder, mvkDSLBind, descriptorIndex, stages, mtlIndexes, dynamicOffsets, dynamicOffsetIndex);
 }
 
-void MVKCombinedImageSamplerDescriptor::write(MVKDescriptorSet* mvkDescSet,
+void MVKCombinedImageSamplerDescriptor::write(MVKDescriptorSetLayoutBinding* mvkDSLBind,
+											  MVKDescriptorSet* descSet,
 											  uint32_t srcIndex,
+											  uint32_t dstIndex,
 											  size_t stride,
 											  const void* pData) {
-	MVKImageDescriptor::write(mvkDescSet, srcIndex, stride, pData);
-	MVKSamplerDescriptorMixin::write(mvkDescSet, srcIndex, stride, pData);
+	MVKImageDescriptor::write(mvkDSLBind, descSet, srcIndex, dstIndex, stride, pData);
+	MVKSamplerDescriptorMixin::write(mvkDSLBind, descSet, srcIndex, dstIndex, stride, pData);
 }
 
-void MVKCombinedImageSamplerDescriptor::read(MVKDescriptorSet* mvkDescSet,
-											 uint32_t dstIndex,
+void MVKCombinedImageSamplerDescriptor::read(uint32_t dstIndex,
 											 VkDescriptorImageInfo* pImageInfo,
 											 VkDescriptorBufferInfo* pBufferInfo,
 											 VkBufferView* pTexelBufferView,
 											 VkWriteDescriptorSetInlineUniformBlockEXT* pInlineUniformBlock) {
-	MVKImageDescriptor::read(mvkDescSet, dstIndex, pImageInfo, pBufferInfo, pTexelBufferView, pInlineUniformBlock);
-	MVKSamplerDescriptorMixin::read(mvkDescSet, dstIndex, pImageInfo, pBufferInfo, pTexelBufferView, pInlineUniformBlock);
+	MVKImageDescriptor::read(dstIndex, pImageInfo, pBufferInfo, pTexelBufferView, pInlineUniformBlock);
+	MVKSamplerDescriptorMixin::read(dstIndex, pImageInfo, pBufferInfo, pTexelBufferView, pInlineUniformBlock);
 }
 
 void MVKCombinedImageSamplerDescriptor::setLayout(MVKDescriptorSetLayoutBinding* dslBinding, uint32_t index) {
@@ -878,6 +1201,11 @@
 	MVKSamplerDescriptorMixin::setLayout(dslBinding, index);
 }
 
+uint32_t MVKCombinedImageSamplerDescriptor::getSamplerArgBufferIndexOffset(MVKDescriptorSetLayoutBinding* dslBinding) {
+	uint8_t planeCount = _mvkImageView ? _mvkImageView->getPlaneCount() : 1;
+	return dslBinding->getDescriptorCount() * planeCount;
+}
+
 void MVKCombinedImageSamplerDescriptor::reset() {
 	MVKSamplerDescriptorMixin::reset();
 	MVKImageDescriptor::reset();
@@ -889,6 +1217,7 @@
 
 // A null cmdEncoder can be passed to perform a validation pass
 void MVKTexelBufferDescriptor::bind(MVKCommandEncoder* cmdEncoder,
+									MVKDescriptorSetLayoutBinding* mvkDSLBind,
 									uint32_t descriptorIndex,
 									bool stages[],
 									MVKShaderResourceBinding& mtlIndexes,
@@ -906,28 +1235,37 @@
 			bb.size = (uint32_t)(mtlTex.height * mtlTex.bufferBytesPerRow);
 		}
 	}
-	for (uint32_t i = kMVKShaderStageVertex; i < kMVKShaderStageMax; i++) {
-		if (stages[i]) {
-			tb.index = mtlIndexes.stages[i].textureIndex + descriptorIndex;
-			if (i == kMVKShaderStageCompute) {
-				if (cmdEncoder) { cmdEncoder->_computeResourcesState.bindTexture(tb); }
-			} else {
-				if (cmdEncoder) { cmdEncoder->_graphicsResourcesState.bindTexture(MVKShaderStage(i), tb); }
-			}
-			if (descType == VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER) {
-				bb.index = mtlIndexes.stages[i].bufferIndex + descriptorIndex;
-				if (i == kMVKShaderStageCompute) {
-					if (cmdEncoder) { cmdEncoder->_computeResourcesState.bindBuffer(bb); }
-				} else {
-					if (cmdEncoder) { cmdEncoder->_graphicsResourcesState.bindBuffer(MVKShaderStage(i), bb); }
+	if (mvkDSLBind->isUsingMetalArgumentBuffer()) {
+		MVKMTLArgumentBufferResourceUsage abru;
+		abru.mtlResource = tb.mtlResource;
+		abru.mtlUsage = getMTLResourceUsage();
+		abru.mtlStages = mvkMTLRenderStagesFromMVKShaderStages(stages);
+		if (cmdEncoder) { cmdEncoder->useArgumentBufferResource(abru, stages[kMVKShaderStageCompute]); }
+
+// Needed for atomic operations
+//		if (descType == VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER) {
+//			abru.mtlResource = bb.mtlResource;
+//			if (cmdEncoder) { cmdEncoder->useArgumentBufferResource(abru, stages[kMVKShaderStageCompute]); }
+//		}
+	} else {
+		// If not using Metal argument buffer, bind discretely
+		for (uint32_t i = kMVKShaderStageVertex; i < kMVKShaderStageCount; i++) {
+			if (stages[i]) {
+				tb.index = mtlIndexes.stages[i].textureIndex + descriptorIndex;
+				if (cmdEncoder) { cmdEncoder->bindTexture(tb, MVKShaderStage(i)); }
+				if (descType == VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER) {
+					bb.index = mtlIndexes.stages[i].bufferIndex + descriptorIndex;
+					if (cmdEncoder) { cmdEncoder->bindBuffer(bb, MVKShaderStage(i)); }
 				}
 			}
 		}
 	}
 }
 
-void MVKTexelBufferDescriptor::write(MVKDescriptorSet* mvkDescSet,
+void MVKTexelBufferDescriptor::write(MVKDescriptorSetLayoutBinding* mvkDSLBind,
+									 MVKDescriptorSet* descSet,
 									 uint32_t srcIndex,
+									 uint32_t dstIndex,
 									 size_t stride,
 									 const void* pData) {
 	auto* oldBuffView = _mvkBufferView;
@@ -937,10 +1275,19 @@
 
 	if (_mvkBufferView) { _mvkBufferView->retain(); }
 	if (oldBuffView) { oldBuffView->release(); }
+
+	// Update the Metal argument buffer entry
+	id<MTLTexture> mtlTexture = _mvkBufferView ? _mvkBufferView->getMTLTexture() : nil;
+	mvkDSLBind->writeToMetalArgumentBuffer(mtlTexture, 1, 0, dstIndex);
+
+// Needed for atomic operations
+//	if (getDescriptorType() == VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER) {
+//		uint32_t buffArgIdx = mvkDSLBind->getDescriptorCount() + dstIndex;
+//		mvkDSLBind->writeToMetalArgumentBuffer(mtlTexture.buffer, mtlTexture.bufferOffset, buffArgIdx);
+//	}
 }
 
-void MVKTexelBufferDescriptor::read(MVKDescriptorSet* mvkDescSet,
-									uint32_t dstIndex,
+void MVKTexelBufferDescriptor::read(uint32_t dstIndex,
 									VkDescriptorImageInfo* pImageInfo,
 									VkDescriptorBufferInfo* pBufferInfo,
 									VkBufferView* pTexelBufferView,
diff --git a/MoltenVK/MoltenVK/GPUObjects/MVKDescriptorSet.h b/MoltenVK/MoltenVK/GPUObjects/MVKDescriptorSet.h
index 6bbf686..e80fe32 100644
--- a/MoltenVK/MoltenVK/GPUObjects/MVKDescriptorSet.h
+++ b/MoltenVK/MoltenVK/GPUObjects/MVKDescriptorSet.h
@@ -20,9 +20,11 @@
 
 #include "MVKDescriptor.h"
 #include "MVKSmallVector.h"
+#include "MVKBitArray.h"
 #include <unordered_set>
 #include <unordered_map>
 #include <vector>
+#include <mutex>
 
 class MVKDescriptorPool;
 class MVKPipelineLayout;
@@ -32,6 +34,13 @@
 #pragma mark -
 #pragma mark MVKDescriptorSetLayout
 
+/** Tracks a MTLArgumentEncoder and its offset into a Metal argument buffer. */
+typedef struct MVKMTLArgumentEncoder {
+	id<MTLArgumentEncoder> mtlArgumentEncoder = nil;
+	NSUInteger argumentBufferOffset = 0;
+	~MVKMTLArgumentEncoder() { [mtlArgumentEncoder release]; }
+} MVKMTLArgumentEncoder;
+
 /** Represents a Vulkan descriptor set layout. */
 class MVKDescriptorSetLayout : public MVKVulkanAPIDeviceObject {
 
@@ -46,6 +55,7 @@
 	/** Encodes this descriptor set layout and the specified descriptor set on the specified command encoder. */
 	void bindDescriptorSet(MVKCommandEncoder* cmdEncoder,
 						   MVKDescriptorSet* descSet,
+						   uint32_t descSetLayoutIndex,
 						   MVKShaderResourceBinding& dslMTLRezIdxOffsets,
 						   MVKArrayRef<uint32_t> dynamicOffsets,
 						   uint32_t& dynamicOffsetIndex);
@@ -69,27 +79,34 @@
                                         uint32_t dslIndex);
 
 	/** Returns true if this layout is for push descriptors only. */
-	bool isPushDescriptorLayout() const { return _isPushDescriptorLayout; }
+	inline bool isPushDescriptorLayout() const { return _isPushDescriptorLayout; }
+
+	/** Returns whether this layout is using an argument buffer. */
+	inline bool isUsingMetalArgumentBuffer() const  { return supportsMetalArgumentBuffers() && !isPushDescriptorLayout(); };
 
 	MVKDescriptorSetLayout(MVKDevice* device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo);
 
 protected:
-
-	friend class MVKDescriptorSetLayoutBinding;
 	friend class MVKPipelineLayout;
-	friend class MVKDescriptorSet;
 	friend class MVKDescriptorPool;
+	friend class MVKDescriptorSetLayoutBinding;
+	friend class MVKDescriptorSet;
 
 	void propagateDebugName() override {}
 	inline uint32_t getDescriptorCount() { return _descriptorCount; }
-	inline uint32_t getDescriptorIndex(uint32_t binding, uint32_t elementIndex = 0) { return _bindingToDescriptorIndex[binding] + elementIndex; }
 	inline MVKDescriptorSetLayoutBinding* getBinding(uint32_t binding) { return &_bindings[_bindingToIndex[binding]]; }
+	inline uint32_t getDescriptorIndex(uint32_t binding, uint32_t elementIndex = 0) { return getBinding(binding)->getDescriptorIndex(elementIndex); }
+	inline NSUInteger getArgumentBufferSize() { return _argumentBufferSize; }
 	const VkDescriptorBindingFlags* getBindingFlags(const VkDescriptorSetLayoutCreateInfo* pCreateInfo);
+	void bindMetalArgumentBuffer(MVKDescriptorSet* descSet);
+	void initMTLArgumentEncoders();
 
 	MVKSmallVector<MVKDescriptorSetLayoutBinding> _bindings;
 	std::unordered_map<uint32_t, uint32_t> _bindingToIndex;
-	std::unordered_map<uint32_t, uint32_t> _bindingToDescriptorIndex;
 	MVKShaderResourceBinding _mtlResourceCounts;
+	MVKMTLArgumentEncoder _argumentEncoder[kMVKShaderStageCount];
+	NSUInteger _argumentBufferSize;
+	std::mutex _argEncodingLock;
 	uint32_t _descriptorCount;
 	bool _isPushDescriptorLayout;
 };
@@ -126,22 +143,29 @@
 			  VkBufferView* pTexelBufferView,
 			  VkWriteDescriptorSetInlineUniformBlockEXT* pInlineUniformBlock);
 
-	MVKDescriptorSet(MVKDescriptorSetLayout* layout,
-					 uint32_t variableDescriptorCount,
-					 MVKDescriptorPool* pool);
+	/** Returns an MTLBuffer region allocation. */
+	const MVKMTLBufferAllocation* acquireMTLBufferRegion(NSUInteger length);
 
-	~MVKDescriptorSet() override;
+	MVKDescriptorSet(MVKDescriptorPool* pool);
 
 protected:
-	friend class MVKDescriptorSetLayoutBinding;
 	friend class MVKDescriptorPool;
+	friend class MVKDescriptorSetLayout;
+	friend class MVKDescriptorSetLayoutBinding;
 
 	void propagateDebugName() override {}
 	MVKDescriptor* getDescriptor(uint32_t binding, uint32_t elementIndex = 0);
+	VkResult allocate(MVKDescriptorSetLayout* layout,
+					  uint32_t variableDescriptorCount,
+					  NSUInteger mtlArgumentBufferOffset);
+	void free(bool isPoolReset);
+	id<MTLBuffer> getMetalArgumentBuffer();
+	inline NSUInteger getMetalArgumentBufferOffset() { return _mtlArgumentBufferOffset; }
 
+	MVKSmallVector<MVKDescriptor*> _descriptors;
 	MVKDescriptorSetLayout* _layout;
 	MVKDescriptorPool* _pool;
-	MVKSmallVector<MVKDescriptor*> _descriptors;
+	NSUInteger _mtlArgumentBufferOffset;
 	uint32_t _variableDescriptorCount;
 };
 
@@ -162,7 +186,7 @@
 								   VkDescriptorType descriptorType);
 
 protected:
-	friend class MVKPreallocatedDescriptors;
+	friend class MVKDescriptorPool;
 
 	VkResult allocateDescriptor(MVKDescriptor** pMVKDesc);
 	bool findDescriptor(uint32_t endIndex, MVKDescriptor** pMVKDesc);
@@ -177,41 +201,6 @@
 
 
 #pragma mark -
-#pragma mark MVKPreallocatedDescriptors
-
-/** Support class for MVKDescriptorPool that holds preallocated instances of all concrete descriptor classes. */
-class MVKPreallocatedDescriptors : public MVKBaseObject {
-
-public:
-
-	/** Returns the Vulkan API opaque object controlling this object. */
-	MVKVulkanAPIObject* getVulkanAPIObject() override { return nullptr; };
-
-	MVKPreallocatedDescriptors(const VkDescriptorPoolCreateInfo* pCreateInfo);
-
-protected:
-	friend class MVKDescriptorPool;
-
-	VkResult allocateDescriptor(VkDescriptorType descriptorType, MVKDescriptor** pMVKDesc);
-	void freeDescriptor(MVKDescriptor* mvkDesc);
-	void reset();
-
-	MVKDescriptorTypePreallocation<MVKUniformBufferDescriptor> _uniformBufferDescriptors;
-	MVKDescriptorTypePreallocation<MVKStorageBufferDescriptor> _storageBufferDescriptors;
-	MVKDescriptorTypePreallocation<MVKUniformBufferDynamicDescriptor> _uniformBufferDynamicDescriptors;
-	MVKDescriptorTypePreallocation<MVKStorageBufferDynamicDescriptor> _storageBufferDynamicDescriptors;
-	MVKDescriptorTypePreallocation<MVKInlineUniformBlockDescriptor> _inlineUniformBlockDescriptors;
-	MVKDescriptorTypePreallocation<MVKSampledImageDescriptor> _sampledImageDescriptors;
-	MVKDescriptorTypePreallocation<MVKStorageImageDescriptor> _storageImageDescriptors;
-	MVKDescriptorTypePreallocation<MVKInputAttachmentDescriptor> _inputAttachmentDescriptors;
-	MVKDescriptorTypePreallocation<MVKSamplerDescriptor> _samplerDescriptors;
-	MVKDescriptorTypePreallocation<MVKCombinedImageSamplerDescriptor> _combinedImageSamplerDescriptors;
-	MVKDescriptorTypePreallocation<MVKUniformTexelBufferDescriptor> _uniformTexelBufferDescriptors;
-	MVKDescriptorTypePreallocation<MVKStorageTexelBufferDescriptor> _storageTexelBufferDescriptors;
-};
-
-
-#pragma mark -
 #pragma mark MVKDescriptorPool
 
 /** Represents a Vulkan descriptor pool. */
@@ -245,13 +234,30 @@
 	void propagateDebugName() override {}
 	VkResult allocateDescriptorSet(MVKDescriptorSetLayout* mvkDSL, uint32_t variableDescriptorCount, VkDescriptorSet* pVKDS);
 	const uint32_t* getVariableDecriptorCounts(const VkDescriptorSetAllocateInfo* pAllocateInfo);
-	void freeDescriptorSet(MVKDescriptorSet* mvkDS);
+	void freeDescriptorSet(MVKDescriptorSet* mvkDS, bool isPoolReset);
 	VkResult allocateDescriptor(VkDescriptorType descriptorType, MVKDescriptor** pMVKDesc);
 	void freeDescriptor(MVKDescriptor* mvkDesc);
+	static NSUInteger getDescriptorByteCountForMetalArgumentBuffer(VkDescriptorType descriptorType);
+	static NSUInteger getMaxInlineBlockSize(MVKDevice* device, const VkDescriptorPoolCreateInfo* pCreateInfo);
 
-	uint32_t _maxSets;
-	std::unordered_set<MVKDescriptorSet*> _allocatedSets;
-	MVKPreallocatedDescriptors* _preallocatedDescriptors;
+	MVKSmallVector<MVKDescriptorSet> _descriptorSets;
+	MVKBitArray _descriptorSetAvailablility;
+	id<MTLBuffer> _mtlArgumentBuffer;
+	NSUInteger _nextMTLArgumentBufferOffset;
+	MVKMTLBufferAllocator _inlineBlockMTLBufferAllocator;
+
+	MVKDescriptorTypePreallocation<MVKUniformBufferDescriptor> _uniformBufferDescriptors;
+	MVKDescriptorTypePreallocation<MVKStorageBufferDescriptor> _storageBufferDescriptors;
+	MVKDescriptorTypePreallocation<MVKUniformBufferDynamicDescriptor> _uniformBufferDynamicDescriptors;
+	MVKDescriptorTypePreallocation<MVKStorageBufferDynamicDescriptor> _storageBufferDynamicDescriptors;
+	MVKDescriptorTypePreallocation<MVKInlineUniformBlockDescriptor> _inlineUniformBlockDescriptors;
+	MVKDescriptorTypePreallocation<MVKSampledImageDescriptor> _sampledImageDescriptors;
+	MVKDescriptorTypePreallocation<MVKStorageImageDescriptor> _storageImageDescriptors;
+	MVKDescriptorTypePreallocation<MVKInputAttachmentDescriptor> _inputAttachmentDescriptors;
+	MVKDescriptorTypePreallocation<MVKSamplerDescriptor> _samplerDescriptors;
+	MVKDescriptorTypePreallocation<MVKCombinedImageSamplerDescriptor> _combinedImageSamplerDescriptors;
+	MVKDescriptorTypePreallocation<MVKUniformTexelBufferDescriptor> _uniformTexelBufferDescriptors;
+	MVKDescriptorTypePreallocation<MVKStorageTexelBufferDescriptor> _storageTexelBufferDescriptors;
 };
 
 
@@ -304,15 +310,3 @@
 void mvkUpdateDescriptorSetWithTemplate(VkDescriptorSet descriptorSet,
 										VkDescriptorUpdateTemplateKHR updateTemplate,
 										const void* pData);
-
-/**
- * If the shader stage binding has a binding defined for the specified stage, populates
- * the context at the descriptor set binding from the shader stage resource binding.
- */
-void mvkPopulateShaderConverterContext(mvk::SPIRVToMSLConversionConfiguration& context,
-									   MVKShaderStageResourceBinding& ssRB,
-									   spv::ExecutionModel stage,
-									   uint32_t descriptorSetIndex,
-									   uint32_t bindingIndex,
-									   uint32_t count,
-									   MVKSampler* immutableSampler);
diff --git a/MoltenVK/MoltenVK/GPUObjects/MVKDescriptorSet.mm b/MoltenVK/MoltenVK/GPUObjects/MVKDescriptorSet.mm
index ed9d5e2..a81c71d 100644
--- a/MoltenVK/MoltenVK/GPUObjects/MVKDescriptorSet.mm
+++ b/MoltenVK/MoltenVK/GPUObjects/MVKDescriptorSet.mm
@@ -17,9 +17,12 @@
  */
 
 #include "MVKDescriptorSet.h"
+#include "MVKCommandBuffer.h"
 #include "MVKInstance.h"
 #include "MVKOSExtensions.h"
 
+using namespace std;
+
 
 #pragma mark -
 #pragma mark MVKDescriptorSetLayout
@@ -27,17 +30,51 @@
 // A null cmdEncoder can be passed to perform a validation pass
 void MVKDescriptorSetLayout::bindDescriptorSet(MVKCommandEncoder* cmdEncoder,
 											   MVKDescriptorSet* descSet,
+											   uint32_t descSetLayoutIndex,
 											   MVKShaderResourceBinding& dslMTLRezIdxOffsets,
 											   MVKArrayRef<uint32_t> dynamicOffsets,
 											   uint32_t& dynamicOffsetIndex) {
 	if (!cmdEncoder) { clearConfigurationResult(); }
-	if ( !_isPushDescriptorLayout ) {
-		for (auto& dslBind : _bindings) {
-			dslBind.bind(cmdEncoder, descSet, dslMTLRezIdxOffsets, dynamicOffsets, dynamicOffsetIndex);
+	if (_isPushDescriptorLayout ) { return; }
+
+	lock_guard<mutex> lock(_argEncodingLock);
+	bindMetalArgumentBuffer(descSet);
+
+	for (auto& dslBind : _bindings) {
+		dslBind.bind(cmdEncoder, descSet, dslMTLRezIdxOffsets, dynamicOffsets, dynamicOffsetIndex);
+	}
+
+	bindMetalArgumentBuffer(nullptr);
+
+	// If we're using Metal argument buffer, bind it to the command encoder in each stage that will use it.
+	if (cmdEncoder) {
+		id<MTLBuffer> mtlArgBuff = descSet->getMetalArgumentBuffer();
+		NSUInteger descSetOffset = descSet->getMetalArgumentBufferOffset();
+		if (mtlArgBuff) {
+			MVKMTLBufferBinding bb;
+			bb.mtlBuffer = mtlArgBuff;
+			bb.index = descSetLayoutIndex;
+			for (uint32_t stage = kMVKShaderStageVertex; stage < kMVKShaderStageCount; stage++) {
+				auto& argEnc = _argumentEncoder[stage];
+				if (argEnc.mtlArgumentEncoder) {
+					bb.offset = descSetOffset + argEnc.argumentBufferOffset;
+					cmdEncoder->bindBuffer(bb, MVKShaderStage(stage));
+				}
+			}
 		}
 	}
 }
 
+void MVKDescriptorSetLayout::bindMetalArgumentBuffer(MVKDescriptorSet* descSet) {
+	id<MTLBuffer> mtlArgBuff = descSet ? descSet->getMetalArgumentBuffer() : nil;
+	NSUInteger descSetOffset = descSet ? descSet->getMetalArgumentBufferOffset() : 0;
+	for (uint32_t stage = kMVKShaderStageVertex; stage < kMVKShaderStageCount; stage++) {
+		auto& argEnc = _argumentEncoder[stage];
+		[argEnc.mtlArgumentEncoder setArgumentBuffer: mtlArgBuff
+											  offset: (descSetOffset + argEnc.argumentBufferOffset)];
+	}
+}
+
 static const void* getWriteParameters(VkDescriptorType type, const VkDescriptorImageInfo* pImageInfo,
                                       const VkDescriptorBufferInfo* pBufferInfo, const VkBufferView* pTexelBufferView,
                                       const VkWriteDescriptorSetInlineUniformBlockEXT* pInlineUniformBlock,
@@ -166,6 +203,11 @@
 	for (uint32_t bindIdx = 0; bindIdx < bindCnt; bindIdx++) {
 		_bindings[bindIdx].populateShaderConverterContext(context, dslMTLRezIdxOffsets, dslIndex);
 	}
+
+	// Mark if Metal argument buffers are in use, but this descriptor set layout is not using them.
+	if (supportsMetalArgumentBuffers() && !isUsingMetalArgumentBuffer()) {
+		context.discreteDescriptorSets.push_back(dslIndex);
+	}
 }
 
 MVKDescriptorSetLayout::MVKDescriptorSetLayout(MVKDevice* device,
@@ -186,20 +228,21 @@
 	for (uint32_t bindIdx = 0; bindIdx < bindCnt; bindIdx++) {
 		sortedBindings.push_back( { &pCreateInfo->pBindings[bindIdx], pBindingFlags ? pBindingFlags[bindIdx] : 0 } );
 	}
-	std::sort(sortedBindings.begin(), sortedBindings.end(), [](BindInfo bindInfo1, BindInfo bindInfo2) {
+	sort(sortedBindings.begin(), sortedBindings.end(), [](BindInfo bindInfo1, BindInfo bindInfo2) {
 		return bindInfo1.pBinding->binding < bindInfo2.pBinding->binding;
 	});
 
-	_isPushDescriptorLayout = (pCreateInfo->flags & VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR) != 0;
+	_isPushDescriptorLayout = mvkIsAnyFlagEnabled(pCreateInfo->flags, VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR);
 	_descriptorCount = 0;
     _bindings.reserve(bindCnt);
     for (uint32_t bindIdx = 0; bindIdx < bindCnt; bindIdx++) {
 		BindInfo& bindInfo = sortedBindings[bindIdx];
-        _bindings.emplace_back(_device, this, bindInfo.pBinding, bindInfo.bindingFlags);
+        _bindings.emplace_back(_device, this, bindInfo.pBinding, bindInfo.bindingFlags, _descriptorCount);
 		_bindingToIndex[bindInfo.pBinding->binding] = bindIdx;
-		_bindingToDescriptorIndex[bindInfo.pBinding->binding] = _descriptorCount;
-		_descriptorCount += _bindings.back().getDescriptorCount(nullptr);
+		_descriptorCount += _bindings.back().getDescriptorCount();
 	}
+
+	initMTLArgumentEncoders();
 }
 
 // Find and return an array of binding flags from the pNext chain of pCreateInfo,
@@ -218,6 +261,32 @@
 	return nullptr;
 }
 
+void MVKDescriptorSetLayout::initMTLArgumentEncoders() {
+	_argumentBufferSize = 0;
+
+	if ( !isUsingMetalArgumentBuffer() ) { return; }
+
+	auto* mvkDvc = getDevice();
+	@autoreleasepool {
+		id<MTLDevice> mtlDvc = mvkDvc->getMTLDevice();
+		NSMutableArray<MTLArgumentDescriptor*>* args = [NSMutableArray arrayWithCapacity: _bindings.size()];
+		for (uint32_t stage = kMVKShaderStageVertex; stage < kMVKShaderStageCount; stage++) {
+			[args removeAllObjects];
+			uint32_t argIdx = 0;
+			for (auto& dslBind : _bindings) {
+				dslBind.addMTLArgumentDescriptors(stage, args, argIdx);
+			}
+			if (args.count) {
+				auto& argEnc = _argumentEncoder[stage];
+				argEnc.mtlArgumentEncoder = [mtlDvc newArgumentEncoderWithArguments: args];		// retained
+				argEnc.argumentBufferOffset = _argumentBufferSize;
+				_argumentBufferSize += mvkAlignByteCount(argEnc.mtlArgumentEncoder.encodedLength,
+														 mvkDvc->_pMetalFeatures->mtlBufferAlignment);
+			}
+		}
+	}
+}
+
 
 #pragma mark -
 #pragma mark MVKDescriptorSet
@@ -230,28 +299,43 @@
 	return _descriptors[_layout->getDescriptorIndex(binding, elementIndex)];
 }
 
+id<MTLBuffer> MVKDescriptorSet::getMetalArgumentBuffer() { return _pool->_mtlArgumentBuffer; }
+
 template<typename DescriptorAction>
 void MVKDescriptorSet::write(const DescriptorAction* pDescriptorAction,
 							 size_t stride,
 							 const void* pData) {
 
-	VkDescriptorType descType = getDescriptorType(pDescriptorAction->dstBinding);
+	lock_guard<mutex> lock(_layout->_argEncodingLock);
+	_layout->bindMetalArgumentBuffer(this);
+
+	MVKDescriptorSetLayoutBinding* mvkDSLBind = _layout->getBinding(pDescriptorAction->dstBinding);
+	VkDescriptorType descType = mvkDSLBind->getDescriptorType();
     if (descType == VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT) {
 		// For inline buffers dstArrayElement is a byte offset
 		MVKDescriptor* mvkDesc = getDescriptor(pDescriptorAction->dstBinding);
 		if (mvkDesc->getDescriptorType() == descType) {
-			mvkDesc->write(this, pDescriptorAction->dstArrayElement, stride, pData);
+			mvkDesc->write(mvkDSLBind, this, pDescriptorAction->dstArrayElement, 0, stride, pData);
 		}
     } else {
-        uint32_t dstStartIdx = _layout->getDescriptorIndex(pDescriptorAction->dstBinding, pDescriptorAction->dstArrayElement);
+		uint32_t descStartIdx = _layout->getDescriptorIndex(pDescriptorAction->dstBinding, pDescriptorAction->dstArrayElement);
 		uint32_t descCnt = pDescriptorAction->descriptorCount;
-        for (uint32_t descIdx = 0; descIdx < descCnt; descIdx++) {
-			MVKDescriptor* mvkDesc = _descriptors[dstStartIdx + descIdx];
+		for (uint32_t srcIdx = 0; srcIdx < descCnt; srcIdx++) {
+			MVKDescriptor* mvkDesc = _descriptors[descStartIdx + srcIdx];
 			if (mvkDesc->getDescriptorType() == descType) {
-				mvkDesc->write(this, descIdx, stride, pData);
+				uint32_t dstIdx = pDescriptorAction->dstArrayElement + srcIdx;
+				mvkDesc->write(mvkDSLBind, this, srcIdx, dstIdx, stride, pData);
 			}
-        }
-    }
+		}
+	}
+
+	// For some unexpected reason, GPU capture on Xcode 12 doesn't always correctly expose
+	// the contents of Metal argument buffers. Triggering an extraction of the arg buffer
+	// contents here, after filling it, seems to correct that.
+	// Sigh. A bug report has been filed with Apple.
+	if (getInstance()->isCurrentlyAutoGPUCapturing()) { [_pool->_mtlArgumentBuffer contents]; }
+
+	_layout->bindMetalArgumentBuffer(nullptr);
 }
 
 // Create concrete implementations of the three variations of the write() function.
@@ -274,26 +358,31 @@
 		// For inline buffers srcArrayElement is a byte offset
 		MVKDescriptor* mvkDesc = getDescriptor(pDescriptorCopy->srcBinding);
 		if (mvkDesc->getDescriptorType() == descType) {
-			mvkDesc->read(this, pDescriptorCopy->srcArrayElement, pImageInfo, pBufferInfo, pTexelBufferView, pInlineUniformBlock);
+			mvkDesc->read(pDescriptorCopy->srcArrayElement, pImageInfo, pBufferInfo, pTexelBufferView, pInlineUniformBlock);
 		}
     } else {
         uint32_t srcStartIdx = _layout->getDescriptorIndex(pDescriptorCopy->srcBinding, pDescriptorCopy->srcArrayElement);
         for (uint32_t descIdx = 0; descIdx < descCnt; descIdx++) {
 			MVKDescriptor* mvkDesc = _descriptors[srcStartIdx + descIdx];
 			if (mvkDesc->getDescriptorType() == descType) {
-				mvkDesc->read(this, descIdx, pImageInfo, pBufferInfo, pTexelBufferView, pInlineUniformBlock);
+				mvkDesc->read(descIdx, pImageInfo, pBufferInfo, pTexelBufferView, pInlineUniformBlock);
 			}
         }
     }
 }
 
-MVKDescriptorSet::MVKDescriptorSet(MVKDescriptorSetLayout* layout,
-								   uint32_t variableDescriptorCount,
-								   MVKDescriptorPool* pool) :
-	MVKVulkanAPIDeviceObject(pool->_device),
-	_layout(layout),
-	_variableDescriptorCount(variableDescriptorCount),
-	_pool(pool) {
+const MVKMTLBufferAllocation* MVKDescriptorSet::acquireMTLBufferRegion(NSUInteger length) {
+	return _pool->_inlineBlockMTLBufferAllocator.acquireMTLBufferRegion(length);
+}
+
+VkResult MVKDescriptorSet::allocate(MVKDescriptorSetLayout* layout,
+									uint32_t variableDescriptorCount,
+									NSUInteger mtlArgumentBufferOffset) {
+	_layout = layout;
+	_variableDescriptorCount = variableDescriptorCount;
+
+	// If the Metal argument buffer offset has not been set yet, set it now.
+	if ( !_mtlArgumentBufferOffset ) { _mtlArgumentBufferOffset = mtlArgumentBufferOffset; }
 
 	_descriptors.reserve(layout->getDescriptorCount());
 	uint32_t bindCnt = (uint32_t)layout->_bindings.size();
@@ -310,10 +399,24 @@
 		}
 		if ( !wasConfigurationSuccessful() ) { break; }
 	}
+	return getConfigurationResult();
 }
 
-MVKDescriptorSet::~MVKDescriptorSet() {
+void MVKDescriptorSet::free(bool isPoolReset) {
+	_layout = nullptr;
+	_variableDescriptorCount = 0;
+
+	// Only reset the Metal arg buffer offset if the entire pool is being reset
+	if (isPoolReset) { _mtlArgumentBufferOffset = 0; }
+
 	for (auto mvkDesc : _descriptors) { _pool->freeDescriptor(mvkDesc); }
+	_descriptors.clear();
+
+	clearConfigurationResult();
+}
+
+MVKDescriptorSet::MVKDescriptorSet(MVKDescriptorPool* pool) : MVKVulkanAPIDeviceObject(pool->_device), _pool(pool) {
+	free(true);
 }
 
 
@@ -321,26 +424,31 @@
 #pragma mark MVKDescriptorTypePreallocation
 
 #ifndef MVK_CONFIG_PREALLOCATE_DESCRIPTORS
-#   define MVK_CONFIG_PREALLOCATE_DESCRIPTORS    0
+#   define MVK_CONFIG_PREALLOCATE_DESCRIPTORS    1
 #endif
 
-static bool _mvkPreallocateDescriptors = MVK_CONFIG_PREALLOCATE_DESCRIPTORS;
-static bool _mvkPreallocateDescriptorsInitialized = false;
-
 // Returns whether descriptors should be preallocated in the descriptor pools
 // We do this once lazily instead of in a library constructor function to
 // ensure the NSProcessInfo environment is available when called upon.
-static inline bool getMVKPreallocateDescriptors() {
-	if ( !_mvkPreallocateDescriptorsInitialized ) {
-		_mvkPreallocateDescriptorsInitialized = true;
-		MVK_SET_FROM_ENV_OR_BUILD_BOOL(_mvkPreallocateDescriptors, MVK_CONFIG_PREALLOCATE_DESCRIPTORS);
+static inline bool mvkShouldPreallocateDescriptors() {
+	static bool _mvkShouldPreallocateDescriptors = MVK_CONFIG_PREALLOCATE_DESCRIPTORS;
+	static bool _mvkShouldPreallocateDescriptorsInitialized = false;
+	if ( !_mvkShouldPreallocateDescriptorsInitialized ) {
+		_mvkShouldPreallocateDescriptorsInitialized = true;
+		MVK_SET_FROM_ENV_OR_BUILD_BOOL(_mvkShouldPreallocateDescriptors, MVK_CONFIG_PREALLOCATE_DESCRIPTORS);
 	}
-	return _mvkPreallocateDescriptors;
+	return _mvkShouldPreallocateDescriptors;
 }
 
 template<class DescriptorClass>
 VkResult MVKDescriptorTypePreallocation<DescriptorClass>::allocateDescriptor(MVKDescriptor** pMVKDesc) {
 
+	// If we don't preallocate, create and return an instance on the fly.
+	if ( !mvkShouldPreallocateDescriptors() ) {
+		*pMVKDesc = new DescriptorClass();
+		return VK_SUCCESS;
+	}
+
 	uint32_t descCnt = (uint32_t)_descriptors.size();
 
 	// Preallocated descriptors that CANNOT be freed.
@@ -389,6 +497,12 @@
 template<typename DescriptorClass>
 void MVKDescriptorTypePreallocation<DescriptorClass>::freeDescriptor(MVKDescriptor* mvkDesc) {
 
+	// If we don't preallocate, create and return an instance on the fly.
+	if ( !mvkShouldPreallocateDescriptors() ) {
+		mvkDesc->destroy();
+		return;
+	}
+
 	mvkDesc->reset();
 
 	if (_supportAvailability) {
@@ -411,29 +525,155 @@
 template<typename DescriptorClass>
 MVKDescriptorTypePreallocation<DescriptorClass>::MVKDescriptorTypePreallocation(const VkDescriptorPoolCreateInfo* pCreateInfo,
 																				VkDescriptorType descriptorType) {
-	// There may be more than  one poolSizeCount instance for the desired VkDescriptorType.
-	// Accumulate the descriptor count for the desired VkDescriptorType, and size the collections accordingly.
-	uint32_t descriptorCount = 0;
-	uint32_t poolCnt = pCreateInfo->poolSizeCount;
-	for (uint32_t poolIdx = 0; poolIdx < poolCnt; poolIdx++) {
-		auto& poolSize = pCreateInfo->pPoolSizes[poolIdx];
-		if (poolSize.type == descriptorType) { descriptorCount += poolSize.descriptorCount; }
-	}
-	_descriptors.resize(descriptorCount);
-
 	// Determine whether we need to track the availability of previously freed descriptors.
 	_supportAvailability = mvkIsAnyFlagEnabled(pCreateInfo->flags, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT);
-	if (_supportAvailability) { _availability.resize(descriptorCount, true); }
 	_nextAvailableIndex = 0;
+
+	if (mvkShouldPreallocateDescriptors()) {
+		// There may be more than  one poolSizeCount instance for the desired VkDescriptorType.
+		// Accumulate the descriptor count for the desired VkDescriptorType, and size the collections accordingly.
+		uint32_t descriptorCount = 0;
+		uint32_t poolCnt = pCreateInfo->poolSizeCount;
+		for (uint32_t poolIdx = 0; poolIdx < poolCnt; poolIdx++) {
+			auto& poolSize = pCreateInfo->pPoolSizes[poolIdx];
+			if (poolSize.type == descriptorType) { descriptorCount += poolSize.descriptorCount; }
+		}
+
+		_descriptors.resize(descriptorCount);
+		if (_supportAvailability) { _availability.resize(descriptorCount, true); }
+	}
 }
 
 
 #pragma mark -
-#pragma mark MVKPreallocatedDescriptors
+#pragma mark MVKDescriptorPool
+
+VkResult MVKDescriptorPool::allocateDescriptorSets(const VkDescriptorSetAllocateInfo* pAllocateInfo,
+												   VkDescriptorSet* pDescriptorSets) {
+	VkResult rslt = VK_SUCCESS;
+	const auto* pVarDescCounts = getVariableDecriptorCounts(pAllocateInfo);
+	for (uint32_t dsIdx = 0; dsIdx < pAllocateInfo->descriptorSetCount; dsIdx++) {
+		MVKDescriptorSetLayout* mvkDSL = (MVKDescriptorSetLayout*)pAllocateInfo->pSetLayouts[dsIdx];
+		if ( !mvkDSL->isPushDescriptorLayout() ) {
+			rslt = allocateDescriptorSet(mvkDSL, (pVarDescCounts ? pVarDescCounts[dsIdx] : 0), &pDescriptorSets[dsIdx]);
+			if (rslt) { break; }
+		}
+	}
+	return rslt;
+}
+
+// Find and return an array of variable descriptor counts from the pNext chain of pCreateInfo,
+// or return nullptr if the chain does not include variable descriptor counts.
+const uint32_t* MVKDescriptorPool::getVariableDecriptorCounts(const VkDescriptorSetAllocateInfo* pAllocateInfo) {
+	for (const auto* next = (VkBaseInStructure*)pAllocateInfo->pNext; next; next = next->pNext) {
+		switch (next->sType) {
+			case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT: {
+				auto* pVarDescSetVarCounts = (VkDescriptorSetVariableDescriptorCountAllocateInfoEXT*)next;
+				return pVarDescSetVarCounts->descriptorSetCount ? pVarDescSetVarCounts->pDescriptorCounts : nullptr;
+			}
+			default:
+				break;
+		}
+	}
+	return nullptr;
+}
+
+// Ensure descriptor set was actually allocated, then return to pool
+VkResult MVKDescriptorPool::freeDescriptorSets(uint32_t count, const VkDescriptorSet* pDescriptorSets) {
+	for (uint32_t dsIdx = 0; dsIdx < count; dsIdx++) {
+		freeDescriptorSet((MVKDescriptorSet*)pDescriptorSets[dsIdx], false);
+	}
+	return VK_SUCCESS;
+}
+
+// Free all descriptor sets.
+VkResult MVKDescriptorPool::reset(VkDescriptorPoolResetFlags flags) {
+	for (auto& mvkDS : _descriptorSets) { freeDescriptorSet(&mvkDS, true); }
+
+	_uniformBufferDescriptors.reset();
+	_storageBufferDescriptors.reset();
+	_uniformBufferDynamicDescriptors.reset();
+	_storageBufferDynamicDescriptors.reset();
+	_inlineUniformBlockDescriptors.reset();
+	_sampledImageDescriptors.reset();
+	_storageImageDescriptors.reset();
+	_inputAttachmentDescriptors.reset();
+	_samplerDescriptors.reset();
+	_combinedImageSamplerDescriptors.reset();
+	_uniformTexelBufferDescriptors.reset();
+	_storageTexelBufferDescriptors.reset();
+
+	_nextMTLArgumentBufferOffset = 0;
+
+	return VK_SUCCESS;
+}
+
+// Retieves the first available descriptor set, and configures it.
+// If none are available, returns an error.
+VkResult MVKDescriptorPool::allocateDescriptorSet(MVKDescriptorSetLayout* mvkDSL,
+												  uint32_t variableDescriptorCount,
+												  VkDescriptorSet* pVKDS) {
+	NSUInteger mtlArgBuffAllocSize = mvkDSL->getArgumentBufferSize();
+	size_t dsCnt = _descriptorSets.size();
+	size_t dsIdx = 0;
+	while (true) {
+		dsIdx = _descriptorSetAvailablility.getIndexOfFirstSetBit(dsIdx, true);
+		if (dsIdx >= dsCnt) { return VK_ERROR_OUT_OF_POOL_MEMORY; }
+
+		bool isSpaceAvail = true;		// If not using Metal arg buffers, space will always be available.
+		MVKDescriptorSet* mvkDS = &_descriptorSets[dsIdx];
+		NSUInteger mtlArgBuffOffset = mvkDS->getMetalArgumentBufferOffset();
+
+		// If the desc set is using a Metal argument buffer, we also need to see if the desc set
+		// will fit in the slot that might already have been allocated for it in the Metal argument
+		// buffer from a previous allocation that was returned. If this pool has been reset recently,
+		// then the desc sets will not have had a Metal argument buffer allocation assigned yet.
+		if (mvkDSL->isUsingMetalArgumentBuffer()) {
+
+			// If the offset has not been set (and it's not the first desc set except
+			// on a reset pool), set the offset and update the next available offset value.
+			if ( !mtlArgBuffOffset && (dsIdx || !_nextMTLArgumentBufferOffset)) {
+				mtlArgBuffOffset = _nextMTLArgumentBufferOffset;
+				_nextMTLArgumentBufferOffset += mtlArgBuffAllocSize;
+			}
+
+			// Get the offset of the next desc set, if one exists and
+			// its offset has been set, or the end of the arg buffer.
+			size_t nextDSIdx = dsIdx + 1;
+			NSUInteger nextOffset = (nextDSIdx < dsCnt ? _descriptorSets[nextDSIdx].getMetalArgumentBufferOffset() : 0);
+			if ( !nextOffset ) { nextOffset = _mtlArgumentBuffer.length; }
+
+			isSpaceAvail = (mtlArgBuffOffset + mtlArgBuffAllocSize) <= nextOffset;
+		}
+
+		if (isSpaceAvail) {
+			mvkDS->allocate(mvkDSL, variableDescriptorCount, mtlArgBuffOffset);
+			if (mvkDS->wasConfigurationSuccessful()) {
+				*pVKDS = (VkDescriptorSet)mvkDS;
+			} else {
+				freeDescriptorSet(mvkDS, false);
+			}
+			return mvkDS->getConfigurationResult();
+		}
+		dsIdx++;	// Skip to next desc set and resume looking
+	}
+}
+
+// Descriptor sets are held in contiguous memory, so the index of the returning descriptor
+// set can be calculated by pointer differences, and it can be marked as available.
+void MVKDescriptorPool::freeDescriptorSet(MVKDescriptorSet* mvkDS, bool isPoolReset) {
+	if ( !mvkDS ) { return; }	// Vulkan allows NULL refs.
+
+	if (mvkDS->_pool != this) { reportError(VK_ERROR_INITIALIZATION_FAILED, "A descriptor set is being returned to a descriptor pool that did not allocate it."); }
+
+	mvkDS->free(isPoolReset);
+	size_t dsIdx = mvkDS - _descriptorSets.data();
+	_descriptorSetAvailablility.setBit(dsIdx);
+}
 
 // Allocate a descriptor of the specified type
-VkResult MVKPreallocatedDescriptors::allocateDescriptor(VkDescriptorType descriptorType,
-														MVKDescriptor** pMVKDesc) {
+VkResult MVKDescriptorPool::allocateDescriptor(VkDescriptorType descriptorType,
+											   MVKDescriptor** pMVKDesc) {
 	switch (descriptorType) {
 		case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
 			return _uniformBufferDescriptors.allocateDescriptor(pMVKDesc);
@@ -476,7 +716,7 @@
 	}
 }
 
-void MVKPreallocatedDescriptors::freeDescriptor(MVKDescriptor* mvkDesc) {
+void MVKDescriptorPool::freeDescriptor(MVKDescriptor* mvkDesc) {
 	VkDescriptorType descriptorType = mvkDesc->getDescriptorType();
 	switch (descriptorType) {
 		case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
@@ -520,22 +760,10 @@
 	}
 }
 
-void MVKPreallocatedDescriptors::reset() {
-	_uniformBufferDescriptors.reset();
-	_storageBufferDescriptors.reset();
-	_uniformBufferDynamicDescriptors.reset();
-	_storageBufferDynamicDescriptors.reset();
-	_inlineUniformBlockDescriptors.reset();
-	_sampledImageDescriptors.reset();
-	_storageImageDescriptors.reset();
-	_inputAttachmentDescriptors.reset();
-	_samplerDescriptors.reset();
-	_combinedImageSamplerDescriptors.reset();
-	_uniformTexelBufferDescriptors.reset();
-	_storageTexelBufferDescriptors.reset();
-}
-
-MVKPreallocatedDescriptors::MVKPreallocatedDescriptors(const VkDescriptorPoolCreateInfo* pCreateInfo) :
+MVKDescriptorPool::MVKDescriptorPool(MVKDevice* device, const VkDescriptorPoolCreateInfo* pCreateInfo) :
+	MVKVulkanAPIDeviceObject(device),
+	_descriptorSets(pCreateInfo->maxSets, MVKDescriptorSet(this)),
+	_descriptorSetAvailablility(pCreateInfo->maxSets, true),
 	_uniformBufferDescriptors(pCreateInfo, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER),
 	_storageBufferDescriptors(pCreateInfo, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER),
 	_uniformBufferDynamicDescriptors(pCreateInfo, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC),
@@ -547,172 +775,84 @@
 	_samplerDescriptors(pCreateInfo, VK_DESCRIPTOR_TYPE_SAMPLER),
 	_combinedImageSamplerDescriptors(pCreateInfo, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER),
 	_uniformTexelBufferDescriptors(pCreateInfo, VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER),
-	_storageTexelBufferDescriptors(pCreateInfo, VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER) {
-}
+	_storageTexelBufferDescriptors(pCreateInfo, VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER),
+	_inlineBlockMTLBufferAllocator(device, getMaxInlineBlockSize(device, pCreateInfo), true) {
 
+	_mtlArgumentBuffer = nil;
+	_nextMTLArgumentBufferOffset = 0;
+	if (supportsMetalArgumentBuffers()) {
+		NSUInteger mtlArgBuffSize = 0;
+		uint32_t poolCnt = pCreateInfo->poolSizeCount;
+		for (uint32_t poolIdx = 0; poolIdx < poolCnt; poolIdx++) {
+			auto& poolSize = pCreateInfo->pPoolSizes[poolIdx];
+			mtlArgBuffSize += getDescriptorByteCountForMetalArgumentBuffer(poolSize.type) * poolSize.descriptorCount;
+		}
+		mtlArgBuffSize += pCreateInfo->maxSets * _device->_pMetalFeatures->mtlBufferAlignment;	// Leave room for each desc set to be aligned
 
-#pragma mark -
-#pragma mark MVKDescriptorPool
+		// Each shader stage uses it's own arg buffer layout. As a result, we need to significantly
+		// overallocate space here, since we don't yet know how the descriptor set layouts will make
+		// use of the descriptors across each pipeline stage. Ideally, the same MVKMTLArgumentEncoder
+		// should be used across all pipeline stages, but that doesn't seem to be possible with present
+		// combination of SPIRV-Cross and Metal behaviour.
+		mtlArgBuffSize *= kMVKShaderStageCount;
 
-VkResult MVKDescriptorPool::allocateDescriptorSets(const VkDescriptorSetAllocateInfo* pAllocateInfo,
-												   VkDescriptorSet* pDescriptorSets) {
-	if (_allocatedSets.size() + pAllocateInfo->descriptorSetCount > _maxSets) {
-		if (_device->_enabledExtensions.vk_KHR_maintenance1.enabled ||
-			_device->getInstance()->getAPIVersion() >= VK_API_VERSION_1_1) {
-			return VK_ERROR_OUT_OF_POOL_MEMORY;		// Failure is an acceptable test...don't log as error.
-		} else {
-			return reportError(VK_ERROR_INITIALIZATION_FAILED, "The maximum number of descriptor sets that can be allocated by this descriptor pool is %d.", _maxSets);
+		if (mtlArgBuffSize) {
+			_mtlArgumentBuffer = [getMTLDevice() newBufferWithLength: mtlArgBuffSize options: MTLResourceStorageModeShared];	// retained
+			_mtlArgumentBuffer.label = @"Argument buffer";
 		}
 	}
-
-	VkResult rslt = VK_SUCCESS;
-	const auto* pVarDescCounts = getVariableDecriptorCounts(pAllocateInfo);
-	for (uint32_t dsIdx = 0; dsIdx < pAllocateInfo->descriptorSetCount; dsIdx++) {
-		MVKDescriptorSetLayout* mvkDSL = (MVKDescriptorSetLayout*)pAllocateInfo->pSetLayouts[dsIdx];
-		if ( !mvkDSL->isPushDescriptorLayout() ) {
-			rslt = allocateDescriptorSet(mvkDSL, (pVarDescCounts ? pVarDescCounts[dsIdx] : 0), &pDescriptorSets[dsIdx]);
-			if (rslt) { break; }
-		}
-	}
-	return rslt;
 }
 
-// Find and return an array of variable descriptor counts from the pNext chain of pCreateInfo,
-// or return nullptr if the chain does not include variable descriptor counts.
-const uint32_t* MVKDescriptorPool::getVariableDecriptorCounts(const VkDescriptorSetAllocateInfo* pAllocateInfo) {
-	for (const auto* next = (VkBaseInStructure*)pAllocateInfo->pNext; next; next = next->pNext) {
-		switch (next->sType) {
-			case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT: {
-				auto* pVarDescSetVarCounts = (VkDescriptorSetVariableDescriptorCountAllocateInfoEXT*)next;
-				return pVarDescSetVarCounts->descriptorSetCount ? pVarDescSetVarCounts->pDescriptorCounts : nullptr;
-			}
-			default:
-				break;
-		}
-	}
-	return nullptr;
-}
-
-// Ensure descriptor set was actually allocated, then return to pool
-VkResult MVKDescriptorPool::freeDescriptorSets(uint32_t count, const VkDescriptorSet* pDescriptorSets) {
-	for (uint32_t dsIdx = 0; dsIdx < count; dsIdx++) {
-		MVKDescriptorSet* mvkDS = (MVKDescriptorSet*)pDescriptorSets[dsIdx];
-		if (_allocatedSets.erase(mvkDS)) {
-			freeDescriptorSet(mvkDS);
-		}
-	}
-	return VK_SUCCESS;
-}
-
-// Destroy all allocated descriptor sets
-VkResult MVKDescriptorPool::reset(VkDescriptorPoolResetFlags flags) {
-	for (auto& mvkDS : _allocatedSets) { freeDescriptorSet(mvkDS); }
-	_allocatedSets.clear();
-	if (_preallocatedDescriptors) { _preallocatedDescriptors->reset(); }
-	return VK_SUCCESS;
-}
-
-VkResult MVKDescriptorPool::allocateDescriptorSet(MVKDescriptorSetLayout* mvkDSL,
-												  uint32_t variableDescriptorCount,
-												  VkDescriptorSet* pVKDS) {
-	MVKDescriptorSet* mvkDS = new MVKDescriptorSet(mvkDSL, variableDescriptorCount, this);
-	VkResult rslt = mvkDS->getConfigurationResult();
-
-	if (mvkDS->wasConfigurationSuccessful()) {
-		_allocatedSets.insert(mvkDS);
-		*pVKDS = (VkDescriptorSet)mvkDS;
-	} else {
-		freeDescriptorSet(mvkDS);
-	}
-	return rslt;
-}
-
-void MVKDescriptorPool::freeDescriptorSet(MVKDescriptorSet* mvkDS) { mvkDS->destroy(); }
-
-// Allocate a descriptor of the specified type
-VkResult MVKDescriptorPool::allocateDescriptor(VkDescriptorType descriptorType,
-											   MVKDescriptor** pMVKDesc) {
-
-	// If descriptors are preallocated allocate from the preallocated pools
-	if (_preallocatedDescriptors) {
-		return _preallocatedDescriptors->allocateDescriptor(descriptorType, pMVKDesc);
-	}
-
-	// Otherwise instantiate one of the appropriate type now
+NSUInteger MVKDescriptorPool::getDescriptorByteCountForMetalArgumentBuffer(VkDescriptorType descriptorType) {
 	switch (descriptorType) {
 		case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
-			*pMVKDesc = new MVKUniformBufferDescriptor();
-			break;
-
-		case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
-			*pMVKDesc = new MVKStorageBufferDescriptor();
-			break;
-
 		case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
-			*pMVKDesc = new MVKUniformBufferDynamicDescriptor();
-			break;
-
+		case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
 		case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
-			*pMVKDesc = new MVKStorageBufferDynamicDescriptor();
-			break;
+			return sizeof(id<MTLBuffer>);
 
 		case VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT:
-			*pMVKDesc = new MVKInlineUniformBlockDescriptor();
-			break;
+			return 1;
 
 		case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
-			*pMVKDesc = new MVKSampledImageDescriptor();
-			break;
+		case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
+		case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
+			return sizeof(id<MTLTexture>);
 
 		case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
-			*pMVKDesc = new MVKStorageImageDescriptor();
-			break;
-
-		case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
-			*pMVKDesc = new MVKInputAttachmentDescriptor();
-			break;
+		case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
+			return sizeof(id<MTLTexture>) + sizeof(id<MTLBuffer>);
 
 		case VK_DESCRIPTOR_TYPE_SAMPLER:
-			*pMVKDesc = new MVKSamplerDescriptor();
-			break;
+			return sizeof(id<MTLSamplerState>);
 
 		case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
-			*pMVKDesc = new MVKCombinedImageSamplerDescriptor();
-			break;
-
-		case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
-			*pMVKDesc = new MVKUniformTexelBufferDescriptor();
-			break;
-
-		case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
-			*pMVKDesc = new MVKStorageTexelBufferDescriptor();
-			break;
+			return sizeof(id<MTLTexture>) + sizeof(id<MTLSamplerState>);
 
 		default:
-			return reportError(VK_ERROR_INITIALIZATION_FAILED, "Unrecognized VkDescriptorType %d.", descriptorType);
-	}
-	return VK_SUCCESS;
-}
-
-// Free a descriptor, either through the preallocated pool, or directly destroy it
-void MVKDescriptorPool::freeDescriptor(MVKDescriptor* mvkDesc) {
-	if (_preallocatedDescriptors) {
-		_preallocatedDescriptors->freeDescriptor(mvkDesc);
-	} else {
-		mvkDesc->destroy();
+			return 0;
 	}
 }
 
-MVKDescriptorPool::MVKDescriptorPool(MVKDevice* device,
-									 const VkDescriptorPoolCreateInfo* pCreateInfo) : MVKVulkanAPIDeviceObject(device) {
-	_maxSets = pCreateInfo->maxSets;
-	_preallocatedDescriptors = getMVKPreallocateDescriptors() ? new MVKPreallocatedDescriptors(pCreateInfo) : nullptr;
+NSUInteger MVKDescriptorPool::getMaxInlineBlockSize(MVKDevice* device, const VkDescriptorPoolCreateInfo* pCreateInfo) {
+	if ( !device->_pMetalFeatures->argumentBuffers || MVKInlineUniformBlockDescriptor::shouldEmbedInlineBlocksInMetalAgumentBuffer()) { return 0; }
+
+	NSUInteger maxInlineBlockSize = 0;
+	uint32_t poolCnt = pCreateInfo->poolSizeCount;
+	for (uint32_t poolIdx = 0; poolIdx < poolCnt; poolIdx++) {
+		auto& poolSize = pCreateInfo->pPoolSizes[poolIdx];
+		if (poolSize.type == VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT) {
+			NSUInteger iubSize = getDescriptorByteCountForMetalArgumentBuffer(poolSize.type) * poolSize.descriptorCount;
+			maxInlineBlockSize = std::max(iubSize, maxInlineBlockSize);
+		}
+	}
+	return std::min<NSUInteger>(maxInlineBlockSize, device->_pMetalFeatures->maxMTLBufferSize);
 }
 
 // Destroy all allocated descriptor sets and preallocated descriptors
 MVKDescriptorPool::~MVKDescriptorPool() {
 	reset(0);
-	if (_preallocatedDescriptors) { _preallocatedDescriptors->destroy(); }
+	[_mtlArgumentBuffer release];
 }
 
 
@@ -819,26 +959,3 @@
 		dstSet->write(pEntry, pEntry->stride, pCurData);
 	}
 }
-
-void mvkPopulateShaderConverterContext(mvk::SPIRVToMSLConversionConfiguration& context,
-									   MVKShaderStageResourceBinding& ssRB,
-									   spv::ExecutionModel stage,
-									   uint32_t descriptorSetIndex,
-									   uint32_t bindingIndex,
-									   uint32_t count,
-									   MVKSampler* immutableSampler) {
-	mvk::MSLResourceBinding rb;
-
-	auto& rbb = rb.resourceBinding;
-	rbb.stage = stage;
-	rbb.desc_set = descriptorSetIndex;
-	rbb.binding = bindingIndex;
-	rbb.count = count;
-	rbb.msl_buffer = ssRB.bufferIndex;
-	rbb.msl_texture = ssRB.textureIndex;
-	rbb.msl_sampler = ssRB.samplerIndex;
-
-	if (immutableSampler) { immutableSampler->getConstexprSampler(rb); }
-
-	context.resourceBindings.push_back(rb);
-}
diff --git a/MoltenVK/MoltenVK/GPUObjects/MVKDevice.h b/MoltenVK/MoltenVK/GPUObjects/MVKDevice.h
index 484db4a..624918a 100644
--- a/MoltenVK/MoltenVK/GPUObjects/MVKDevice.h
+++ b/MoltenVK/MoltenVK/GPUObjects/MVKDevice.h
@@ -819,6 +819,9 @@
 	/** Returns info about the pixel format supported by the physical device. */
 	inline MVKPixelFormats* getPixelFormats() { return _device->getPixelFormats(); }
 
+	/** Returns whether the device supports using Metal argument buffers. */
+	inline bool supportsMetalArgumentBuffers() const  { return _device->_pMetalFeatures->argumentBuffers; };
+
 	/** Constructs an instance for the specified device. */
     MVKDeviceTrackingMixin(MVKDevice* device) : _device(device) { assert(_device); }
 
diff --git a/MoltenVK/MoltenVK/GPUObjects/MVKDevice.mm b/MoltenVK/MoltenVK/GPUObjects/MVKDevice.mm
index 6545444..37a1cb9 100644
--- a/MoltenVK/MoltenVK/GPUObjects/MVKDevice.mm
+++ b/MoltenVK/MoltenVK/GPUObjects/MVKDevice.mm
@@ -377,6 +377,7 @@
                 break;
             }
 			case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT: {
+				bool isTier2 = _metalFeatures.argumentBuffers && _mtlDevice.argumentBuffersSupport == MTLArgumentBuffersTier2;
 				auto* pDescIdxProps = (VkPhysicalDeviceDescriptorIndexingPropertiesEXT*)next;
 				pDescIdxProps->maxUpdateAfterBindDescriptorsInAllPools				= kMVKUndefinedLargeUInt32;
 				pDescIdxProps->shaderUniformBufferArrayNonUniformIndexingNative		= false;
@@ -386,20 +387,20 @@
 				pDescIdxProps->shaderInputAttachmentArrayNonUniformIndexingNative	= _metalFeatures.arrayOfTextures;
 				pDescIdxProps->robustBufferAccessUpdateAfterBind					= _features.robustBufferAccess;
 				pDescIdxProps->quadDivergentImplicitLod								= false;
-				pDescIdxProps->maxPerStageDescriptorUpdateAfterBindSamplers			= _properties.limits.maxPerStageDescriptorSamplers;
-				pDescIdxProps->maxPerStageDescriptorUpdateAfterBindUniformBuffers	= _properties.limits.maxPerStageDescriptorUniformBuffers;
-				pDescIdxProps->maxPerStageDescriptorUpdateAfterBindStorageBuffers	= _properties.limits.maxPerStageDescriptorStorageBuffers;
-				pDescIdxProps->maxPerStageDescriptorUpdateAfterBindSampledImages	= _properties.limits.maxPerStageDescriptorSampledImages;
-				pDescIdxProps->maxPerStageDescriptorUpdateAfterBindStorageImages	= _properties.limits.maxPerStageDescriptorStorageImages;
+				pDescIdxProps->maxPerStageDescriptorUpdateAfterBindSamplers			= isTier2 ? 2048 : _properties.limits.maxPerStageDescriptorSamplers;
+				pDescIdxProps->maxPerStageDescriptorUpdateAfterBindUniformBuffers	= isTier2 ? 500000 : _properties.limits.maxPerStageDescriptorUniformBuffers;
+				pDescIdxProps->maxPerStageDescriptorUpdateAfterBindStorageBuffers	= isTier2 ? 500000 : _properties.limits.maxPerStageDescriptorStorageBuffers;
+				pDescIdxProps->maxPerStageDescriptorUpdateAfterBindSampledImages	= isTier2 ? 500000 : _properties.limits.maxPerStageDescriptorSampledImages;
+				pDescIdxProps->maxPerStageDescriptorUpdateAfterBindStorageImages	= isTier2 ? 500000 : _properties.limits.maxPerStageDescriptorStorageImages;
 				pDescIdxProps->maxPerStageDescriptorUpdateAfterBindInputAttachments	= _properties.limits.maxPerStageDescriptorInputAttachments;
-				pDescIdxProps->maxPerStageUpdateAfterBindResources					= _properties.limits.maxPerStageResources;
-				pDescIdxProps->maxDescriptorSetUpdateAfterBindSamplers				= _properties.limits.maxDescriptorSetSamplers;
-				pDescIdxProps->maxDescriptorSetUpdateAfterBindUniformBuffers		= _properties.limits.maxDescriptorSetUniformBuffers;
-				pDescIdxProps->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic	= _properties.limits.maxDescriptorSetUniformBuffersDynamic;
-				pDescIdxProps->maxDescriptorSetUpdateAfterBindStorageBuffers		= _properties.limits.maxDescriptorSetStorageBuffers;
-				pDescIdxProps->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic	= _properties.limits.maxDescriptorSetStorageBuffersDynamic;
-				pDescIdxProps->maxDescriptorSetUpdateAfterBindSampledImages			= _properties.limits.maxDescriptorSetSampledImages;
-				pDescIdxProps->maxDescriptorSetUpdateAfterBindStorageImages			= _properties.limits.maxDescriptorSetStorageImages;
+				pDescIdxProps->maxPerStageUpdateAfterBindResources					= isTier2 ? 500000 : _properties.limits.maxPerStageResources;
+				pDescIdxProps->maxDescriptorSetUpdateAfterBindSamplers				= isTier2 ? 2048 : _properties.limits.maxDescriptorSetSamplers;
+				pDescIdxProps->maxDescriptorSetUpdateAfterBindUniformBuffers		= isTier2 ? 500000 : _properties.limits.maxDescriptorSetUniformBuffers;
+				pDescIdxProps->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic	= isTier2 ? 500000 : _properties.limits.maxDescriptorSetUniformBuffersDynamic;
+				pDescIdxProps->maxDescriptorSetUpdateAfterBindStorageBuffers		= isTier2 ? 500000 : _properties.limits.maxDescriptorSetStorageBuffers;
+				pDescIdxProps->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic	= isTier2 ? 500000 : _properties.limits.maxDescriptorSetStorageBuffersDynamic;
+				pDescIdxProps->maxDescriptorSetUpdateAfterBindSampledImages			= isTier2 ? 500000 : _properties.limits.maxDescriptorSetSampledImages;
+				pDescIdxProps->maxDescriptorSetUpdateAfterBindStorageImages			= isTier2 ? 500000 : _properties.limits.maxDescriptorSetStorageImages;
 				pDescIdxProps->maxDescriptorSetUpdateAfterBindInputAttachments		= _properties.limits.maxDescriptorSetInputAttachments;
 				break;
 			}
@@ -456,54 +457,51 @@
 // Populates the device ID properties structure
 void MVKPhysicalDevice::populate(VkPhysicalDeviceIDProperties* pDevIdProps) {
 
-	uint8_t* uuid;
 	size_t uuidComponentOffset;
 
 	//  ---- Device ID ----------------------------------------------
-	uuid = pDevIdProps->deviceUUID;
 	uuidComponentOffset = 0;
-	mvkClear(uuid, VK_UUID_SIZE);
+	mvkClear(&pDevIdProps->deviceUUID);
 
 	// First 4 bytes contains GPU vendor ID
 	uint32_t vendorID = _properties.vendorID;
-	*(uint32_t*)&uuid[uuidComponentOffset] = NSSwapHostIntToBig(vendorID);
+	*(uint32_t*)&pDevIdProps->deviceUUID[uuidComponentOffset] = NSSwapHostIntToBig(vendorID);
 	uuidComponentOffset += sizeof(vendorID);
 
 	// Next 4 bytes contains GPU device ID
 	uint32_t deviceID = _properties.deviceID;
-	*(uint32_t*)&uuid[uuidComponentOffset] = NSSwapHostIntToBig(deviceID);
+	*(uint32_t*)&pDevIdProps->deviceUUID[uuidComponentOffset] = NSSwapHostIntToBig(deviceID);
 	uuidComponentOffset += sizeof(deviceID);
 
 	// Last 8 bytes contain the GPU registry ID
 	uint64_t regID = mvkGetRegistryID(_mtlDevice);
-	*(uint64_t*)&uuid[uuidComponentOffset] = NSSwapHostLongLongToBig(regID);
+	*(uint64_t*)&pDevIdProps->deviceUUID[uuidComponentOffset] = NSSwapHostLongLongToBig(regID);
 	uuidComponentOffset += sizeof(regID);
 
 
 	// ---- Driver ID ----------------------------------------------
-	uuid = pDevIdProps->driverUUID;
 	uuidComponentOffset = 0;
-	mvkClear(uuid, VK_UUID_SIZE);
+	mvkClear(&pDevIdProps->driverUUID);
 
 	// First 4 bytes contains MoltenVK prefix
 	const char* mvkPfx = "MVK";
 	size_t mvkPfxLen = strlen(mvkPfx);
-	mvkCopy(&uuid[uuidComponentOffset], (uint8_t*)mvkPfx, mvkPfxLen);
+	mvkCopy(&pDevIdProps->driverUUID[uuidComponentOffset], (uint8_t*)mvkPfx, mvkPfxLen);
 	uuidComponentOffset += mvkPfxLen + 1;
 
 	// Next 4 bytes contains MoltenVK version
 	uint32_t mvkVersion = MVK_VERSION;
-	*(uint32_t*)&uuid[uuidComponentOffset] = NSSwapHostIntToBig(mvkVersion);
+	*(uint32_t*)&pDevIdProps->driverUUID[uuidComponentOffset] = NSSwapHostIntToBig(mvkVersion);
 	uuidComponentOffset += sizeof(mvkVersion);
 
 	// Next 4 bytes contains highest Metal feature set supported by this device
 	uint32_t mtlFeatSet = getHighestMTLFeatureSet();
-	*(uint32_t*)&uuid[uuidComponentOffset] = NSSwapHostIntToBig(mtlFeatSet);
+	*(uint32_t*)&pDevIdProps->driverUUID[uuidComponentOffset] = NSSwapHostIntToBig(mtlFeatSet);
 	uuidComponentOffset += sizeof(mtlFeatSet);
 
 
 	// ---- LUID ignored for Metal devices ------------------------
-	mvkClear(pDevIdProps->deviceLUID, VK_LUID_SIZE);
+	mvkClear(&pDevIdProps->deviceLUID);
 	pDevIdProps->deviceNodeMask = 0;
 	pDevIdProps->deviceLUIDValid = VK_FALSE;
 }
@@ -1111,8 +1109,8 @@
 		switch (next->sType) {
 			case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT: {
 				auto* budgetProps = (VkPhysicalDeviceMemoryBudgetPropertiesEXT*)next;
-				mvkClear(budgetProps->heapBudget, VK_MAX_MEMORY_HEAPS);
-				mvkClear(budgetProps->heapUsage, VK_MAX_MEMORY_HEAPS);
+				mvkClear(&budgetProps->heapBudget);
+				mvkClear(&budgetProps->heapUsage);
 				budgetProps->heapBudget[0] = (VkDeviceSize)getRecommendedMaxWorkingSetSize();
 				budgetProps->heapUsage[0] = (VkDeviceSize)getCurrentAllocatedSize();
 				if (!getHasUnifiedMemory()) {
@@ -1144,7 +1142,8 @@
 	initExtensions();
 	initMemoryProperties();
 	initExternalMemoryProperties();
-	logGPUInfo();
+	initPipelineCacheUUID();			// Call penultimate
+	logGPUInfo();						// Call last
 }
 
 // Initializes the physical device properties (except limits).
@@ -1155,7 +1154,6 @@
 	_properties.driverVersion = MVK_VERSION;
 
 	initGPUInfoProperties();
-	initPipelineCacheUUID();
 }
 
 // Initializes the Metal-specific physical device features of this instance.
@@ -1214,6 +1212,7 @@
 	if (supportsMTLFeatureSet(tvOS_GPUFamily1_v3)) {
 		_metalFeatures.mslVersionEnum = MTLLanguageVersion2_0;
         _metalFeatures.renderWithoutAttachments = true;
+		MVK_SET_FROM_ENV_OR_BUILD_BOOL(_metalFeatures.argumentBuffers, MVK_CONFIG_USE_METAL_ARGUMENT_BUFFERS);
 	}
 
 	if (supportsMTLFeatureSet(tvOS_GPUFamily1_v4)) {
@@ -1287,6 +1286,7 @@
     if (supportsMTLFeatureSet(iOS_GPUFamily1_v4)) {
 		_metalFeatures.mslVersionEnum = MTLLanguageVersion2_0;
         _metalFeatures.renderWithoutAttachments = true;
+		MVK_SET_FROM_ENV_OR_BUILD_BOOL(_metalFeatures.argumentBuffers, MVK_CONFIG_USE_METAL_ARGUMENT_BUFFERS);
     }
 
 	if (supportsMTLFeatureSet(iOS_GPUFamily1_v5)) {
@@ -1395,6 +1395,7 @@
 		_metalFeatures.presentModeImmediate = true;
 		_metalFeatures.fences = true;
 		_metalFeatures.nonUniformThreadgroups = true;
+		MVK_SET_FROM_ENV_OR_BUILD_BOOL(_metalFeatures.argumentBuffers, MVK_CONFIG_USE_METAL_ARGUMENT_BUFFERS);
     }
 
     if (supportsMTLFeatureSet(macOS_GPUFamily1_v4)) {
@@ -2336,24 +2337,26 @@
 void MVKPhysicalDevice::initPipelineCacheUUID() {
 
 	// Clear the UUID
-	mvkClear(&_properties.pipelineCacheUUID, VK_UUID_SIZE);
+	mvkClear(&_properties.pipelineCacheUUID);
 
 	size_t uuidComponentOffset = 0;
 
-	// First 4 bytes contains MoltenVK version
-	uint32_t mvkVersion = MVK_VERSION;
-	*(uint32_t*)&_properties.pipelineCacheUUID[uuidComponentOffset] = NSSwapHostIntToBig(mvkVersion);
-	uuidComponentOffset += sizeof(mvkVersion);
+	// First 8 bytes contain the first part of the MoltenVK Git revision
+	uint64_t mvkRev = getMoltenVKGitRevision();
+	*(uint64_t*)&_properties.pipelineCacheUUID[uuidComponentOffset] = NSSwapHostLongLongToBig(mvkRev);
+	uuidComponentOffset += sizeof(mvkRev);
 
 	// Next 4 bytes contains highest Metal feature set supported by this device
 	uint32_t mtlFeatSet = getHighestMTLFeatureSet();
 	*(uint32_t*)&_properties.pipelineCacheUUID[uuidComponentOffset] = NSSwapHostIntToBig(mtlFeatSet);
 	uuidComponentOffset += sizeof(mtlFeatSet);
 
-	// Last 8 bytes contain the first part of the MoltenVK Git revision
-	uint64_t mvkRev = getMoltenVKGitRevision();
-	*(uint64_t*)&_properties.pipelineCacheUUID[uuidComponentOffset] = NSSwapHostLongLongToBig(mvkRev);
-	uuidComponentOffset += sizeof(mvkRev);
+	// Last 4 bytes contains flags based on enabled Metal features that
+	// might affect the contents of the pipeline cache (mostly MSL content).
+	uint32_t mtlFeatures = 0;
+	mtlFeatures |= ((bool)_metalFeatures.argumentBuffers) << 0;
+	*(uint32_t*)&_properties.pipelineCacheUUID[uuidComponentOffset] = NSSwapHostIntToBig(mtlFeatures);
+	uuidComponentOffset += sizeof(mtlFeatures);
 }
 
 uint32_t MVKPhysicalDevice::getHighestMTLFeatureSet() {
@@ -2953,7 +2956,7 @@
 }
 
 VkResult MVKDevice::getDeviceGroupPresentCapabilities(VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) {
-	mvkClear(pDeviceGroupPresentCapabilities->presentMask, VK_MAX_DEVICE_GROUP_SIZE);
+	mvkClear(&pDeviceGroupPresentCapabilities->presentMask);
 	pDeviceGroupPresentCapabilities->presentMask[0] = 0x1;
 
 	pDeviceGroupPresentCapabilities->modes = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR;
@@ -3688,40 +3691,7 @@
 
 	_commandResourceFactory = new MVKCommandResourceFactory(this);
 
-// This code will be refactored in an upcoming release, but for now,
-// suppress deprecation warnings for startCaptureWithDevice: on MacCatalyst.
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wdeprecated-declarations"
-	if (getInstance()->_autoGPUCaptureScope == MVK_CONFIG_AUTO_GPU_CAPTURE_SCOPE_DEVICE) {
-		MTLCaptureManager *captureMgr = [MTLCaptureManager sharedCaptureManager];
-		if (!getInstance()->_autoGPUCaptureOutputFile.empty()) {
-			if ( ![captureMgr respondsToSelector: @selector(supportsDestination:)] ||
-				 ![captureMgr supportsDestination: MTLCaptureDestinationGPUTraceDocument] ) {
-				reportError(VK_ERROR_FEATURE_NOT_PRESENT, "Capturing GPU traces to a file requires macOS 10.15 or iOS 13.0. Falling back to Xcode GPU capture.");
-				[captureMgr startCaptureWithDevice: getMTLDevice()];
-			} else {
-				NSError *err = nil;
-				NSString *path, *expandedPath;
-				MTLCaptureDescriptor *captureDesc = [MTLCaptureDescriptor new];
-				captureDesc.captureObject = getMTLDevice();
-				captureDesc.destination = MTLCaptureDestinationGPUTraceDocument;
-				path = [NSString stringWithUTF8String: getInstance()->_autoGPUCaptureOutputFile.c_str()];
-				expandedPath = path.stringByExpandingTildeInPath;
-				captureDesc.outputURL = [NSURL fileURLWithPath: expandedPath];
-				if (![captureMgr startCaptureWithDescriptor: captureDesc error: &err]) {
-					reportError(VK_ERROR_INITIALIZATION_FAILED, "Failed to start GPU capture session to %s (Error code %li): %s", getInstance()->_autoGPUCaptureOutputFile.c_str(), (long)err.code, err.localizedDescription.UTF8String);
-					[err release];
-				}
-				[captureDesc.outputURL release];
-				[captureDesc release];
-				[expandedPath release];
-				[path release];
-			}
-		} else {
-			[captureMgr startCaptureWithDevice: getMTLDevice()];
-		}
-	}
-#pragma clang diagnostic pop
+	getInstance()->startAutoGPUCapture(MVK_CONFIG_AUTO_GPU_CAPTURE_SCOPE_DEVICE, getMTLDevice());
 
 	MVKLogInfo("Created VkDevice to run on GPU %s with the following %d Vulkan extensions enabled:%s",
 			   _pProperties->deviceName,
@@ -4099,9 +4069,7 @@
     [_globalVisibilityResultMTLBuffer release];
 	[_defaultMTLSamplerState release];
 
-	if (getInstance()->_autoGPUCaptureScope == MVK_CONFIG_AUTO_GPU_CAPTURE_SCOPE_DEVICE) {
-		[[MTLCaptureManager sharedCaptureManager] stopCapture];
-	}
+	getInstance()->stopAutoGPUCapture(MVK_CONFIG_AUTO_GPU_CAPTURE_SCOPE_DEVICE);
 
 	mvkDestroyContainerContents(_privateDataSlots);
 }
diff --git a/MoltenVK/MoltenVK/GPUObjects/MVKImage.mm b/MoltenVK/MoltenVK/GPUObjects/MVKImage.mm
index 16771af..0a2c3ba 100644
--- a/MoltenVK/MoltenVK/GPUObjects/MVKImage.mm
+++ b/MoltenVK/MoltenVK/GPUObjects/MVKImage.mm
@@ -1930,6 +1930,7 @@
 								 ? mvkClamp(pCreateInfo->maxAnisotropy, 1.0f, _device->_pProperties->limits.maxSamplerAnisotropy)
 								 : 1);
 	mtlSampDesc.normalizedCoordinates = !pCreateInfo->unnormalizedCoordinates;
+	mtlSampDesc.supportArgumentBuffers = supportsMetalArgumentBuffers();
 
 	// If compareEnable is true, but dynamic samplers with depth compare are not available
 	// on this device, this sampler must only be used as an immutable sampler, and will
diff --git a/MoltenVK/MoltenVK/GPUObjects/MVKInstance.h b/MoltenVK/MoltenVK/GPUObjects/MVKInstance.h
index 3ff1a95..9bb0175 100644
--- a/MoltenVK/MoltenVK/GPUObjects/MVKInstance.h
+++ b/MoltenVK/MoltenVK/GPUObjects/MVKInstance.h
@@ -158,6 +158,37 @@
 	/** The list of Vulkan extensions, indicating whether each has been enabled by the app. */
 	const MVKExtensionList _enabledExtensions;
 
+	/**
+	 * Checks if automatic GPU capture is enabled for the specified auto capture
+	 * scope, and if so, starts capturing from the specified Metal capture object.
+	 * The capture will be made to either Xcode, or to a file if the
+	 * MVK_CONFIG_AUTO_GPU_CAPTURE_OUTPUT_FILE environment has specified.
+	 *
+	 * The autoGPUCaptureScope parameter must be one of:
+	 *   - MVK_CONFIG_AUTO_GPU_CAPTURE_SCOPE_NONE
+	 *   - MVK_CONFIG_AUTO_GPU_CAPTURE_SCOPE_DEVICE
+	 *   - MVK_CONFIG_AUTO_GPU_CAPTURE_SCOPE_FRAME
+	 *
+	 * The mtlCaptureObject must be one of:
+	 *   - MTLDevice for scope MVK_CONFIG_AUTO_GPU_CAPTURE_SCOPE_DEVICE
+	 *   - MTLCommandQueue for scope MVK_CONFIG_AUTO_GPU_CAPTURE_SCOPE_FRAME.
+	 */
+	void startAutoGPUCapture(int32_t autoGPUCaptureScope, id mtlCaptureObject);
+
+	/**
+	 * Checks if automatic GPU capture is enabled for the specified
+	 * auto capture scope, and if so, stops capturing.
+	 *
+	 * The autoGPUCaptureScope parameter must be one of:
+	 *   - MVK_CONFIG_AUTO_GPU_CAPTURE_SCOPE_NONE
+	 *   - MVK_CONFIG_AUTO_GPU_CAPTURE_SCOPE_DEVICE
+	 *   - MVK_CONFIG_AUTO_GPU_CAPTURE_SCOPE_FRAME
+	 */
+	void stopAutoGPUCapture(int32_t autoGPUCaptureScope);
+
+	/** Returns whether this instance is currently automatically capturing a GPU trace. */
+	inline bool isCurrentlyAutoGPUCapturing() { return _isCurrentlyAutoGPUCapturing; }
+
 
 #pragma mark Object Creation
 
@@ -205,6 +236,7 @@
 	bool _useCreationCallbacks;
 	const char* _debugReportCallbackLayerPrefix;
 	int32_t _autoGPUCaptureScope;
+	bool _isCurrentlyAutoGPUCapturing;
 	std::string _autoGPUCaptureOutputFile;
 };
 
diff --git a/MoltenVK/MoltenVK/GPUObjects/MVKInstance.mm b/MoltenVK/MoltenVK/GPUObjects/MVKInstance.mm
index 78efef5..9f1d555 100644
--- a/MoltenVK/MoltenVK/GPUObjects/MVKInstance.mm
+++ b/MoltenVK/MoltenVK/GPUObjects/MVKInstance.mm
@@ -280,6 +280,49 @@
 	}
 }
 
+void MVKInstance::startAutoGPUCapture(int32_t autoGPUCaptureScope, id mtlCaptureObject) {
+
+	if (_isCurrentlyAutoGPUCapturing || (_autoGPUCaptureScope != autoGPUCaptureScope)) { return; }
+
+	_isCurrentlyAutoGPUCapturing = true;
+
+	@autoreleasepool {
+		MTLCaptureManager *captureMgr = [MTLCaptureManager sharedCaptureManager];
+
+		MTLCaptureDescriptor *captureDesc = [[MTLCaptureDescriptor new] autorelease];
+		captureDesc.captureObject = mtlCaptureObject;
+		captureDesc.destination = MTLCaptureDestinationDeveloperTools;
+
+		if ( !_autoGPUCaptureOutputFile.empty() ) {
+			if ([captureMgr respondsToSelector: @selector(supportsDestination:)] &&
+				[captureMgr supportsDestination: MTLCaptureDestinationGPUTraceDocument] ) {
+
+				NSString* filePath = [[NSString stringWithUTF8String: _autoGPUCaptureOutputFile.c_str()] stringByExpandingTildeInPath];
+				MVKLogInfo("Capturing GPU trace to file %s.", filePath.UTF8String);
+
+				captureDesc.destination = MTLCaptureDestinationGPUTraceDocument;
+				captureDesc.outputURL = [NSURL fileURLWithPath: filePath];
+
+			} else {
+				reportError(VK_ERROR_FEATURE_NOT_PRESENT, "Capturing GPU traces to a file requires macOS 10.15 or iOS 13.0. Falling back to Xcode GPU capture.");
+			}
+		} else {
+			MVKLogInfo("Capturing GPU trace to Xcode.");
+		}
+
+		NSError *err = nil;
+		if ( ![captureMgr startCaptureWithDescriptor: captureDesc error: &err] ) {
+			reportError(VK_ERROR_INITIALIZATION_FAILED, "Failed to automatically start GPU capture session (Error code %li): %s", (long)err.code, err.localizedDescription.UTF8String);
+		}
+	}
+}
+
+void MVKInstance::stopAutoGPUCapture(int32_t autoGPUCaptureScope) {
+	if (_isCurrentlyAutoGPUCapturing && _autoGPUCaptureScope == autoGPUCaptureScope) {
+		[[MTLCaptureManager sharedCaptureManager] stopCapture];
+		_isCurrentlyAutoGPUCapturing = false;
+	}
+}
 
 #pragma mark Object Creation
 
@@ -364,6 +407,8 @@
 		setConfigurationResult(reportError(VK_ERROR_INCOMPATIBLE_DRIVER, "Vulkan is not supported on this device. MoltenVK requires Metal, which is not available on this device."));
 	}
 
+	_isCurrentlyAutoGPUCapturing = false;
+
 	if (MVK_MACCAT && !mvkOSVersionIsAtLeast(11.0)) {
 		setConfigurationResult(reportError(VK_ERROR_INCOMPATIBLE_DRIVER, "To support Mac Catalyst, MoltenVK requires macOS 11.0 or above."));
 	}
diff --git a/MoltenVK/MoltenVK/GPUObjects/MVKPipeline.h b/MoltenVK/MoltenVK/GPUObjects/MVKPipeline.h
index 45161b5..f6c2f93 100644
--- a/MoltenVK/MoltenVK/GPUObjects/MVKPipeline.h
+++ b/MoltenVK/MoltenVK/GPUObjects/MVKPipeline.h
@@ -39,7 +39,7 @@
 #pragma mark MVKPipelineLayout
 
 struct MVKShaderImplicitRezBinding {
-	uint32_t stages[kMVKShaderStageMax];
+	uint32_t stages[kMVKShaderStageCount];
 };
 
 /** Represents a Vulkan pipeline layout. */
@@ -111,7 +111,7 @@
 protected:
 	void propagateDebugName() override {}
 
-	MVKSmallVector<MVKDescriptorSetLayout*, 1> _descriptorSetLayouts;
+	MVKSmallVector<MVKDescriptorSetLayout*, 8> _descriptorSetLayouts;
 	MVKSmallVector<MVKShaderResourceBinding, 1> _dslMTLResourceIndexOffsets;
 	MVKSmallVector<VkPushConstantRange> _pushConstants;
 	MVKShaderResourceBinding _pushConstantsMTLResourceIndexes;
diff --git a/MoltenVK/MoltenVK/GPUObjects/MVKPipeline.mm b/MoltenVK/MoltenVK/GPUObjects/MVKPipeline.mm
index 7a160fa..4bc3481 100644
--- a/MoltenVK/MoltenVK/GPUObjects/MVKPipeline.mm
+++ b/MoltenVK/MoltenVK/GPUObjects/MVKPipeline.mm
@@ -48,7 +48,8 @@
 		MVKDescriptorSet* descSet = descriptorSets[dsIdx];
 		uint32_t dslIdx = firstSet + dsIdx;
 		MVKDescriptorSetLayout* dsl = _descriptorSetLayouts[dslIdx];
-		dsl->bindDescriptorSet(cmdEncoder, descSet, _dslMTLResourceIndexOffsets[dslIdx],
+		dsl->bindDescriptorSet(cmdEncoder, descSet, dslIdx,
+							   _dslMTLResourceIndexOffsets[dslIdx],
 							   dynamicOffsets, dynamicOffsetIndex);
 		if (!cmdEncoder) { setConfigurationResult(dsl->getConfigurationResult()); }
 	}
@@ -77,6 +78,8 @@
 
 void MVKPipelineLayout::populateShaderConverterContext(SPIRVToMSLConversionConfiguration& context) {
 	context.resourceBindings.clear();
+	context.discreteDescriptorSets.clear();
+	context.inlineUniformBlocks.clear();
 
     // Add resource bindings defined in the descriptor set layouts
 	uint32_t dslCnt = (uint32_t)_descriptorSetLayouts.size();
@@ -94,7 +97,7 @@
 		spv::ExecutionModelFragment,
 		spv::ExecutionModelGLCompute
 	};
-	for (uint32_t i = kMVKShaderStageVertex; i < kMVKShaderStageMax; i++) {
+	for (uint32_t i = kMVKShaderStageVertex; i < kMVKShaderStageCount; i++) {
 		mvkPopulateShaderConverterContext(context,
 										  _pushConstantsMTLResourceIndexes.stages[i],
 										  models[i],
@@ -105,40 +108,40 @@
 	}
 }
 
+// Add descriptor set layouts.
+// According to the Vulkan spec, VkDescriptorSetLayout is intended to be consumed when passed
+// to any Vulkan function, and may be safely destroyed by app immediately after. In order for
+// this pipeline layout to retain the VkDescriptorSetLayout, the MVKDescriptorSetLayout
+// instance is retained, so that it will live on here after it has been destroyed by the API.
+
+// If we're not using Metal argument buffers, accumulate the resource index offsets used
+// by the corresponding DSL, and associating the current accumulated resource index offsets
+// with each DSL as it is added. If we're using Metal argument buffers, just accumulate the
+// number of Metal argument buffers we need for each stage.
+// The final accumulation of resource index offsets becomes the resource index offsets that
+// will be used for push contants and any additional auxilliary buffers.
 MVKPipelineLayout::MVKPipelineLayout(MVKDevice* device,
                                      const VkPipelineLayoutCreateInfo* pCreateInfo) : MVKVulkanAPIDeviceObject(device) {
-
-    // Add descriptor set layouts, accumulating the resource index offsets used by the
-    // corresponding DSL, and associating the current accumulated resource index offsets
-    // with each DSL as it is added. The final accumulation of resource index offsets
-    // becomes the resource index offsets that will be used for push contants.
-
-    // According to the Vulkan spec, VkDescriptorSetLayout is intended to be consumed when passed
-	// to any Vulkan function, and may be safely destroyed by app immediately after. In order for
-	// this pipeline layout to retain the VkDescriptorSetLayout, the MVKDescriptorSetLayout
-	// instance is retained, so that it will live on here after it has been destroyed by the API.
-
-	_descriptorSetLayouts.reserve(pCreateInfo->setLayoutCount);
-	for (uint32_t i = 0; i < pCreateInfo->setLayoutCount; i++) {
-		MVKDescriptorSetLayout* pDescSetLayout = (MVKDescriptorSetLayout*)pCreateInfo->pSetLayouts[i];
-		pDescSetLayout->retain();
-		_descriptorSetLayouts.push_back(pDescSetLayout);
-		_dslMTLResourceIndexOffsets.push_back(_pushConstantsMTLResourceIndexes);
-		_pushConstantsMTLResourceIndexes += pDescSetLayout->_mtlResourceCounts;
-	}
-
-	// Add push constants
-	_pushConstants.reserve(pCreateInfo->pushConstantRangeCount);
-	for (uint32_t i = 0; i < pCreateInfo->pushConstantRangeCount; i++) {
-		_pushConstants.push_back(pCreateInfo->pPushConstantRanges[i]);
+	uint32_t dslCnt = pCreateInfo->setLayoutCount;
+	_descriptorSetLayouts.resize(dslCnt);
+	_dslMTLResourceIndexOffsets.resize(dslCnt);
+	for (uint32_t dslIdx = 0; dslIdx < dslCnt; dslIdx++) {
+		MVKDescriptorSetLayout* mvkDSL = (MVKDescriptorSetLayout*)pCreateInfo->pSetLayouts[dslIdx];
+		mvkDSL->retain();
+		_descriptorSetLayouts[dslIdx] = mvkDSL;
+		if (mvkDSL->isUsingMetalArgumentBuffer()) {
+			_pushConstantsMTLResourceIndexes.addArgumentBuffer(mvkDSL->_mtlResourceCounts);
+		} else {
+			_dslMTLResourceIndexOffsets[dslIdx] = _pushConstantsMTLResourceIndexes;
+			_pushConstantsMTLResourceIndexes += mvkDSL->_mtlResourceCounts;
+		}
 	}
 
 	// Set implicit buffer indices
 	// FIXME: Many of these are optional. We shouldn't set the ones that aren't
-	// present--or at least, we should move the ones that are down to avoid
-	// running over the limit of available buffers. But we can't know that
-	// until we compile the shaders.
-	for (uint32_t i = kMVKShaderStageVertex; i < kMVKShaderStageMax; i++) {
+	// present--or at least, we should move the ones that are down to avoid running over
+	// the limit of available buffers. But we can't know that until we compile the shaders.
+	for (uint32_t i = kMVKShaderStageVertex; i < kMVKShaderStageCount; i++) {
 		_swizzleBufferIndex.stages[i] = _pushConstantsMTLResourceIndexes.stages[i].bufferIndex + 1;
 		_bufferSizeBufferIndex.stages[i] = _swizzleBufferIndex.stages[i] + 1;
 		_indirectParamsIndex.stages[i] = _bufferSizeBufferIndex.stages[i] + 1;
@@ -148,6 +151,13 @@
 			_tessCtlLevelBufferIndex = _tessCtlPatchOutputBufferIndex + 1;
 		}
 	}
+
+	// Add push constants
+	_pushConstants.reserve(pCreateInfo->pushConstantRangeCount);
+	for (uint32_t i = 0; i < pCreateInfo->pushConstantRangeCount; i++) {
+		_pushConstants.push_back(pCreateInfo->pPushConstantRanges[i]);
+	}
+
 	// Since we currently can't use multiview with tessellation or geometry shaders,
 	// to conserve the number of buffer bindings, use the same bindings for the
 	// view range buffer as for the indirect paramters buffer.
@@ -164,7 +174,7 @@
 
 void MVKPipeline::bindPushConstants(MVKCommandEncoder* cmdEncoder) {
 	if (cmdEncoder) {
-		for (uint32_t i = kMVKShaderStageVertex; i < kMVKShaderStageMax; i++) {
+		for (uint32_t i = kMVKShaderStageVertex; i < kMVKShaderStageCount; i++) {
 			cmdEncoder->getPushConstants(mvkVkShaderStageFlagBitsFromMVKShaderStage(MVKShaderStage(i)))->setMTLBufferIndex(_pushConstantsMTLResourceIndexes.stages[i].bufferIndex);
 		}
 	}
@@ -367,7 +377,7 @@
 	}
 
 	// Track dynamic state in _dynamicStateEnabled array
-	mvkClear(_dynamicStateEnabled, kMVKVkDynamicStateCount);	// start with all dynamic state disabled
+	mvkClear(&_dynamicStateEnabled);	// start with all dynamic state disabled
 	const VkPipelineDynamicStateCreateInfo* pDS = pCreateInfo->pDynamicState;
 	if (pDS) {
 		for (uint32_t i = 0; i < pDS->dynamicStateCount; i++) {
@@ -1451,6 +1461,8 @@
     shaderContext.options.mslOptions.texel_buffer_texture_width = _device->_pMetalFeatures->maxTextureDimension;
     shaderContext.options.mslOptions.r32ui_linear_texture_alignment = (uint32_t)_device->getVkFormatTexelBufferAlignment(VK_FORMAT_R32_UINT, this);
 	shaderContext.options.mslOptions.texture_buffer_native = _device->_pMetalFeatures->textureBuffers;
+	shaderContext.options.mslOptions.argument_buffers = supportsMetalArgumentBuffers();
+	shaderContext.options.mslOptions.force_active_argument_buffer_resources = supportsMetalArgumentBuffers();
 
     MVKPipelineLayout* layout = (MVKPipelineLayout*)pCreateInfo->layout;
     layout->populateShaderConverterContext(shaderContext);
@@ -1693,6 +1705,8 @@
 	shaderContext.options.mslOptions.dispatch_base = _allowsDispatchBase;
 	shaderContext.options.mslOptions.texture_1D_as_2D = mvkTreatTexture1DAs2D();
     shaderContext.options.mslOptions.fixed_subgroup_size = mvkIsAnyFlagEnabled(pSS->flags, VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT) ? 0 : _device->_pMetalFeatures->maxSubgroupSize;
+	shaderContext.options.mslOptions.argument_buffers = supportsMetalArgumentBuffers();
+	shaderContext.options.mslOptions.force_active_argument_buffer_resources = supportsMetalArgumentBuffers();
 #if MVK_MACOS
     shaderContext.options.mslOptions.emulate_subgroups = !_device->_pMetalFeatures->simdPermute;
 #endif
@@ -2102,10 +2116,18 @@
 	}
 
 	template<class Archive>
+	void serialize(Archive & archive, DescriptorBinding& db) {
+		archive(db.descriptorSet,
+				db.binding);
+	}
+
+	template<class Archive>
 	void serialize(Archive & archive, SPIRVToMSLConversionConfiguration& ctx) {
 		archive(ctx.options,
 				ctx.shaderInputs,
-				ctx.resourceBindings);
+				ctx.resourceBindings,
+				ctx.discreteDescriptorSets,
+				ctx.inlineUniformBlocks);
 	}
 
 	template<class Archive>
diff --git a/MoltenVK/MoltenVK/GPUObjects/MVKPixelFormats.mm b/MoltenVK/MoltenVK/GPUObjects/MVKPixelFormats.mm
index 4ca6b4f..9cde2b0 100644
--- a/MoltenVK/MoltenVK/GPUObjects/MVKPixelFormats.mm
+++ b/MoltenVK/MoltenVK/GPUObjects/MVKPixelFormats.mm
@@ -754,7 +754,7 @@
 
 void MVKPixelFormats::initVkFormatCapabilities() {
 
-	mvkClear(_vkFormatDescriptions, _vkFormatCount);
+	mvkClear(&_vkFormatDescriptions);
 
 	uint32_t fmtIdx = 0;
 
@@ -1066,7 +1066,7 @@
 
 void MVKPixelFormats::initMTLPixelFormatCapabilities() {
 
-	mvkClear(_mtlPixelFormatDescriptions, _mtlPixelFormatCount);
+	mvkClear(&_mtlPixelFormatDescriptions);
 
 	uint32_t fmtIdx = 0;
 
@@ -1250,7 +1250,7 @@
 
 void MVKPixelFormats::initMTLVertexFormatCapabilities() {
 
-	mvkClear(_mtlVertexFormatDescriptions, _mtlVertexFormatCount);
+	mvkClear(&_mtlVertexFormatDescriptions);
 
 	uint32_t fmtIdx = 0;
 
@@ -1331,8 +1331,8 @@
 void MVKPixelFormats::buildMTLFormatMaps() {
 
 	// Set all MTLPixelFormats and MTLVertexFormats to undefined/invalid
-	mvkClear(_mtlFormatDescIndicesByMTLPixelFormatsCore, _mtlPixelFormatCoreCount);
-	mvkClear(_mtlFormatDescIndicesByMTLVertexFormats, _mtlVertexFormatCount);
+	mvkClear(&_mtlFormatDescIndicesByMTLPixelFormatsCore);
+	mvkClear(&_mtlFormatDescIndicesByMTLVertexFormats);
 
 	// Build lookup table for MTLPixelFormat specs.
 	// For most Metal format values, which are small and consecutive, use a simple lookup array.
@@ -1933,7 +1933,7 @@
 void MVKPixelFormats::buildVkFormatMaps() {
 
 	// Set the VkFormats to undefined/invalid
-	mvkClear(_vkFormatDescIndicesByVkFormatsCore, _vkFormatCoreCount);
+	mvkClear(&_vkFormatDescIndicesByVkFormatsCore);
 
 	// Iterate through the VkFormat descriptions, populate the lookup maps and back pointers,
 	// and validate the Metal formats for the platform and OS.
diff --git a/MoltenVK/MoltenVK/GPUObjects/MVKQueue.h b/MoltenVK/MoltenVK/GPUObjects/MVKQueue.h
index 5df8401..91b66c0 100644
--- a/MoltenVK/MoltenVK/GPUObjects/MVKQueue.h
+++ b/MoltenVK/MoltenVK/GPUObjects/MVKQueue.h
@@ -208,7 +208,6 @@
 	id<MTLCommandBuffer> _activeMTLCommandBuffer;
 };
 
-
 /**
  * Submits the commands in a set of command buffers to the queue.
  * Template class to balance vector pre-allocations between very common low counts and fewer larger counts.
@@ -253,6 +252,7 @@
 
 protected:
 	id<MTLCommandBuffer> getMTLCommandBuffer();
+	void stopAutoGPUCapture();
 
 	MVKSmallVector<MVKPresentTimingInfo, 4> _presentInfo;
 };
diff --git a/MoltenVK/MoltenVK/GPUObjects/MVKQueue.mm b/MoltenVK/MoltenVK/GPUObjects/MVKQueue.mm
index caec05e..0fc8979 100644
--- a/MoltenVK/MoltenVK/GPUObjects/MVKQueue.mm
+++ b/MoltenVK/MoltenVK/GPUObjects/MVKQueue.mm
@@ -162,7 +162,7 @@
 	initName();
 	initExecQueue();
 	initMTLCommandQueue();
-	initGPUCaptureScopes();
+	initGPUCaptureScopes();		// After initMTLCommandQueue()
 }
 
 void MVKQueue::initName() {
@@ -203,6 +203,8 @@
 		_submissionCaptureScope->makeDefault();
 	}
 	_submissionCaptureScope->beginScope();	// Allow Xcode to capture the first frame if desired.
+
+	getInstance()->startAutoGPUCapture(MVK_CONFIG_AUTO_GPU_CAPTURE_SCOPE_FRAME, _mtlQueue);
 }
 
 MVKQueue::~MVKQueue() {
@@ -402,6 +404,7 @@
 	auto cs = _queue->_submissionCaptureScope;
 	cs->endScope();
 	cs->beginScope();
+	stopAutoGPUCapture();
 
 	this->destroy();
 }
@@ -413,6 +416,16 @@
 	return mtlCmdBuff;
 }
 
+
+void MVKQueuePresentSurfaceSubmission::stopAutoGPUCapture() {
+	MVKInstance* mvkInst = _queue->getInstance();
+	const MVKConfiguration* pMVKConfig = mvkInst->getMoltenVKConfiguration();
+	if (_queue->_queueFamily->getIndex() == pMVKConfig->defaultGPUCaptureScopeQueueFamilyIndex &&
+		_queue->_index == pMVKConfig->defaultGPUCaptureScopeQueueIndex) {
+		mvkInst->stopAutoGPUCapture(MVK_CONFIG_AUTO_GPU_CAPTURE_SCOPE_FRAME);
+	}
+}
+
 MVKQueuePresentSurfaceSubmission::MVKQueuePresentSurfaceSubmission(MVKQueue* queue,
 																   const VkPresentInfoKHR* pPresentInfo)
 	: MVKQueueSubmission(queue, pPresentInfo->waitSemaphoreCount, pPresentInfo->pWaitSemaphores) {
diff --git a/MoltenVK/MoltenVK/Layers/MVKExtensions.mm b/MoltenVK/MoltenVK/Layers/MVKExtensions.mm
index 0e0eba8..fcf304e 100644
--- a/MoltenVK/MoltenVK/Layers/MVKExtensions.mm
+++ b/MoltenVK/MoltenVK/Layers/MVKExtensions.mm
@@ -33,7 +33,7 @@
 // Returns a VkExtensionProperties struct populated with a name and version
 static VkExtensionProperties mvkMakeExtProps(const char* extensionName, uint32_t specVersion) {
 	VkExtensionProperties extProps;
-	mvkClear(extProps.extensionName, VK_MAX_EXTENSION_NAME_SIZE);
+	mvkClear(&extProps.extensionName);
 	if (extensionName) { strcpy(extProps.extensionName, extensionName); }
 	extProps.specVersion = specVersion;
 	return extProps;
diff --git a/MoltenVK/MoltenVK/Layers/MVKLayers.mm b/MoltenVK/MoltenVK/Layers/MVKLayers.mm
index aefaef3..3a2bc71 100644
--- a/MoltenVK/MoltenVK/Layers/MVKLayers.mm
+++ b/MoltenVK/MoltenVK/Layers/MVKLayers.mm
@@ -41,9 +41,9 @@
 MVKLayer::MVKLayer() : _supportedInstanceExtensions(nullptr, true) {
 
 	// The core driver layer
-	mvkClear(_layerProperties.layerName, VK_MAX_EXTENSION_NAME_SIZE);
+	mvkClear(&_layerProperties.layerName);
 	strcpy(_layerProperties.layerName, "MoltenVK");
-	mvkClear(_layerProperties.description, VK_MAX_DESCRIPTION_SIZE);
+	mvkClear(&_layerProperties.description);
 	strcpy(_layerProperties.description, "MoltenVK driver layer");
 	_layerProperties.specVersion = MVK_VULKAN_API_VERSION;
 	_layerProperties.implementationVersion = MVK_VERSION;
diff --git a/MoltenVK/MoltenVK/Utility/MVKBitArray.h b/MoltenVK/MoltenVK/Utility/MVKBitArray.h
new file mode 100755
index 0000000..6f2226d
--- /dev/null
+++ b/MoltenVK/MoltenVK/Utility/MVKBitArray.h
@@ -0,0 +1,179 @@
+/*
+ * MVKBitArray.h
+ *
+ * Copyright (c) 2020-2020 The Brenwill Workshop Ltd. (http://www.brenwill.com)
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include "MVKFoundation.h"
+
+
+#pragma mark -
+#pragma mark MVKBitArray
+
+/** Represents an array of bits, optimized for storage and fast scanning for bits that are set. */
+class MVKBitArray {
+
+	static constexpr size_t SectionMaskSize = 6;
+	static constexpr size_t SectionSize = 1U << SectionMaskSize;
+
+public:
+
+	/** Returns the value of the bit. */
+	inline bool getBit(size_t bitIndex) {
+		return mvkIsAnyFlagEnabled(_pSections[getIndexOfSection(bitIndex)], getSectionSetMask(bitIndex));
+	}
+
+	/** Sets the value of the bit to 1. */
+	inline void setBit(size_t bitIndex) {
+		size_t secIdx = getIndexOfSection(bitIndex);
+		mvkEnableFlags(_pSections[secIdx], getSectionSetMask(bitIndex));
+
+		if (secIdx < _minUnclearedSectionIndex) { _minUnclearedSectionIndex = secIdx; }
+	}
+
+	/** Sets the value of the bit to 0. */
+	inline void clearBit(size_t bitIndex) {
+		size_t secIdx = getIndexOfSection(bitIndex);
+		mvkDisableFlags(_pSections[secIdx], getSectionSetMask(bitIndex));
+
+		if (secIdx == _minUnclearedSectionIndex && !_pSections[secIdx]) { _minUnclearedSectionIndex++; }
+	}
+
+	/** Sets the value of the bit to the value. */
+	inline void setBit(size_t bitIndex, bool val) {
+		if (val) {
+			setBit(bitIndex);
+		} else {
+			clearBit(bitIndex);
+		}
+	}
+
+	/** Sets all bits in the array to 1. */
+	inline void setAllBits() { setAllSections(~0); }
+
+	/** Clears all bits in the array to 0. */
+	inline void clearAllBits() { setAllSections(0); }
+
+	/**
+	 * Returns the index of the first bit that is set, at or after the specified index,
+	 * and optionally clears that bit. If no bits are set, returns the size() of this bit array.
+	 */
+	size_t getIndexOfFirstSetBit(size_t startIndex, bool shouldClear) {
+		size_t startSecIdx = std::max(getIndexOfSection(startIndex), _minUnclearedSectionIndex);
+		size_t bitIdx = startSecIdx << SectionMaskSize;
+		size_t secCnt = getSectionCount();
+		for (size_t secIdx = startSecIdx; secIdx < secCnt; secIdx++) {
+			size_t lclBitIdx = getIndexOfFirstSetBitInSection(_pSections[secIdx], getBitIndexInSection(startIndex));
+			bitIdx += lclBitIdx;
+			if (lclBitIdx < SectionSize) {
+				if (startSecIdx == _minUnclearedSectionIndex && !_pSections[startSecIdx]) { _minUnclearedSectionIndex = secIdx; }
+				if (shouldClear) { clearBit(bitIdx); }
+				return bitIdx;
+			}
+		}
+		return std::min(bitIdx, _bitCount);
+	}
+
+	/**
+	 * Returns the index of the first bit that is set, at or after the specified index.
+	 * If no bits are set, returns the size() of this bit array.
+	 */
+	inline size_t getIndexOfFirstSetBit(size_t startIndex) {
+		return getIndexOfFirstSetBit(startIndex, false);
+	}
+
+	/**
+	 * Returns the index of the first bit that is set and optionally clears that bit.
+	 * If no bits are set, returns the size() of this bit array.
+	 */
+	inline size_t getIndexOfFirstSetBit(bool shouldClear) {
+		return getIndexOfFirstSetBit(0, shouldClear);
+	}
+
+	/**
+	 * Returns the index of the first bit that is set.
+	 * If no bits are set, returns the size() of this bit array.
+	 */
+	inline size_t getIndexOfFirstSetBit() {
+		return getIndexOfFirstSetBit(0, false);
+	}
+
+	/** Returns the number of bits in this array. */
+	inline size_t size() { return _bitCount; }
+
+	/** Returns whether this array is empty. */
+	inline bool empty() { return !_bitCount; }
+
+	/** Constructs an instance for the specified number of bits, and sets the initial value of all the bits. */
+	MVKBitArray(size_t size, bool val = false) {
+		_bitCount = size;
+		_pSections = _bitCount ? (uint64_t*)malloc(getSectionCount() * SectionSize) : nullptr;
+		if (val) {
+			setAllBits();
+		} else {
+			clearAllBits();
+		}
+	}
+
+	~MVKBitArray() { free(_pSections); }
+
+protected:
+
+	// Returns the number of sections.
+	inline size_t getSectionCount() {
+		return _bitCount ? getIndexOfSection(_bitCount - 1) + 1 : 0;
+	}
+
+	// Returns the index of the section that contains the specified bit.
+	static inline size_t getIndexOfSection(size_t bitIndex) {
+		return bitIndex >> SectionMaskSize;
+	}
+
+	// Converts the bit index to a local bit index within a section, and returns that local bit index.
+	static inline size_t getBitIndexInSection(size_t bitIndex) {
+		return bitIndex & (SectionSize - 1);
+	}
+
+	// Returns a section mask containing a single 1 value in the bit in the section that
+	// corresponds to the specified global bit index, and 0 values in all other bits.
+	static inline uint64_t getSectionSetMask(size_t bitIndex) {
+		return (uint64_t)1U << ((SectionSize - 1) - getBitIndexInSection(bitIndex));
+	}
+
+	// Returns the local index of the first set bit in the section, starting from the highest order bit.
+	// Clears all bits ahead of the start bit so they will be ignored, then counts the number of zeros
+	// ahead of the set bit. If there are no set bits, returns the number of bits in a section.
+	static size_t getIndexOfFirstSetBitInSection(uint64_t section, size_t lclStartBitIndex) {
+		uint64_t lclStartMask = ~(uint64_t)0;
+		lclStartMask >>= lclStartBitIndex;
+		section &= lclStartMask;
+		return section ? __builtin_clzll(section) : SectionSize;
+	}
+
+	// Sets the content of all sections to the value
+	void setAllSections(uint64_t sectionValue) {
+		size_t secCnt = getSectionCount();
+		for (size_t secIdx = 0; secIdx < secCnt; secIdx++) {
+			_pSections[secIdx] = sectionValue;
+		}
+		_minUnclearedSectionIndex = sectionValue ? 0 : secCnt;
+	}
+
+	uint64_t* _pSections;
+	size_t _bitCount;
+	size_t _minUnclearedSectionIndex;	// Tracks where to start looking for bits that are set
+};
diff --git a/MoltenVK/MoltenVK/Utility/MVKEnvironment.h b/MoltenVK/MoltenVK/Utility/MVKEnvironment.h
index 63cc2eb..008b6fc 100644
--- a/MoltenVK/MoltenVK/Utility/MVKEnvironment.h
+++ b/MoltenVK/MoltenVK/Utility/MVKEnvironment.h
@@ -167,6 +167,7 @@
  */
 #define MVK_CONFIG_AUTO_GPU_CAPTURE_SCOPE_NONE		0
 #define MVK_CONFIG_AUTO_GPU_CAPTURE_SCOPE_DEVICE	1
+#define MVK_CONFIG_AUTO_GPU_CAPTURE_SCOPE_FRAME		2
 #ifndef MVK_CONFIG_AUTO_GPU_CAPTURE_SCOPE
 #   define MVK_CONFIG_AUTO_GPU_CAPTURE_SCOPE    	MVK_CONFIG_AUTO_GPU_CAPTURE_SCOPE_NONE
 #endif
@@ -205,6 +206,11 @@
 #   define MVK_CONFIG_TEXTURE_1D_AS_2D    1
 #endif
 
+/** Support Metal argument buffers. Enabled by default. */
+#ifndef MVK_CONFIG_USE_METAL_ARGUMENT_BUFFERS
+#   define MVK_CONFIG_USE_METAL_ARGUMENT_BUFFERS    1
+#endif
+
 /**
  * IOSurfaces are supported on macOS, and on iOS starting with iOS 11.
  *
diff --git a/MoltenVK/MoltenVK/Utility/MVKSmallVector.h b/MoltenVK/MoltenVK/Utility/MVKSmallVector.h
index 1d1612b..ff3042d 100755
--- a/MoltenVK/MoltenVK/Utility/MVKSmallVector.h
+++ b/MoltenVK/MoltenVK/Utility/MVKSmallVector.h
@@ -43,11 +43,11 @@
 // If you don't need any inline storage use:
 //  MVKSmallVector<int> v;   // this is essentially the same as using std::vector
 //
-// The per-instance memory overhead of MVKSmallVector (16 bytes) is smaller than MVKVector (40 bytes)
-// and std::vector (24 bytes), but MVKSmallVector lacks the polymorphism of MVKVector (or std::vector),
-// that allows them to be passed around to functions without reference to the pre-allocation size.
-// MVKSmallVector supports the contents() function to derive an MVKArrayRef from its contents,
-// which can be passed around without reference to the pre-allocaton size.
+// The per-instance memory overhead of MVKSmallVector (16 bytes) is smaller than std::vector (24 bytes),
+// and MVKSmallVector lacks the polymorphism of std::vector, that allows them to be passed around to
+// functions without reference to the pre-allocation size. MVKSmallVector supports the contents()
+// function to derive an MVKArrayRef from its contents, which can be passed around without reference
+// to the pre-allocaton size.
 
 #include "MVKSmallVectorAllocator.h"
 #include "MVKFoundation.h"
diff --git a/MoltenVK/MoltenVK/Utility/MVKVector.h b/MoltenVK/MoltenVK/Utility/MVKVector.h
deleted file mode 100755
index 60a4871..0000000
--- a/MoltenVK/MoltenVK/Utility/MVKVector.h
+++ /dev/null
@@ -1,1000 +0,0 @@
-/*
- * MVKVector.h
- *
- * Copyright (c) 2012-2020 Dr. Torsten Hans (hans@ipacs.de)
- *
- * 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.
- */
-
-#pragma once
-
-//
-// in case MVKVector should use std::vector
-//
-#if 0
-
-template<typename T, size_t N = 0>
-using MVKVectorInline = std::vector<T>;
-
-template<typename T>
-using MVKVectorDefault = std::vector<T>;
-
-template<typename T>
-using MVKVector = std::vector<T>;
-
-#else
-
-//
-// MVKVector.h is a sequence container that (optionally) implements a small
-// buffer optimization.
-// It behaves similarly to std::vector, except until a certain number of
-// elements are reserved, it does not use the heap.
-// Like std::vector, MVKVector is guaranteed to use contiguous memory, so if the
-// preallocated number of elements are exceeded, all elements are then in heap.
-// MVKVector supports just the necessary members to be compatible with MoltenVK
-// If C++17 will be the default in the future, code can be simplified quite a bit.
-//
-// Example:
-//
-//  MVKVectorInline<int, 3> vector;
-//  vector.emplace_back( 1 );
-//  vector.emplace_back( 2 );
-//  vector.emplace_back( 3 );
-//  // adding another element now reserves memory from heap
-//  vector.emplace_back( 4 );
-//
-// If you don't need any inline storage use
-//  MVKVectorDefault<int> vector;   // this is essentially the same as using std::vector
-//
-// Passing MVKVectorInline to a function would require to use the same template
-// parameters that have been used for declaration. To avoid this MVKVectorInline
-// is derived from MVKVector. If you want to pass MVKVectorInline to a function
-// use MVKVector.
-//
-#include "MVKVectorAllocator.h"
-#include "MVKFoundation.h"
-#include <type_traits>
-#include <initializer_list>
-#include <utility>
-
-
-template<class Type> class MVKVector
-{
-  mvk_vector_allocator_base<Type> *alc_ptr;
-
-public:
-  class iterator : public std::iterator<std::forward_iterator_tag, Type>
-  {
-    const MVKVector *vector;
-    size_t           index;
-
-  public:
-    iterator() = delete;
-    iterator( const size_t _index, const MVKVector &_vector ) : vector{ &_vector }, index{ _index } { }
-    iterator &operator=( const iterator &it ) = delete;
-
-    Type *operator->() const { return &vector->alc_ptr->ptr[index]; }
-    Type &operator*()  const { return  vector->alc_ptr->ptr[index]; }
-    operator Type*( )  const { return &vector->alc_ptr->ptr[index]; }
-
-    bool operator==( const iterator &it ) const { return vector == it.vector && index == it.index; }
-    bool operator!=( const iterator &it ) const { return vector != it.vector || index != it.index; }
-
-    iterator& operator++()      {                 ++index; return *this; }
-    iterator  operator++( int ) { auto t = *this; ++index; return t; }
-
-    bool   is_valid()     const { return index < vector->size(); }
-    size_t get_position() const { return index; }
-  };
-
-public:
-  typedef Type value_type;
-
-  MVKVector() = delete;
-  MVKVector( mvk_vector_allocator_base<Type> *a ) : alc_ptr{ a } { }
-  virtual ~MVKVector() { }
-
-  iterator begin() const { return iterator( 0,               *this ); }
-  iterator end()   const { return iterator( alc_ptr->size(), *this ); }
-
-  const MVKArrayRef<Type> contents() const { return MVKArrayRef<Type>(data(), size()); }
-        MVKArrayRef<Type> contents()       { return MVKArrayRef<Type>(data(), size()); }
-
-  virtual const Type &operator[]( const size_t i ) const                  = 0;
-  virtual       Type &operator[]( const size_t i )                        = 0;
-  virtual const Type &at( const size_t i ) const                          = 0;
-  virtual       Type &at( const size_t i )                                = 0;
-  virtual const Type &front() const                                       = 0;
-  virtual       Type &front()                                             = 0;
-  virtual const Type &back() const                                        = 0;
-  virtual       Type &back()                                              = 0;
-  virtual const Type *data() const                                        = 0;
-  virtual       Type *data()                                              = 0;
-
-  virtual size_t      size()     const                                    = 0;
-  virtual bool        empty()    const                                    = 0;
-  virtual size_t      capacity() const                                    = 0;
-
-  virtual void        pop_back()                                          = 0;
-  virtual void        clear()                                             = 0;
-  virtual void        reset()                                             = 0;
-  virtual void        reserve( const size_t new_size )                    = 0;
-  virtual void        assign( const size_t new_size, const Type &t )      = 0;
-  virtual void        resize( const size_t new_size, const Type t = { } ) = 0;
-  virtual void        shrink_to_fit()                                     = 0;
-  virtual void        push_back( const Type &t )                          = 0;
-  virtual void        push_back( Type &&t )                               = 0;
-};
-
-
-template<class Type> class MVKVector<Type *>
-{
-  mvk_vector_allocator_base<Type*> *alc_ptr;
-
-  class iterator : public std::iterator<std::forward_iterator_tag, Type*>
-  {
-    const MVKVector *vector;
-    size_t           index;
-
-  public:
-    iterator() = delete;
-    iterator( const size_t _index, const MVKVector &_vector ) : vector{ &_vector }, index{ _index } { }
-    iterator &operator=( const iterator &it ) = delete;
-
-    Type *operator->() const { return vector->alc_ptr->ptr[index]; }
-    Type *&operator*()       { return vector->alc_ptr->ptr[index]; }
-    operator Type*&()  const { return &vector->alc_ptr->ptr[index]; }
-
-    bool operator==( const iterator &it ) const { return vector == it.vector && index == it.index; }
-    bool operator!=( const iterator &it ) const { return vector != it.vector || index != it.index; }
-
-    iterator& operator++()      {                 ++index; return *this; }
-    iterator  operator++( int ) { auto t = *this; ++index; return t; }
-
-    bool   is_valid()     const { return index < vector->size(); }
-    size_t get_position() const { return index; }
-  };
-
-public:
-  typedef Type* value_type;
-
-  MVKVector() = delete;
-  MVKVector( mvk_vector_allocator_base<Type*> *a ) : alc_ptr{ a } { }
-  virtual ~MVKVector() { }
-
-  iterator begin() const { return iterator( 0,               *this ); }
-  iterator end()   const { return iterator( alc_ptr->size(), *this ); }
-
-  const MVKArrayRef<Type*> contents() const { return MVKArrayRef<Type*>(data(), size()); }
-        MVKArrayRef<Type*> contents()       { return MVKArrayRef<Type*>(data(), size()); }
-
-  virtual const Type * const  operator[]( const size_t i ) const             = 0;
-  virtual       Type *       &operator[]( const size_t i )                   = 0;
-  virtual const Type * const  at( const size_t i ) const                     = 0;
-  virtual       Type *       &at( const size_t i )                           = 0;
-  virtual const Type * const  front() const                                  = 0;
-  virtual       Type *       &front()                                        = 0;
-  virtual const Type * const  back() const                                   = 0;
-  virtual       Type *       &back()                                         = 0;
-  virtual const Type * const *data() const                                   = 0;
-  virtual       Type *       *data()                                         = 0;
-
-  virtual size_t              size() const                                   = 0;
-  virtual bool                empty() const                                  = 0;
-  virtual size_t              capacity() const                               = 0;
-
-  virtual void                pop_back()                                     = 0;
-  virtual void                clear()                                        = 0;
-  virtual void                reset()                                        = 0;
-  virtual void                reserve( const size_t new_size )               = 0;
-  virtual void                assign( const size_t new_size, const Type *t ) = 0;
-  virtual void                resize( const size_t new_size, const Type *t = nullptr ) = 0;
-  virtual void                shrink_to_fit()                                = 0;
-  virtual void                push_back( const Type *t )                     = 0;
-};
-
-
-// this is the actual implementation of MVKVector
-template<class Type, typename Allocator = mvk_vector_allocator_default<Type>> class MVKVectorImpl : public MVKVector<Type>
-{
-  friend class MVKVectorImpl;
-
-  Allocator  alc;
-  
-public:
-  class iterator : public std::iterator<std::forward_iterator_tag, Type>
-  {
-    const MVKVectorImpl *vector;
-    size_t               index;
-
-  public:
-    iterator() = delete;
-    iterator( const size_t _index, const MVKVectorImpl &_vector ) : vector{ &_vector }, index{ _index } { }
-
-    iterator &operator=( const iterator &it )
-    {
-      vector = it.vector;
-      index  = it.index;
-      return *this;
-    }
-
-    Type *operator->() { return &vector->alc.ptr[index]; }
-    Type &operator*()  { return  vector->alc.ptr[index]; }
-    operator Type*()   { return &vector->alc.ptr[index]; }
-
-    bool operator==( const iterator &it ) const { return vector == it.vector && index == it.index; }
-    bool operator!=( const iterator &it ) const { return vector != it.vector || index != it.index; }
-
-    iterator& operator++()      {                 ++index; return *this; }
-    iterator  operator++( int ) { auto t = *this; ++index; return t; }
-
-    bool   is_valid()     const { return index < vector->alc.size(); }
-    size_t get_position() const { return index; }
-  };
-
-private:
-  // this is the growth strategy -> adjust to your needs
-  size_t vector_GetNextCapacity() const
-  {
-    constexpr auto ELEMENTS_FOR_64_BYTES = 64 / sizeof( Type );
-    constexpr auto MINIMUM_CAPACITY = ELEMENTS_FOR_64_BYTES > 4 ? ELEMENTS_FOR_64_BYTES : 4;
-    const auto current_capacity = capacity();
-    return MINIMUM_CAPACITY + ( 3 * current_capacity ) / 2;
-  }
-
-  void vector_Allocate( const size_t s )
-  {
-    const auto new_reserved_size = s > size() ? s : size();
-
-    alc.allocate( new_reserved_size );
-  }
-
-  void vector_ReAllocate( const size_t s )
-  {
-    alc.re_allocate( s );
-  }
-
-public:
-  MVKVectorImpl() : MVKVector<Type>{ &alc }
-  {
-  }
-
-  MVKVectorImpl( const size_t n, const Type t ) : MVKVector<Type>{ &alc }
-  {
-    if( n > 0 )
-    {
-      alc.allocate( n );
-
-      for( size_t i = 0; i < n; ++i )
-      {
-        alc.construct( &alc.ptr[i], t );
-      }
-
-      alc.num_elements_used = n;
-    }
-  }
-
-  MVKVectorImpl( const MVKVectorImpl &a ) : MVKVector<Type>{ &alc }
-  {
-    const size_t n = a.size();
-
-    if( n > 0 )
-    {
-      alc.allocate( n );
-
-      for( size_t i = 0; i < n; ++i )
-      {
-        alc.construct( &alc.ptr[i], a.alc.ptr[i] );
-      }
-
-      alc.num_elements_used = n;
-    }
-  }
-
-  template<typename U>
-  MVKVectorImpl( const U &a ) : MVKVector<Type>{ &alc }
-  {
-    const size_t n = a.size();
-
-    if( n > 0 )
-    {
-      alc.allocate( n );
-
-      for( size_t i = 0; i < n; ++i )
-      {
-        alc.construct( &alc.ptr[i], a[i] );
-      }
-
-      alc.num_elements_used = n;
-    }
-  }
-
-  MVKVectorImpl( MVKVectorImpl &&a ) : MVKVector<Type>{ &alc }, alc{ std::move( a.alc ) }
-  {
-  }
-
-  MVKVectorImpl( std::initializer_list<Type> vector ) : MVKVector<Type>{ &alc }
-  {
-    if( vector.size() > capacity() )
-    {
-      vector_Allocate( vector.size() );
-    }
-
-    // std::initializer_list does not yet support std::move, we use it anyway but it has no effect
-    for( auto &&element : vector )
-    {
-      alc.construct( &alc.ptr[alc.num_elements_used], std::move( element ) );
-      ++alc.num_elements_used;
-    }
-  }
-
-  ~MVKVectorImpl()
-  {
-  }
-
-  template<typename U>
-  MVKVectorImpl& operator=( const U &a )
-  {
-    static_assert( std::is_base_of<MVKVector<Type>, U>::value, "argument is not of type MVKVector" );
-
-    if( this != reinterpret_cast<const MVKVector<Type>*>( &a ) )
-    {
-      const auto n = a.size();
-
-      if( alc.num_elements_used == n )
-      {
-        for( size_t i = 0; i < n; ++i )
-        {
-          alc.ptr[i] = a.alc.ptr[i];
-        }
-      }
-      else
-      {
-        if( n > capacity() )
-        {
-          vector_ReAllocate( n );
-        }
-        else
-        {
-          alc.template destruct_all<Type>();
-        }
-
-        for( size_t i = 0; i < n; ++i )
-        {
-          alc.construct( &alc.ptr[i], a[i] );
-        }
-
-        alc.num_elements_used = n;
-      }
-    }
-
-    return *this;
-  }
-
-  MVKVectorImpl& operator=( MVKVectorImpl &&a )
-  {
-    alc.swap( a.alc );
-    return *this;
-  }
-
-  bool operator==( const MVKVectorImpl &a ) const
-  {
-    if( alc.num_elements_used != a.alc.num_elements_used )
-      return false;
-    for( size_t i = 0; i < alc.num_elements_used; ++i )
-    {
-      if( alc[i] != a.alc[i] )
-        return false;
-    }
-    return true;
-  }
-
-  bool operator!=( const MVKVectorImpl &a ) const
-  {
-    if( alc.num_elements_used != a.alc.num_elements_used )
-      return true;
-    for( size_t i = 0; i < alc.num_elements_used; ++i )
-    {
-      if( alc.ptr[i] != a.alc[i] )
-        return true;
-    }
-    return false;
-  }
-
-  void swap( MVKVectorImpl &a )
-  {
-    alc.swap( a.alc );
-  }
-
-  iterator begin() const { return iterator( 0, *this ); }
-  iterator end()   const { return iterator( alc.num_elements_used, *this ); }
-
-  const Type &operator[]( const size_t i ) const override { return alc[i]; }
-        Type &operator[]( const size_t i )       override { return alc[i]; }
-  const Type &at( const size_t i )         const override { return alc[i]; }
-        Type &at( const size_t i )               override { return alc[i]; }
-  const Type &front()                      const override { return alc[0]; }
-        Type &front()                            override { return alc[0]; }
-  const Type &back()                       const override { return alc[alc.num_elements_used - 1]; }
-        Type &back()                             override { return alc[alc.num_elements_used - 1]; }
-  const Type *data()                       const override { return alc.ptr; }
-        Type *data()                             override { return alc.ptr; }
-
-  size_t      size()                       const override { return alc.num_elements_used; }
-  bool        empty()                      const override { return alc.num_elements_used == 0; }
-  size_t      capacity()                   const override { return alc.get_capacity(); }
-
-  void pop_back() override
-  {
-    if( alc.num_elements_used > 0 )
-    {
-      --alc.num_elements_used;
-      alc.destruct( &alc.ptr[alc.num_elements_used] );
-    }
-  }
-
-  void clear() override
-  {
-    alc.template destruct_all<Type>();
-  }
-
-  void reset() override
-  {
-    alc.deallocate();
-  }
-
-  void reserve( const size_t new_size ) override
-  {
-    if( new_size > capacity() )
-    {
-      vector_ReAllocate( new_size );
-    }
-  }
-
-  void assign( const size_t new_size, const Type &t ) override
-  {
-    if( new_size <= capacity() )
-    {
-      clear();
-    }
-    else
-    {
-      vector_Allocate( new_size );
-    }
-
-    for( size_t i = 0; i < new_size; ++i )
-    {
-      alc.construct( &alc.ptr[i], t );
-    }
-
-    alc.num_elements_used = new_size;
-  }
-
-  template <class InputIterator>
-  void assign( InputIterator first, InputIterator last )
-  {
-    clear();
-
-    while( first != last )
-    {
-      emplace_back( *first );
-      ++first;
-    }
-  }
-
-  void resize( const size_t new_size, const Type t = { } ) override
-  {
-    if( new_size == alc.num_elements_used )
-    {
-      return;
-    }
-
-    if( new_size == 0 )
-    {
-      clear();
-      return;
-    }
-
-    if( new_size > alc.num_elements_used )
-    {
-      if( new_size > capacity() )
-      {
-        vector_ReAllocate( new_size );
-      }
-
-      while( alc.num_elements_used < new_size )
-      {
-        alc.construct( &alc.ptr[alc.num_elements_used], t );
-        ++alc.num_elements_used;
-      }
-    }
-    else
-    {
-      //if constexpr( !std::is_trivially_destructible<Type>::value )
-      {
-        while( alc.num_elements_used > new_size )
-        {
-          --alc.num_elements_used;
-          alc.destruct( &alc.ptr[alc.num_elements_used] );
-        }
-      }
-      //else
-      //{
-      //  alc.num_elements_used = new_size;
-      //}
-    }
-  }
-
-  // trims the capacity of the slist to the number of alc.ptr
-  void shrink_to_fit() override
-  {
-    alc.shrink_to_fit();
-  }
-
-  void erase( const iterator it )
-  {
-    if( it.is_valid() )
-    {
-      --alc.num_elements_used;
-
-      for( size_t i = it.get_position(); i < alc.num_elements_used; ++i )
-      {
-        alc.ptr[i] = std::move( alc.ptr[i + 1] );
-      }
-
-      // this is required for types with a destructor
-      alc.destruct( &alc.ptr[alc.num_elements_used] );
-    }
-  }
-
-  void erase( const iterator first, const iterator last )
-  {
-    if( first.is_valid() )
-    {
-      size_t last_pos = last.is_valid() ? last.get_position() : size();
-      size_t n = last_pos - first.get_position();
-      alc.num_elements_used -= n;
-
-      for( size_t i = first.get_position(), e = last_pos; i < alc.num_elements_used && e < alc.num_elements_used + n; ++i, ++e )
-      {
-        alc.ptr[i] = std::move( alc.ptr[e] );
-      }
-
-      // this is required for types with a destructor
-      for( size_t i = alc.num_elements_used; i < alc.num_elements_used + n; ++i )
-      {
-        alc.destruct( &alc.ptr[i] );
-      }
-    }
-  }
-
-  // adds t before it and automatically resizes vector if necessary
-  void insert( const iterator it, Type t )
-  {
-    if( !it.is_valid() || alc.num_elements_used == 0 )
-    {
-      push_back( std::move( t ) );
-    }
-    else
-    {
-      if( alc.num_elements_used == capacity() )
-        vector_ReAllocate( vector_GetNextCapacity() );
-
-      // move construct last element
-      alc.construct( &alc.ptr[alc.num_elements_used], std::move( alc.ptr[alc.num_elements_used - 1] ) );
-
-      // move the remaining elements
-      const size_t it_position = it.get_position();
-      for( size_t i = alc.num_elements_used - 1; i > it_position; --i )
-      {
-        alc.ptr[i] = std::move( alc.ptr[i - 1] );
-      }
-
-      alc.ptr[it_position] = std::move( t );
-      ++alc.num_elements_used;
-    }
-  }
-
-  void push_back( const Type &t ) override
-  {
-    if( alc.num_elements_used == capacity() )
-      vector_ReAllocate( vector_GetNextCapacity() );
-
-    alc.construct( &alc.ptr[alc.num_elements_used], t );
-    ++alc.num_elements_used;
-  }
-
-  void push_back( Type &&t ) override
-  {
-    if( alc.num_elements_used == capacity() )
-      vector_ReAllocate( vector_GetNextCapacity() );
-
-    alc.construct( &alc.ptr[alc.num_elements_used], std::forward<Type>( t ) );
-    ++alc.num_elements_used;
-  }
-
-  template<class... Args>
-  Type &emplace_back( Args&&... args )
-  {
-    if( alc.num_elements_used == capacity() )
-      vector_ReAllocate( vector_GetNextCapacity() );
-
-    alc.construct( &alc.ptr[alc.num_elements_used], std::forward<Args>( args )... );
-    ++alc.num_elements_used;
-
-    return alc.ptr[alc.num_elements_used - 1];
-  }
-};
-
-// specialization for pointer types
-template<class Type, typename Allocator> class MVKVectorImpl<Type*, Allocator> : public MVKVector<Type*>
-{
-  friend class MVKVectorImpl;
-
-  Allocator  alc;
-
-public:
-  class iterator : public std::iterator<std::forward_iterator_tag, Type*>
-  {
-    MVKVectorImpl *vector;
-    size_t         index;
-
-  public:
-    iterator() = delete;
-    iterator( const size_t _index, MVKVectorImpl &_vector ) : vector{ &_vector }, index{ _index } { }
-
-    iterator &operator=( const iterator &it )
-    {
-      vector = it.vector;
-      index = it.index;
-      return *this;
-    }
-
-    Type *&operator*() { return vector->alc[index]; }
-
-    bool operator==( const iterator &it ) const { return vector == it.vector && index == it.index; }
-    bool operator!=( const iterator &it ) const { return vector != it.vector || index != it.index; }
-
-    iterator& operator++() { ++index; return *this; }
-    iterator  operator++( int ) { auto t = *this; ++index; return t; }
-
-    bool   is_valid()     const { return index < vector->alc.size(); }
-    size_t get_position() const { return index; }
-  };
-
-private:
-  // this is the growth strategy -> adjust to your needs
-  size_t vector_GetNextCapacity() const
-  {
-    constexpr auto ELEMENTS_FOR_64_BYTES = 64 / sizeof( Type* );
-    constexpr auto MINIMUM_CAPACITY = ELEMENTS_FOR_64_BYTES > 4 ? ELEMENTS_FOR_64_BYTES : 4;
-    const auto current_capacity = capacity();
-    return MINIMUM_CAPACITY + ( 3 * current_capacity ) / 2;
-  }
-
-  void vector_Allocate( const size_t s )
-  {
-    const auto new_reserved_size = s > size() ? s : size();
-
-    alc.allocate( new_reserved_size );
-  }
-
-  void vector_ReAllocate( const size_t s )
-  {
-    alc.re_allocate( s );
-  }
-
-public:
-  MVKVectorImpl() : MVKVector<Type*>{ &alc }
-  {
-  }
-
-  MVKVectorImpl( const size_t n, const Type *t ) : MVKVector<Type*>{ &alc }
-  {
-    if ( n > 0 )
-    {
-      alc.allocate( n );
-
-      for ( size_t i = 0; i < n; ++i )
-      {
-        alc.ptr[i] = t;
-      }
-
-      alc.num_elements_used = n;
-    }
-  }
-
-  MVKVectorImpl( const MVKVectorImpl &a ) : MVKVector<Type*>{ &alc }
-  {
-    const size_t n = a.size();
-
-    if ( n > 0 )
-    {
-      alc.allocate( n );
-
-      for ( size_t i = 0; i < n; ++i )
-      {
-        alc.ptr[i] = a.alc.ptr[i];
-      }
-
-      alc.num_elements_used = n;
-    }
-  }
-
-  MVKVectorImpl( MVKVectorImpl &&a ) : MVKVector<Type*>{ &alc }, alc{ std::move( a.alc ) }
-  {
-  }
-
-  MVKVectorImpl( std::initializer_list<Type*> vector ) : MVKVector<Type*>{ &alc }
-  {
-    if ( vector.size() > capacity() )
-    {
-      vector_Allocate( vector.size() );
-    }
-
-    // std::initializer_list does not yet support std::move, we use it anyway but it has no effect
-    for ( auto element : vector )
-    {
-      alc.ptr[alc.num_elements_used] = element;
-      ++alc.num_elements_used;
-    }
-  }
-
-  ~MVKVectorImpl()
-  {
-  }
-
-  template<typename U>
-  MVKVectorImpl& operator=( const U &a )
-  {
-    static_assert( std::is_base_of<MVKVector<U>, U>::value, "argument is not of type MVKVector" );
-
-    if ( this != reinterpret_cast< const MVKVector<Type>* >( &a ) )
-    {
-      const auto n = a.size();
-
-      if ( alc.num_elements_used == n )
-      {
-        for ( size_t i = 0; i < n; ++i )
-        {
-          alc.ptr[i] = a.alc.ptr[i];
-        }
-      }
-      else
-      {
-        if ( n > capacity() )
-        {
-          vector_ReAllocate( n );
-        }
-
-        for ( size_t i = 0; i < n; ++i )
-        {
-          alc.ptr[i] = a[i];
-        }
-
-        alc.num_elements_used = n;
-      }
-    }
-
-    return *this;
-  }
-
-  MVKVectorImpl& operator=( MVKVectorImpl &&a )
-  {
-    alc.swap( a.alc );
-    return *this;
-  }
-
-  bool operator==( const MVKVectorImpl &a ) const
-  {
-    if ( alc.num_elements_used != a.alc.num_elements_used )
-      return false;
-    for ( size_t i = 0; i < alc.num_elements_used; ++i )
-    {
-      if ( alc[i] != a.alc[i] )
-        return false;
-    }
-    return true;
-  }
-
-  bool operator!=( const MVKVectorImpl &a ) const
-  {
-    if ( alc.num_elements_used != a.alc.num_elements_used )
-      return true;
-    for ( size_t i = 0; i < alc.num_elements_used; ++i )
-    {
-      if ( alc.ptr[i] != a.alc[i] )
-        return true;
-    }
-    return false;
-  }
-
-  void swap( MVKVectorImpl &a )
-  {
-    alc.swap( a.alc );
-  }
-
-  iterator begin()        { return iterator( 0, *this ); }
-  iterator end()          { return iterator( alc.num_elements_used, *this ); }
-
-  const Type * const  at( const size_t i )         const override { return alc[i]; }
-        Type *       &at( const size_t i )               override { return alc[i]; }
-  const Type * const  operator[]( const size_t i ) const override { return alc[i]; }
-        Type *       &operator[]( const size_t i )       override { return alc[i]; }
-  const Type * const  front()                      const override { return alc[0]; }
-        Type *       &front()                            override { return alc[0]; }
-  const Type * const  back()                       const override { return alc[alc.num_elements_used - 1]; }
-        Type *       &back()                             override { return alc[alc.num_elements_used - 1]; }
-  const Type * const *data()                       const override { return alc.ptr; }
-        Type *       *data()                             override { return alc.ptr; }
-
-  size_t   size()                                  const override { return alc.num_elements_used; }
-  bool     empty()                                 const override { return alc.num_elements_used == 0; }
-  size_t   capacity()                              const override { return alc.get_capacity(); }
-
-  void pop_back() override
-  {
-    if ( alc.num_elements_used > 0 )
-    {
-      --alc.num_elements_used;
-    }
-  }
-
-  void clear() override
-  {
-    alc.num_elements_used = 0;
-  }
-
-  void reset() override
-  {
-    alc.deallocate();
-  }
-
-  void reserve( const size_t new_size ) override
-  {
-    if ( new_size > capacity() )
-    {
-      vector_ReAllocate( new_size );
-    }
-  }
-
-  void assign( const size_t new_size, const Type *t ) override
-  {
-    if ( new_size <= capacity() )
-    {
-      clear();
-    }
-    else
-    {
-      vector_Allocate( new_size );
-    }
-
-    for ( size_t i = 0; i < new_size; ++i )
-    {
-      alc.ptr[i] = const_cast< Type* >( t );
-    }
-
-    alc.num_elements_used = new_size;
-  }
-
-  void resize( const size_t new_size, const Type *t = nullptr ) override
-  {
-    if ( new_size == alc.num_elements_used )
-    {
-      return;
-    }
-
-    if ( new_size == 0 )
-    {
-      clear();
-      return;
-    }
-
-    if ( new_size > alc.num_elements_used )
-    {
-      if ( new_size > capacity() )
-      {
-        vector_ReAllocate( new_size );
-      }
-
-      while ( alc.num_elements_used < new_size )
-      {
-        alc.ptr[alc.num_elements_used] = const_cast< Type* >( t );
-        ++alc.num_elements_used;
-      }
-    }
-    else
-    {
-      alc.num_elements_used = new_size;
-    }
-  }
-
-  // trims the capacity of the MVKVector to the number of used elements
-  void shrink_to_fit() override
-  {
-    alc.shrink_to_fit();
-  }
-
-  void erase( const iterator it )
-  {
-    if ( it.is_valid() )
-    {
-      --alc.num_elements_used;
-
-      for ( size_t i = it.get_position(); i < alc.num_elements_used; ++i )
-      {
-        alc.ptr[i] = alc.ptr[i + 1];
-      }
-    }
-  }
-
-  void erase( const iterator first, const iterator last )
-  {
-    if( first.is_valid() )
-    {
-      size_t last_pos = last.is_valid() ? last.get_position() : size();
-      size_t n = last_pos - first.get_position();
-      alc.num_elements_used -= n;
-
-      for( size_t i = first.get_position(), e = last_pos; i < alc.num_elements_used && e < alc.num_elements_used + n; ++i, ++e )
-      {
-        alc.ptr[i] = alc.ptr[e];
-      }
-    }
-  }
-
-  // adds t before position it and automatically resizes vector if necessary
-  void insert( const iterator it, const Type *t )
-  {
-    if ( !it.is_valid() || alc.num_elements_used == 0 )
-    {
-      push_back( t );
-    }
-    else
-    {
-      if ( alc.num_elements_used == capacity() )
-        vector_ReAllocate( vector_GetNextCapacity() );
-
-      // move the remaining elements
-      const size_t it_position = it.get_position();
-      for ( size_t i = alc.num_elements_used; i > it_position; --i )
-      {
-        alc.ptr[i] = alc.ptr[i - 1];
-      }
-
-      alc.ptr[it_position] = const_cast< Type* >( t );
-      ++alc.num_elements_used;
-    }
-  }
-
-  void push_back( const Type *t ) override
-  {
-    if ( alc.num_elements_used == capacity() )
-      vector_ReAllocate( vector_GetNextCapacity() );
-
-    alc.ptr[alc.num_elements_used] = const_cast< Type* >( t );
-    ++alc.num_elements_used;
-  }
-};
-
-
-template<typename Type>
-using MVKVectorDefault = MVKVectorImpl<Type, mvk_vector_allocator_default<Type>>;
-
-template<typename Type, size_t N = 8>
-using MVKVectorInline  = MVKVectorImpl<Type, mvk_vector_allocator_with_stack<Type, N>>;
-
-
-#endif
-
-
diff --git a/MoltenVK/MoltenVK/Utility/MVKVectorAllocator.h b/MoltenVK/MoltenVK/Utility/MVKVectorAllocator.h
deleted file mode 100755
index 38623c0..0000000
--- a/MoltenVK/MoltenVK/Utility/MVKVectorAllocator.h
+++ /dev/null
@@ -1,552 +0,0 @@
-/*
- * MVKVectorAllocator.h
- *
- * Copyright (c) 2012-2020 Dr. Torsten Hans (hans@ipacs.de)
- *
- * 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.
- */
-
-#pragma once
-
-#include <new>
-#include <type_traits>
-
-
-#define MVK_VECTOR_CHECK_BOUNDS if (i >= num_elements_used) { throw std::out_of_range("Index out of range"); }
-
-
-namespace mvk_memory_allocator
-{
-  inline char *alloc( const size_t num_bytes )
-  {
-    return new char[num_bytes];
-  }
-
-  inline void free( void *ptr )
-  {
-    delete[] (char*)ptr;
-  }
-};
-
-
-//////////////////////////////////////////////////////////////////////////////////////////
-//
-// mvk_vector_allocator_base -> base class so we can use MVKVector with template parameter
-//
-//////////////////////////////////////////////////////////////////////////////////////////
-template<typename T>
-class mvk_vector_allocator_base
-{
-public:
-  typedef T value_type;
-  T      *ptr;
-  size_t  num_elements_used;
-
-public:
-  mvk_vector_allocator_base()                                           : ptr{ nullptr }, num_elements_used{ 0 }                  { }
-  mvk_vector_allocator_base( T *_ptr, const size_t _num_elements_used ) : ptr{ _ptr },    num_elements_used{ _num_elements_used } { }
-  virtual ~mvk_vector_allocator_base() { }
-
-  const T &operator[]( const size_t i ) const { MVK_VECTOR_CHECK_BOUNDS return ptr[i]; }
-  T       &operator[]( const size_t i )       { MVK_VECTOR_CHECK_BOUNDS return ptr[i]; }
-
-  size_t size() const { return num_elements_used; }
-
-  virtual size_t get_capacity() const = 0;
-  virtual void   allocate( const size_t num_elements_to_reserve ) = 0;
-  virtual void   re_allocate( const size_t num_elements_to_reserve ) = 0;
-  virtual void   shrink_to_fit() = 0;
-  virtual void   deallocate() = 0;
-};
-
-
-//////////////////////////////////////////////////////////////////////////////////////////
-//
-// mvk_vector_allocator_default -> malloc based allocator for MVKVector
-//
-//////////////////////////////////////////////////////////////////////////////////////////
-template <typename T>
-class mvk_vector_allocator_default final : public mvk_vector_allocator_base<T>
-{
-private:
-  size_t  num_elements_reserved;
-
-public:
-  template<class S, class... Args> typename std::enable_if< !std::is_trivially_constructible<S>::value >::type
-    construct( S *_ptr, Args&&... _args )
-  {
-    new ( _ptr ) S( std::forward<Args>( _args )... );
-  }
-
-  template<class S, class... Args> typename std::enable_if< std::is_trivially_constructible<S>::value >::type
-    construct( S *_ptr, Args&&... _args )
-  {
-    *_ptr = S( std::forward<Args>( _args )... );
-  }
-
-  template<class S> typename std::enable_if< !std::is_trivially_destructible<S>::value >::type
-    destruct( S *_ptr )
-  {
-    _ptr->~S();
-  }
-
-  template<class S> typename std::enable_if< std::is_trivially_destructible<S>::value >::type
-    destruct( S *_ptr )
-  {
-  }
-
-  template<class S> typename std::enable_if< !std::is_trivially_destructible<S>::value >::type
-    destruct_all()
-  {
-    for( size_t i = 0; i < mvk_vector_allocator_base<S>::num_elements_used; ++i )
-    {
-      mvk_vector_allocator_base<S>::ptr[i].~S();
-    }
-
-    mvk_vector_allocator_base<S>::num_elements_used = 0;
-  }
-
-  template<class S> typename std::enable_if< std::is_trivially_destructible<S>::value >::type
-    destruct_all()
-  {
-    mvk_vector_allocator_base<T>::num_elements_used = 0;
-  }
-
-public:
-  constexpr mvk_vector_allocator_default() : mvk_vector_allocator_base<T>{}, num_elements_reserved{ 0 }
-  {
-  }
-
-  mvk_vector_allocator_default( mvk_vector_allocator_default &&a ) : mvk_vector_allocator_base<T>{ a.ptr, a.num_elements_used }, num_elements_reserved{ a.num_elements_reserved }
-  {
-    a.ptr                   = nullptr;
-    a.num_elements_used     = 0;
-    a.num_elements_reserved = 0;
-  }
-
-  virtual ~mvk_vector_allocator_default()
-  {
-    deallocate();
-  }
-
-  size_t get_capacity() const override
-  {
-    return num_elements_reserved;
-  }
-
-  void swap( mvk_vector_allocator_default &a )
-  {
-    const auto copy_ptr                   = a.ptr;
-    const auto copy_num_elements_used     = a.num_elements_used;
-    const auto copy_num_elements_reserved = a.num_elements_reserved;
-
-    a.ptr                   = mvk_vector_allocator_base<T>::ptr;
-    a.num_elements_used     = mvk_vector_allocator_base<T>::num_elements_used;
-    a.num_elements_reserved = num_elements_reserved;
-
-    mvk_vector_allocator_base<T>::ptr                = copy_ptr;
-    mvk_vector_allocator_base<T>::num_elements_used  = copy_num_elements_used;
-    num_elements_reserved = copy_num_elements_reserved;
-  }
-
-  void allocate( const size_t num_elements_to_reserve ) override
-  {
-    deallocate();
-
-    mvk_vector_allocator_base<T>::ptr                = reinterpret_cast< T* >( mvk_memory_allocator::alloc( num_elements_to_reserve * sizeof( T ) ) );
-    mvk_vector_allocator_base<T>::num_elements_used  = 0;
-    num_elements_reserved = num_elements_to_reserve;
-  }
-
-  void re_allocate( const size_t num_elements_to_reserve ) override
-  {
-    //if constexpr( std::is_trivially_copyable<T>::value )
-    //{
-    //  ptr = reinterpret_cast< T* >( mvk_memory_allocator::tm_memrealloc( ptr, num_elements_to_reserve * sizeof( T ) );
-    //}
-    //else
-    {
-      auto *new_ptr = reinterpret_cast< T* >( mvk_memory_allocator::alloc( num_elements_to_reserve * sizeof( T ) ) );
-
-      for( size_t i = 0; i < mvk_vector_allocator_base<T>::num_elements_used; ++i )
-      {
-        construct( &new_ptr[i], std::move( mvk_vector_allocator_base<T>::ptr[i] ) );
-        destruct( &mvk_vector_allocator_base<T>::ptr[i] );
-      }
-
-      //if ( ptr != nullptr )
-      {
-        mvk_memory_allocator::free( mvk_vector_allocator_base<T>::ptr );
-      }
-
-      mvk_vector_allocator_base<T>::ptr = new_ptr;
-    }
-
-    num_elements_reserved = num_elements_to_reserve;
-  }
-
-  void shrink_to_fit() override
-  {
-    if( mvk_vector_allocator_base<T>::num_elements_used == 0 )
-    {
-      deallocate();
-    }
-    else
-    {
-      auto *new_ptr = reinterpret_cast< T* >( mvk_memory_allocator::alloc( mvk_vector_allocator_base<T>::num_elements_used * sizeof( T ) ) );
-
-      for( size_t i = 0; i < mvk_vector_allocator_base<T>::num_elements_used; ++i )
-      {
-        construct( &new_ptr[i], std::move( mvk_vector_allocator_base<T>::ptr[i] ) );
-        destruct( &mvk_vector_allocator_base<T>::ptr[i] );
-      }
-
-      mvk_memory_allocator::free( mvk_vector_allocator_base<T>::ptr );
-
-      mvk_vector_allocator_base<T>::ptr = new_ptr;
-      num_elements_reserved = mvk_vector_allocator_base<T>::num_elements_used;
-    }
-  }
-
-  void deallocate() override
-  {
-    destruct_all<T>();
-
-    mvk_memory_allocator::free( mvk_vector_allocator_base<T>::ptr );
-
-    mvk_vector_allocator_base<T>::ptr = nullptr;
-    num_elements_reserved = 0;
-  }
-};
-
-
-//////////////////////////////////////////////////////////////////////////////////////////
-//
-// mvk_vector_allocator_with_stack -> malloc based MVKVector allocator with preallocated storage
-//
-//////////////////////////////////////////////////////////////////////////////////////////
-template <typename T, int N>
-class mvk_vector_allocator_with_stack final : public mvk_vector_allocator_base<T>
-{
-private:
-  //size_t  num_elements_reserved; // uhh, num_elements_reserved is mapped onto the stack elements, let the fun begin
-  alignas( alignof( T ) ) unsigned char   elements_stack[N * sizeof( T )];
-
-  static_assert( N * sizeof( T ) >= sizeof( size_t ), "Initial static allocation must be at least 8 bytes. Increase the count of pre-allocated elements." );
-
-  void set_num_elements_reserved( const size_t num_elements_reserved )
-  {
-    *reinterpret_cast<size_t*>( &elements_stack[0] ) = num_elements_reserved;
-  }
-
-public:
-  //
-  // faster element construction and destruction using type traits
-  //
-  template<class S, class... Args> typename std::enable_if< !std::is_trivially_constructible<S, Args...>::value >::type
-    construct( S *_ptr, Args&&... _args )
-  {
-    new ( _ptr ) S( std::forward<Args>( _args )... );
-  }
-
-  template<class S, class... Args> typename std::enable_if< std::is_trivially_constructible<S, Args...>::value >::type
-    construct( S *_ptr, Args&&... _args )
-  {
-    *_ptr = S( std::forward<Args>( _args )... );
-  }
-
-  template<class S> typename std::enable_if< !std::is_trivially_destructible<S>::value >::type
-    destruct( S *_ptr )
-  {
-    _ptr->~S();
-  }
-
-  template<class S> typename std::enable_if< std::is_trivially_destructible<S>::value >::type
-    destruct( S *_ptr )
-  {
-  }
-
-  template<class S> typename std::enable_if< !std::is_trivially_destructible<S>::value >::type
-    destruct_all()
-  {
-    for( size_t i = 0; i < mvk_vector_allocator_base<S>::num_elements_used; ++i )
-    {
-      mvk_vector_allocator_base<S>::ptr[i].~S();
-    }
-
-    mvk_vector_allocator_base<S>::num_elements_used = 0;
-  }
-
-  template<class S> typename std::enable_if< std::is_trivially_destructible<S>::value >::type
-    destruct_all()
-  {
-    mvk_vector_allocator_base<S>::num_elements_used = 0;
-  }
-
-  template<class S> typename std::enable_if< !std::is_trivially_destructible<S>::value >::type
-    swap_stack( mvk_vector_allocator_with_stack &a )
-  {
-    T stack_copy[N];
-
-    for( size_t i = 0; i < mvk_vector_allocator_base<S>::num_elements_used; ++i )
-    {
-      construct( &stack_copy[i], std::move( S::ptr[i] ) );
-      destruct( &mvk_vector_allocator_base<S>::ptr[i] );
-    }
-
-    for( size_t i = 0; i < a.num_elements_used; ++i )
-    {
-      construct( &mvk_vector_allocator_base<S>::ptr[i], std::move( a.ptr[i] ) );
-      destruct( &mvk_vector_allocator_base<S>::ptr[i] );
-    }
-
-    for( size_t i = 0; i < mvk_vector_allocator_base<S>::num_elements_used; ++i )
-    {
-      construct( &a.ptr[i], std::move( stack_copy[i] ) );
-      destruct( &stack_copy[i] );
-    }
-  }
-
-  template<class S> typename std::enable_if< std::is_trivially_destructible<S>::value >::type
-    swap_stack( mvk_vector_allocator_with_stack &a )
-  {
-    constexpr int STACK_SIZE = N * sizeof( T );
-    for( int i = 0; i < STACK_SIZE; ++i )
-    {
-      const auto v = elements_stack[i];
-      elements_stack[i] = a.elements_stack[i];
-      a.elements_stack[i] = v;
-    }
-  }
-
-public:
-  mvk_vector_allocator_with_stack() : mvk_vector_allocator_base<T>{ reinterpret_cast<T*>( &elements_stack[0] ), 0 }
-  {
-  }
-
-  mvk_vector_allocator_with_stack( mvk_vector_allocator_with_stack &&a ) : mvk_vector_allocator_base<T>{ nullptr, a.num_elements_used }
-  {
-    // is a heap based -> steal ptr from a
-    if( !a.get_data_on_stack() )
-    {
-      mvk_vector_allocator_base<T>::ptr = a.ptr;
-      set_num_elements_reserved( a.get_capacity() );
-
-      a.ptr = a.get_default_ptr();
-    }
-    else
-    {
-      mvk_vector_allocator_base<T>::ptr = get_default_ptr();
-      for( size_t i = 0; i < a.num_elements_used; ++i )
-      {
-        construct( &mvk_vector_allocator_base<T>::ptr[i], std::move( a.ptr[i] ) );
-        destruct( &a.ptr[i] );
-      }
-    }
-
-    a.num_elements_used = 0;
-  }
-
-  ~mvk_vector_allocator_with_stack()
-  {
-    deallocate();
-  }
-
-  size_t get_capacity() const override
-  {
-    return get_data_on_stack() ? N : *reinterpret_cast<const size_t*>( &elements_stack[0] );
-  }
-
-  constexpr T *get_default_ptr() const
-  {
-    return reinterpret_cast< T* >( const_cast< unsigned char * >( &elements_stack[0] ) );
-  }
-
-  bool get_data_on_stack() const
-  {
-    return mvk_vector_allocator_base<T>::ptr == get_default_ptr();
-  }
-
-  void swap( mvk_vector_allocator_with_stack &a )
-  {
-    // both allocators on heap -> easy case
-    if( !get_data_on_stack() && !a.get_data_on_stack() )
-    {
-      auto copy_ptr = mvk_vector_allocator_base<T>::ptr;
-      auto copy_num_elements_reserved = get_capacity();
-      mvk_vector_allocator_base<T>::ptr = a.ptr;
-      set_num_elements_reserved( a.get_capacity() );
-      a.ptr = copy_ptr;
-      a.set_num_elements_reserved( copy_num_elements_reserved );
-    }
-    // both allocators on stack -> just switch the stack contents
-    else if( get_data_on_stack() && a.get_data_on_stack() )
-    {
-      swap_stack<T>( a );
-    }
-    else if( get_data_on_stack() && !a.get_data_on_stack() )
-    {
-      auto copy_ptr = a.ptr;
-      auto copy_num_elements_reserved = a.get_capacity();
-
-      a.ptr = a.get_default_ptr();
-      for( size_t i = 0; i < mvk_vector_allocator_base<T>::num_elements_used; ++i )
-      {
-        construct( &a.ptr[i], std::move( mvk_vector_allocator_base<T>::ptr[i] ) );
-        destruct( &mvk_vector_allocator_base<T>::ptr[i] );
-      }
-
-      mvk_vector_allocator_base<T>::ptr = copy_ptr;
-      set_num_elements_reserved( copy_num_elements_reserved );
-    }
-    else if( !get_data_on_stack() && a.get_data_on_stack() )
-    {
-      auto copy_ptr = mvk_vector_allocator_base<T>::ptr;
-      auto copy_num_elements_reserved = get_capacity();
-
-      mvk_vector_allocator_base<T>::ptr = get_default_ptr();
-      for( size_t i = 0; i < a.num_elements_used; ++i )
-      {
-        construct( &mvk_vector_allocator_base<T>::ptr[i], std::move( a.ptr[i] ) );
-        destruct( &a.ptr[i] );
-      }
-
-      a.ptr = copy_ptr;
-      a.set_num_elements_reserved( copy_num_elements_reserved );
-    }
-
-    auto copy_num_elements_used = mvk_vector_allocator_base<T>::num_elements_used;
-    mvk_vector_allocator_base<T>::num_elements_used = a.num_elements_used;
-    a.num_elements_used = copy_num_elements_used;
-  }
-
-  //
-  // allocates rounded up to the defined alignment the number of bytes / if the system cannot allocate the specified amount of memory then a null block is returned
-  //
-  void allocate( const size_t num_elements_to_reserve ) override
-  {
-    deallocate();
-
-    // check if enough memory on stack space is left
-    if( num_elements_to_reserve <= N )
-    {
-      return;
-    }
-
-    mvk_vector_allocator_base<T>::ptr               = reinterpret_cast< T* >( mvk_memory_allocator::alloc( num_elements_to_reserve * sizeof( T ) ) );
-    mvk_vector_allocator_base<T>::num_elements_used = 0;
-    set_num_elements_reserved( num_elements_to_reserve );
-  }
-
-  //template<class S> typename std::enable_if< !std::is_trivially_copyable<S>::value >::type
-  void _re_allocate( const size_t num_elements_to_reserve )
-  {
-    auto *new_ptr = reinterpret_cast< T* >( mvk_memory_allocator::alloc( num_elements_to_reserve * sizeof( T ) ) );
-
-    for( size_t i = 0; i < mvk_vector_allocator_base<T>::num_elements_used; ++i )
-    {
-      construct( &new_ptr[i], std::move( mvk_vector_allocator_base<T>::ptr[i] ) );
-      destruct( &mvk_vector_allocator_base<T>::ptr[i] );
-    }
-
-    if( mvk_vector_allocator_base<T>::ptr != get_default_ptr() )
-    {
-      mvk_memory_allocator::free( mvk_vector_allocator_base<T>::ptr );
-    }
-
-    mvk_vector_allocator_base<T>::ptr = new_ptr;
-    set_num_elements_reserved( num_elements_to_reserve );
-  }
-
-  //template<class S> typename std::enable_if< std::is_trivially_copyable<S>::value >::type
-  //  _re_allocate( const size_t num_elements_to_reserve )
-  //{
-  //  const bool data_is_on_stack = get_data_on_stack();
-  //
-  //  auto *new_ptr = reinterpret_cast< S* >( mvk_memory_allocator::tm_memrealloc( data_is_on_stack ? nullptr : ptr, num_elements_to_reserve * sizeof( S ) ) );
-  //  if( data_is_on_stack )
-  //  {
-  //    for( int i = 0; i < N; ++i )
-  //    {
-  //      new_ptr[i] = ptr[i];
-  //    }
-  //  }
-  //
-  //  ptr = new_ptr;
-  //  set_num_elements_reserved( num_elements_to_reserve );
-  //}
-
-  void re_allocate( const size_t num_elements_to_reserve ) override
-  {
-    //TM_ASSERT( num_elements_to_reserve > get_capacity() );
-
-    if( num_elements_to_reserve > N )
-    {
-      _re_allocate( num_elements_to_reserve );
-    }
-  }
-
-  void shrink_to_fit() override
-  {
-    // nothing to do if data is on stack already
-    if( get_data_on_stack() )
-      return;
-
-    // move elements to stack space
-    if( mvk_vector_allocator_base<T>::num_elements_used <= N )
-    {
-      //const auto num_elements_reserved = get_capacity();
-
-      auto *stack_ptr = get_default_ptr();
-      for( size_t i = 0; i < mvk_vector_allocator_base<T>::num_elements_used; ++i )
-      {
-        construct( &stack_ptr[i], std::move( mvk_vector_allocator_base<T>::ptr[i] ) );
-        destruct( &mvk_vector_allocator_base<T>::ptr[i] );
-      }
-
-      mvk_memory_allocator::free( mvk_vector_allocator_base<T>::ptr );
-
-      mvk_vector_allocator_base<T>::ptr = stack_ptr;
-    }
-    else
-    {
-      auto *new_ptr = reinterpret_cast< T* >( mvk_memory_allocator::alloc( mvk_vector_allocator_base<T>::num_elements_used * sizeof( T ) ) );
-
-      for( size_t i = 0; i < mvk_vector_allocator_base<T>::num_elements_used; ++i )
-      {
-        construct( &new_ptr[i], std::move( mvk_vector_allocator_base<T>::ptr[i] ) );
-        destruct( &mvk_vector_allocator_base<T>::ptr[i] );
-      }
-
-      mvk_memory_allocator::free( mvk_vector_allocator_base<T>::ptr );
-
-      mvk_vector_allocator_base<T>::ptr = new_ptr;
-      set_num_elements_reserved( mvk_vector_allocator_base<T>::num_elements_used );
-    }
-  }
-
-  void deallocate() override
-  {
-    destruct_all<T>();
-
-    if( !get_data_on_stack() )
-    {
-      mvk_memory_allocator::free( mvk_vector_allocator_base<T>::ptr );
-    }
-
-    mvk_vector_allocator_base<T>::ptr = get_default_ptr();
-    mvk_vector_allocator_base<T>::num_elements_used = 0;
-  }
-};
-
-
diff --git a/MoltenVK/MoltenVK/Vulkan/mvk_datatypes.mm b/MoltenVK/MoltenVK/Vulkan/mvk_datatypes.mm
index f348b54..0d22e17 100644
--- a/MoltenVK/MoltenVK/Vulkan/mvk_datatypes.mm
+++ b/MoltenVK/MoltenVK/Vulkan/mvk_datatypes.mm
@@ -638,7 +638,7 @@
 		case VK_SHADER_STAGE_COMPUTE_BIT:					return kMVKShaderStageCompute;
 		default:
 			MVKBaseObject::reportError(mvkObj, VK_ERROR_FORMAT_NOT_SUPPORTED, "VkShaderStage %x is not supported.", vkStage);
-			return kMVKShaderStageMax;
+			return kMVKShaderStageCount;
 	}
 }
 
@@ -650,8 +650,8 @@
 		/* FIXME: kMVKShaderStageGeometry */
 		case kMVKShaderStageFragment:	return VK_SHADER_STAGE_FRAGMENT_BIT;
 		case kMVKShaderStageCompute:	return VK_SHADER_STAGE_COMPUTE_BIT;
-		case kMVKShaderStageMax:
-			assert(!"This function should never be called with kMVKShaderStageMax!");
+		case kMVKShaderStageCount:
+			assert(!"This function should never be called with kMVKShaderStageCount!");
 			return VK_SHADER_STAGE_ALL;
 	}
 }
diff --git a/MoltenVKShaderConverter/MoltenVKShaderConverter/SPIRVToMSLConverter.cpp b/MoltenVKShaderConverter/MoltenVKShaderConverter/SPIRVToMSLConverter.cpp
index fb1bb93..36c803f 100644
--- a/MoltenVKShaderConverter/MoltenVKShaderConverter/SPIRVToMSLConverter.cpp
+++ b/MoltenVKShaderConverter/MoltenVKShaderConverter/SPIRVToMSLConverter.cpp
@@ -31,10 +31,17 @@
 #pragma mark -
 #pragma mark SPIRVToMSLConversionConfiguration
 
+// Returns whether the container contains an item equal to the value.
+template<class C, class T>
+bool contains(const C& container, const T& val) {
+	for (const T& cVal : container) { if (cVal == val) { return true; } }
+	return false;
+}
+
 // Returns whether the vector contains the value (using a matches(T&) comparison member function). */
-template<class T>
-bool containsMatching(const vector<T>& vec, const T& val) {
-    for (const T& vecVal : vec) { if (vecVal.matches(val)) { return true; } }
+template<class C, class T>
+bool containsMatching(const C& container, const T& val) {
+    for (const T& cVal : container) { if (cVal.matches(val)) { return true; } }
     return false;
 }
 
@@ -143,6 +150,12 @@
 	return true;
 }
 
+MVK_PUBLIC_SYMBOL bool mvk::DescriptorBinding::matches(const mvk::DescriptorBinding& other) const {
+	if (descriptorSet != other.descriptorSet) { return false; }
+	if (binding != other.binding) { return false; }
+	return true;
+}
+
 MVK_PUBLIC_SYMBOL bool SPIRVToMSLConversionConfiguration::stageSupportsVertexAttributes() const {
 	return (options.entryPointStage == spv::ExecutionModelVertex ||
 			options.entryPointStage == spv::ExecutionModelTessellationControl ||
@@ -182,6 +195,14 @@
         if (rb.isUsedByShader && !containsMatching(other.resourceBindings, rb)) { return false; }
     }
 
+	for (uint32_t dsIdx : discreteDescriptorSets) {
+		if ( !contains(other.discreteDescriptorSets, dsIdx)) { return false; }
+	}
+
+	for (const auto& db : inlineUniformBlocks) {
+		if ( !containsMatching(other.inlineUniformBlocks, db)) { return false; }
+	}
+
     return true;
 }
 
@@ -277,6 +298,18 @@
 			}
 		}
 
+		// Add any descriptor sets that are not using Metal argument buffers.
+		// This only has an effect if SPIRVToMSLConversionConfiguration::options::mslOptions::argument_buffers is enabled.
+		for (uint32_t dsIdx : context.discreteDescriptorSets) {
+			pMSLCompiler->add_discrete_descriptor_set(dsIdx);
+		}
+
+		// Add any inline block bindings.
+		// This only has an effect if SPIRVToMSLConversionConfiguration::options::mslOptions::argument_buffers is enabled.
+		for (auto& db : context.inlineUniformBlocks) {
+			pMSLCompiler->add_inline_uniform_block(db.descriptorSet, db.binding);
+		}
+
 		_msl = pMSLCompiler->compile();
 
         if (shouldLogMSL) { logSource(_msl, "MSL", "Converted"); }
diff --git a/MoltenVKShaderConverter/MoltenVKShaderConverter/SPIRVToMSLConverter.h b/MoltenVKShaderConverter/MoltenVKShaderConverter/SPIRVToMSLConverter.h
index f642644..a9d9199 100644
--- a/MoltenVKShaderConverter/MoltenVKShaderConverter/SPIRVToMSLConverter.h
+++ b/MoltenVKShaderConverter/MoltenVKShaderConverter/SPIRVToMSLConverter.h
@@ -120,6 +120,20 @@
 	} MSLResourceBinding;
 
 	/**
+	 * Identifies a descriptor set binding.
+	 *
+	 * THIS STRUCT IS STREAMED OUT AS PART OF THE PIPELINE CACHE.
+	 * CHANGES TO THIS STRUCT SHOULD BE CAPTURED IN THE STREAMING LOGIC OF THE PIPELINE CACHE.
+	 */
+	typedef struct DescriptorBinding {
+		uint32_t descriptorSet = 0;
+		uint32_t binding = 0;
+
+		bool matches(const DescriptorBinding& other) const;
+
+	} DescriptorBinding;
+
+	/**
 	 * Configuration passed to the SPIRVToMSLConverter.
 	 *
 	 * THIS STRUCT IS STREAMED OUT AS PART OF THE PIEPLINE CACHE.
@@ -129,6 +143,8 @@
 		SPIRVToMSLConversionOptions options;
 		std::vector<MSLShaderInput> shaderInputs;
 		std::vector<MSLResourceBinding> resourceBindings;
+		std::vector<uint32_t> discreteDescriptorSets;
+		std::vector<DescriptorBinding> inlineUniformBlocks;
 
 		/** Returns whether the pipeline stage being converted supports vertex attributes. */
 		bool stageSupportsVertexAttributes() const;