diff --git a/MoltenVK/MoltenVK/Commands/MVKCmdDraw.h b/MoltenVK/MoltenVK/Commands/MVKCmdDraw.h
index 1fb53cd..d9be776 100644
--- a/MoltenVK/MoltenVK/Commands/MVKCmdDraw.h
+++ b/MoltenVK/MoltenVK/Commands/MVKCmdDraw.h
@@ -44,7 +44,7 @@
     MVKCmdBindVertexBuffers(MVKCommandTypePool<MVKCmdBindVertexBuffers>* pool);
 
 protected:
-    MVKVector<MVKMTLBufferBinding> _bindings;
+    MVKVectorInline<MVKMTLBufferBinding, 8> _bindings;
 };
 
 
diff --git a/MoltenVK/MoltenVK/Commands/MVKCmdPipeline.h b/MoltenVK/MoltenVK/Commands/MVKCmdPipeline.h
index 7166d1c..2044f66 100644
--- a/MoltenVK/MoltenVK/Commands/MVKCmdPipeline.h
+++ b/MoltenVK/MoltenVK/Commands/MVKCmdPipeline.h
@@ -102,8 +102,8 @@
 private:
 	VkPipelineBindPoint _pipelineBindPoint;
 	MVKPipelineLayout* _pipelineLayout;
-	MVKVector<MVKDescriptorSet*> _descriptorSets;
-	MVKVector<uint32_t>          _dynamicOffsets;
+	MVKVectorInline<MVKDescriptorSet*, 8> _descriptorSets;
+	MVKVectorInline<uint32_t, 8>          _dynamicOffsets;
 	uint32_t _firstSet;
 };
 
@@ -129,7 +129,7 @@
 	MVKPipelineLayout* _pipelineLayout;
 	VkShaderStageFlags _stageFlags;
 	uint32_t _offset;
-	MVKVector<char> _pushConstants;
+	MVKVectorInline<char, 128> _pushConstants;
 };
 
 
@@ -157,7 +157,7 @@
 
 	VkPipelineBindPoint _pipelineBindPoint;
 	MVKPipelineLayout* _pipelineLayout;
-	std::vector<VkWriteDescriptorSet> _descriptorWrites;
+	MVKVectorInline<VkWriteDescriptorSet, 8> _descriptorWrites;
 	uint32_t _set;
 };
 
diff --git a/MoltenVK/MoltenVK/Commands/MVKCmdRenderPass.h b/MoltenVK/MoltenVK/Commands/MVKCmdRenderPass.h
index 733e290..8de657e 100644
--- a/MoltenVK/MoltenVK/Commands/MVKCmdRenderPass.h
+++ b/MoltenVK/MoltenVK/Commands/MVKCmdRenderPass.h
@@ -48,7 +48,7 @@
 	VkSubpassContents _contents;
 	MVKRenderPass* _renderPass;
 	MVKFramebuffer* _framebuffer;
-	MVKVector<VkClearValue> _clearValues;
+	MVKVectorInline<VkClearValue, 8> _clearValues;
 };
 
 
@@ -115,7 +115,7 @@
 
 private:
 	uint32_t _firstViewport;
-	MVKVector<MTLViewport> _mtlViewports;
+	MVKVectorInline<MTLViewport, 8> _mtlViewports;
 };
 
 
@@ -134,7 +134,7 @@
 
 private:
 	uint32_t _firstScissor;
-	MVKVector<MTLScissorRect> _mtlScissors;
+	MVKVectorInline<MTLScissorRect, 8> _mtlScissors;
 };
 
 
diff --git a/MoltenVK/MoltenVK/Commands/MVKCommandBuffer.h b/MoltenVK/MoltenVK/Commands/MVKCommandBuffer.h
index 11fd50c..9b8d4a5 100644
--- a/MoltenVK/MoltenVK/Commands/MVKCommandBuffer.h
+++ b/MoltenVK/MoltenVK/Commands/MVKCommandBuffer.h
@@ -403,7 +403,7 @@
 	uint32_t _renderSubpassIndex;
 	VkRect2D _renderArea;
     MVKActivatedQueries* _pActivatedQueries;
-	MVKVector<VkClearValue> _clearValues;
+	MVKVectorInline<VkClearValue, 8> _clearValues;
 	id<MTLComputeCommandEncoder> _mtlComputeEncoder;
 	MVKCommandUse _mtlComputeEncoderUse;
 	id<MTLBlitCommandEncoder> _mtlBlitEncoder;
diff --git a/MoltenVK/MoltenVK/Commands/MVKCommandEncoderState.h b/MoltenVK/MoltenVK/Commands/MVKCommandEncoderState.h
index f52bcab..a18e6d4 100644
--- a/MoltenVK/MoltenVK/Commands/MVKCommandEncoderState.h
+++ b/MoltenVK/MoltenVK/Commands/MVKCommandEncoderState.h
@@ -147,7 +147,7 @@
     void encodeImpl() override;
     void resetImpl() override;
 
-    MVKVector<MTLViewport> _mtlViewports;
+    MVKVectorInline<MTLViewport, 8> _mtlViewports;
 };
 
 
@@ -176,7 +176,7 @@
     void encodeImpl() override;
     void resetImpl() override;
 
-    MVKVector<MTLScissorRect> _mtlScissors;
+    MVKVectorInline<MTLScissorRect, 8> _mtlScissors;
 };
 
 
@@ -203,7 +203,7 @@
     void encodeImpl() override;
     void resetImpl() override;
 
-    MVKVector<char> _pushConstants;
+    MVKVectorInline<char, 128> _pushConstants;
     VkShaderStageFlagBits _shaderStage;
     uint32_t _mtlBufferIndex = 0;
 };
@@ -451,14 +451,14 @@
     void resetImpl() override;
     void markDirty() override;
 
-    MVKVector<MVKMTLBufferBinding> _vertexBufferBindings;
-    MVKVector<MVKMTLBufferBinding> _fragmentBufferBindings;
-    MVKVector<MVKMTLTextureBinding> _vertexTextureBindings;
-    MVKVector<MVKMTLTextureBinding> _fragmentTextureBindings;
-    MVKVector<MVKMTLSamplerStateBinding> _vertexSamplerStateBindings;
-    MVKVector<MVKMTLSamplerStateBinding> _fragmentSamplerStateBindings;
-    MVKVector<uint32_t> _vertexSwizzleConstants;
-    MVKVector<uint32_t> _fragmentSwizzleConstants;
+    MVKVectorInline<MVKMTLBufferBinding, 8> _vertexBufferBindings;
+    MVKVectorInline<MVKMTLBufferBinding, 8> _fragmentBufferBindings;
+    MVKVectorInline<MVKMTLTextureBinding, 8> _vertexTextureBindings;
+    MVKVectorInline<MVKMTLTextureBinding, 8> _fragmentTextureBindings;
+    MVKVectorInline<MVKMTLSamplerStateBinding, 8> _vertexSamplerStateBindings;
+    MVKVectorInline<MVKMTLSamplerStateBinding, 8> _fragmentSamplerStateBindings;
+    MVKVectorInline<uint32_t, 8> _vertexSwizzleConstants;
+    MVKVectorInline<uint32_t, 8> _fragmentSwizzleConstants;
     MVKMTLBufferBinding _vertexAuxBufferBinding;
     MVKMTLBufferBinding _fragmentAuxBufferBinding;
 
@@ -504,10 +504,10 @@
     void resetImpl() override;
     void markDirty() override;
 
-    MVKVector<MVKMTLBufferBinding> _bufferBindings;
-    MVKVector<MVKMTLTextureBinding> _textureBindings;
-    MVKVector<MVKMTLSamplerStateBinding> _samplerStateBindings;
-    MVKVector<uint32_t> _swizzleConstants;
+    MVKVectorDefault<MVKMTLBufferBinding> _bufferBindings;
+    MVKVectorDefault<MVKMTLTextureBinding> _textureBindings;
+    MVKVectorDefault<MVKMTLSamplerStateBinding> _samplerStateBindings;
+    MVKVectorDefault<uint32_t> _swizzleConstants;
     MVKMTLBufferBinding _auxBufferBinding;
 
     bool _areBufferBindingsDirty = false;
diff --git a/MoltenVK/MoltenVK/Commands/MVKCommandEncoderState.mm b/MoltenVK/MoltenVK/Commands/MVKCommandEncoderState.mm
index d7eea3b..480fc9d 100644
--- a/MoltenVK/MoltenVK/Commands/MVKCommandEncoderState.mm
+++ b/MoltenVK/MoltenVK/Commands/MVKCommandEncoderState.mm
@@ -402,7 +402,8 @@
 #pragma mark MVKResourcesCommandEncoderState
 
 // Updates the swizzle for an image in the given vector.
-static void updateSwizzle(MVKVector<uint32_t> &constants, uint32_t index, uint32_t swizzle) {
+template<typename T>
+static void updateSwizzle(T &constants, uint32_t index, uint32_t swizzle) {
 	if (index >= constants.size()) { constants.resize(index + 1); }
 	constants[index] = swizzle;
 }
diff --git a/MoltenVK/MoltenVK/GPUObjects/MVKDescriptorSet.h b/MoltenVK/MoltenVK/GPUObjects/MVKDescriptorSet.h
index 8a33856..b94c9ff 100644
--- a/MoltenVK/MoltenVK/GPUObjects/MVKDescriptorSet.h
+++ b/MoltenVK/MoltenVK/GPUObjects/MVKDescriptorSet.h
@@ -143,7 +143,7 @@
 
 	/** Encodes this descriptor set layout and the specified descriptor updates on the specified command encoder immediately. */
 	void pushDescriptorSet(MVKCommandEncoder* cmdEncoder,
-						   std::vector<VkWriteDescriptorSet>& descriptorWrites,
+						   MVKVector<VkWriteDescriptorSet>& descriptorWrites,
 						   MVKShaderResourceBinding& dslMTLRezIdxOffsets);
 
 
@@ -171,7 +171,7 @@
 	friend class MVKPipelineLayout;
 	friend class MVKDescriptorSet;
 
-	MVKVector<MVKDescriptorSetLayoutBinding> _bindings;
+	MVKVectorInline<MVKDescriptorSetLayoutBinding, 8> _bindings;
 	std::unordered_map<uint32_t, uint32_t> _bindingToIndex;
 	MVKShaderResourceBinding _mtlResourceCounts;
 	bool _isPushDescriptorLayout : 1;
diff --git a/MoltenVK/MoltenVK/GPUObjects/MVKDescriptorSet.mm b/MoltenVK/MoltenVK/GPUObjects/MVKDescriptorSet.mm
index d711ab8..4d7e64f 100644
--- a/MoltenVK/MoltenVK/GPUObjects/MVKDescriptorSet.mm
+++ b/MoltenVK/MoltenVK/GPUObjects/MVKDescriptorSet.mm
@@ -559,7 +559,7 @@
 }
 
 void MVKDescriptorSetLayout::pushDescriptorSet(MVKCommandEncoder* cmdEncoder,
-                                               vector<VkWriteDescriptorSet>& descriptorWrites,
+                                               MVKVector<VkWriteDescriptorSet>& descriptorWrites,
                                                MVKShaderResourceBinding& dslMTLRezIdxOffsets) {
 
     if (!_isPushDescriptorLayout) return;
diff --git a/MoltenVK/MoltenVK/GPUObjects/MVKImage.h b/MoltenVK/MoltenVK/GPUObjects/MVKImage.h
index 71a0146..bdf64a5 100644
--- a/MoltenVK/MoltenVK/GPUObjects/MVKImage.h
+++ b/MoltenVK/MoltenVK/GPUObjects/MVKImage.h
@@ -20,8 +20,8 @@
 
 #include "MVKResource.h"
 #include "MVKSync.h"
+#include "MVKVector.h"
 #include <mutex>
-#include <list>
 
 #import <IOSurface/IOSurfaceRef.h>
 
@@ -396,7 +396,7 @@
 	uint32_t _swapchainIndex;
 	id<CAMetalDrawable> _mtlDrawable;
 	std::mutex _availabilityLock;
-	std::list<MVKSwapchainSignaler> _availabilitySignalers;
+	MVKVectorInline<MVKSwapchainSignaler, 4> _availabilitySignalers;
 	MVKSwapchainSignaler _preSignaled;
 	MVKSwapchainImageAvailability _availability;
 };
diff --git a/MoltenVK/MoltenVK/GPUObjects/MVKImage.mm b/MoltenVK/MoltenVK/GPUObjects/MVKImage.mm
index faa31cb..715470b 100644
--- a/MoltenVK/MoltenVK/GPUObjects/MVKImage.mm
+++ b/MoltenVK/MoltenVK/GPUObjects/MVKImage.mm
@@ -1027,7 +1027,8 @@
 		// If this image is not yet available, extract and signal the first semaphore and fence.
 
 		signaler = _availabilitySignalers.front();
-		_availabilitySignalers.pop_front();
+    _availabilitySignalers.erase( _availabilitySignalers.begin() );
+		//_availabilitySignalers.pop_front();
 	}
 
 	// Signal the semaphore and fence, and let them know they are no longer being tracked.
diff --git a/MoltenVK/MoltenVK/GPUObjects/MVKPipeline.h b/MoltenVK/MoltenVK/GPUObjects/MVKPipeline.h
index 6b6509b..5132a05 100644
--- a/MoltenVK/MoltenVK/GPUObjects/MVKPipeline.h
+++ b/MoltenVK/MoltenVK/GPUObjects/MVKPipeline.h
@@ -25,7 +25,6 @@
 #include "MVKVector.h"
 #include <MoltenVKSPIRVToMSLConverter/SPIRVToMSLConverter.h>
 #include <unordered_set>
-#include <vector>
 #include <ostream>
 
 #import <Metal/Metal.h>
@@ -59,7 +58,7 @@
 
 	/** Updates a descriptor set in a command encoder. */
 	void pushDescriptorSet(MVKCommandEncoder* cmdEncoder,
-						   std::vector<VkWriteDescriptorSet>& descriptorWrites,
+						   MVKVector<VkWriteDescriptorSet>& descriptorWrites,
 						   uint32_t set);
 
 	/** Updates a descriptor set from a template in a command encoder. */
@@ -78,9 +77,9 @@
 	MVKPipelineLayout(MVKDevice* device, const VkPipelineLayoutCreateInfo* pCreateInfo);
 
 protected:
-	std::vector<MVKDescriptorSetLayout> _descriptorSetLayouts;
-	std::vector<MVKShaderResourceBinding> _dslMTLResourceIndexOffsets;
-	std::vector<VkPushConstantRange> _pushConstants;
+	MVKVectorInline<MVKDescriptorSetLayout, 8> _descriptorSetLayouts;
+	MVKVectorInline<MVKShaderResourceBinding, 8> _dslMTLResourceIndexOffsets;
+	MVKVectorInline<VkPushConstantRange, 8> _pushConstants;
 	MVKShaderResourceBinding _pushConstantsMTLResourceIndexes;
 	MVKShaderAuxBufferBinding _auxBufferIndex;
 };
@@ -143,8 +142,8 @@
 	VkPipelineRasterizationStateCreateInfo _rasterInfo;
 	VkPipelineDepthStencilStateCreateInfo _depthStencilInfo;
 
-  MVKVector<MTLViewport> _mtlViewports;
-  MVKVector<MTLScissorRect> _mtlScissors;
+  MVKVectorInline<MTLViewport, 8> _mtlViewports;
+  MVKVectorInline<MTLScissorRect, 8> _mtlScissors;
 
 	id<MTLRenderPipelineState> _mtlPipelineState;
 	MTLCullMode _mtlCullMode;
diff --git a/MoltenVK/MoltenVK/GPUObjects/MVKPipeline.mm b/MoltenVK/MoltenVK/GPUObjects/MVKPipeline.mm
index 9bb5a36..4e1916d 100644
--- a/MoltenVK/MoltenVK/GPUObjects/MVKPipeline.mm
+++ b/MoltenVK/MoltenVK/GPUObjects/MVKPipeline.mm
@@ -55,7 +55,7 @@
 }
 
 void MVKPipelineLayout::pushDescriptorSet(MVKCommandEncoder* cmdEncoder,
-                                          vector<VkWriteDescriptorSet>& descriptorWrites,
+                                          MVKVector<VkWriteDescriptorSet>& descriptorWrites,
                                           uint32_t set) {
 
     _descriptorSetLayouts[set].pushDescriptorSet(cmdEncoder, descriptorWrites,
diff --git a/MoltenVK/MoltenVK/GPUObjects/MVKQueue.h b/MoltenVK/MoltenVK/GPUObjects/MVKQueue.h
index 1feac0e..580d98e 100644
--- a/MoltenVK/MoltenVK/GPUObjects/MVKQueue.h
+++ b/MoltenVK/MoltenVK/GPUObjects/MVKQueue.h
@@ -170,7 +170,7 @@
 	MVKQueueSubmission* _prev;
 	MVKQueueSubmission* _next;
 	VkResult _submissionResult;
-	MVKVector<MVKSemaphore*> _waitSemaphores;
+	MVKVectorInline<MVKSemaphore*, 8> _waitSemaphores;
 	bool _isAwaitingSemaphores;
 };
 
@@ -205,8 +205,8 @@
 	void commitActiveMTLCommandBuffer(bool signalCompletion = false);
 	void finish();
 
-	MVKVector<MVKCommandBuffer*> _cmdBuffers;
-	MVKVector<MVKSemaphore*> _signalSemaphores;
+	MVKVectorInline<MVKCommandBuffer*, 16> _cmdBuffers;
+	MVKVectorInline<MVKSemaphore*, 16> _signalSemaphores;
 	MVKFence* _fence;
     MVKCommandUse _cmdBuffUse;
 	id<MTLCommandBuffer> _activeMTLCommandBuffer;
@@ -228,6 +228,6 @@
 									 const VkPresentInfoKHR* pPresentInfo);
 
 protected:
-	MVKVector<MVKSwapchainImage*> _surfaceImages;
+	MVKVectorInline<MVKSwapchainImage*, 4> _surfaceImages;
 };
 
diff --git a/MoltenVK/MoltenVK/Utility/MVKVector.h b/MoltenVK/MoltenVK/Utility/MVKVector.h
index df0b8a9..df2413d 100755
--- a/MoltenVK/MoltenVK/Utility/MVKVector.h
+++ b/MoltenVK/MoltenVK/Utility/MVKVector.h
@@ -1,7 +1,7 @@
 /*
- * MVKVectorAllocator.h
+ * MVKVector.h
  *
- * Copyright (c) 2012-2018 Dr. Torsten Hans (hans@ipacs.de)
+ * Copyright (c) 2012-2019 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.
@@ -23,25 +23,57 @@
 //
 #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
 
 //
-// a simple std::vector like container with a configurable extra stack space
-// this class supports just the necessary members to be compatible with MoltenVK
-// if C++17 is used, code can be simplified further
-// by default MVKVector used 8 elements from the stack before getting memory from heap
+// 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.
+// Keep in mind MVKVector only supports iterating over the MVKVector, no other
+// operation is supported.
 //
 #include "MVKVectorAllocator.h"
 #include <type_traits>
 #include <initializer_list>
 #include <utility>
 
-template<class Type, class Allocator = mvk_vector_allocator_with_stack<Type, 8>> class MVKVector
+
+template<class Type> class MVKVector
 {
-  Allocator alc;
+  mvk_vector_allocator_base<Type> *alc_ptr;
 
 public:
   class iterator
@@ -52,100 +84,134 @@
   public:
     iterator() = delete;
     iterator( const size_t _index, const MVKVector &_vector ) : vector{ &_vector }, index{ _index } { }
+    iterator &operator=( const iterator &it ) = delete;
 
-    iterator &operator=( const iterator &it )
-    {
-      vector = it.vector;
-      index = it.index;
-      return *this;
-    }
+    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]; }
 
-    Type *operator->() const
-    {
-      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; }
 
-    Type &operator*() const
-    {
-      return vector->alc.ptr[index];
-    }
+    iterator& operator++()      {                 ++index; return *this; }
+    iterator  operator++( int ) { auto t = *this; ++index; return t; }
 
-    operator Type*() const
-    {
-      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; }
-
-    bool   is_valid()     const { return index < vector->alc.num_elements_used; }
+    bool   is_valid()     const { return index < vector->size(); }
     size_t get_position() const { return index; }
   };
 
-  class reverse_iterator
+public:
+  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 ); }
+  size_t   size()     const { return alc_ptr->size(); }
+  bool     empty()    const { return alc_ptr->size() == 0; }
+  size_t   capacity() const { return alc_ptr->get_capacity(); }
+
+  virtual const Type &operator[]( const size_t i ) const = 0;
+  virtual void push_back( const Type &t ) = 0;
+};
+
+
+template<class Type> class MVKVector<Type *>
+{
+  mvk_vector_allocator_base<Type*> *alc_ptr;
+
+public:
+  class iterator
   {
     const MVKVector *vector;
     size_t           index;
 
   public:
-    reverse_iterator() = delete;
-    reverse_iterator( const size_t _index, const MVKVector &_vector ) : vector{ &_vector }, index{ _index } { }
-    reverse_iterator &operator=( const reverse_iterator & ) = delete;
+    iterator() = delete;
+    iterator( const size_t _index, const MVKVector &_vector ) : vector{ &_vector }, index{ _index } { }
+    iterator &operator=( const iterator &it ) = delete;
 
-    Type *operator->() const
+    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:
+  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 ); }
+  size_t   size()     const { return alc_ptr->size(); }
+  bool     empty()    const { return alc_ptr->size() == 0; }
+  size_t   capacity() const { return alc_ptr->get_capacity(); }
+
+  virtual Type * const &operator[]( const size_t i ) const = 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
+  {
+    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 )
     {
-      return &vector->alc.ptr[index];
+      vector = it.vector;
+      index  = it.index;
+      return *this;
     }
 
-    Type &operator*() const
-    {
-      return vector->alc.ptr[index];
-    }
+    Type *operator->() { return &vector->alc.ptr[index]; }
+    Type &operator*()  { return  vector->alc.ptr[index]; }
+    operator Type*()   { return &vector->alc.ptr[index]; }
 
-    operator Type*() const
-    {
-      return &vector->alc.ptr[index];
-    }
-    
-    bool operator==( const reverse_iterator &it ) const
-    {
-      return vector == it.vector && index == it.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; }
 
-    bool operator!=( const reverse_iterator &it ) const
-    {
-      return vector != it.vector || index != it.index;
-    }
+    iterator& operator++()      {                 ++index; return *this; }
+    iterator  operator++( int ) { auto t = *this; ++index; return t; }
 
-    reverse_iterator& operator++() { --index; return *this; }
-
-    bool   is_valid()     const { return index < vector->alc.num_elements_used; }
+    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();
-    //if( current_capacity < 256 )
-    //  return MINIMUM_CAPACITY + 2 * current_capacity;
     return MINIMUM_CAPACITY + ( 3 * current_capacity ) / 2;
   }
 
   void vector_Allocate( const size_t s )
   {
-    const auto new_reserved_size = tm_max( s, alc.num_elements_used );
+    const auto new_reserved_size = tm_max( s, size() );
 
     alc.allocate( new_reserved_size );
   }
@@ -156,11 +222,11 @@
   }
 
 public:
-  MVKVector()
+  MVKVectorImpl() : MVKVector<Type>{ &alc }
   {
   }
 
-  MVKVector( const size_t n, const Type t )
+  MVKVectorImpl( const size_t n, const Type t ) : MVKVector<Type>{ &alc }
   {
     if( n > 0 )
     {
@@ -175,7 +241,7 @@
     }
   }
 
-  MVKVector( const MVKVector &a )
+  MVKVectorImpl( const MVKVectorImpl &a ) : MVKVector<Type>{ &alc }
   {
     const size_t n = a.size();
 
@@ -192,11 +258,29 @@
     }
   }
 
-  MVKVector( MVKVector &&a ) : alc{ std::move( a.alc ) }
+  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 ) }
   {
   }
 
-  MVKVector( std::initializer_list<Type> vector )
+  MVKVectorImpl( std::initializer_list<Type> vector ) : MVKVector<Type>{ &alc }
   {
     if( vector.size() > capacity() )
     {
@@ -211,15 +295,18 @@
     }
   }
 
-  ~MVKVector()
+  ~MVKVectorImpl()
   {
   }
 
-  MVKVector& operator=( const MVKVector &a )
+  template<typename U>
+  MVKVectorImpl& operator=( const U &a )
   {
-    if( this != &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.alc.num_elements_used;
+      const auto n = a.size();
 
       if( alc.num_elements_used == n )
       {
@@ -241,7 +328,7 @@
 
         for( size_t i = 0; i < n; ++i )
         {
-          alc.construct( &alc.ptr[i], a.alc.ptr[i] );
+          alc.construct( &alc.ptr[i], a[i] );
         }
 
         alc.num_elements_used = n;
@@ -251,37 +338,37 @@
     return *this;
   }
 
-  MVKVector& operator=( MVKVector &&a )
+  MVKVectorImpl& operator=( MVKVectorImpl &&a )
   {
     alc.swap( a.alc );
     return *this;
   }
 
-  bool operator==( const MVKVector &a ) const
+  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.ptr[i] != a.alc.ptr[i] )
+      if( alc[i] != a.alc[i] )
         return false;
     }
     return true;
   }
 
-  bool operator!=( const MVKVector &a ) const
+  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.ptr[i] )
+      if( alc.ptr[i] != a.alc[i] )
         return true;
     }
     return false;
   }
 
-  void swap( MVKVector &a )
+  void swap( MVKVectorImpl &a )
   {
     alc.swap( a.alc );
   }
@@ -298,8 +385,6 @@
 
   iterator         begin()  const { return iterator( 0, *this ); }
   iterator         end()    const { return iterator( alc.num_elements_used, *this ); }
-  reverse_iterator rbegin() const { return reverse_iterator( alc.num_elements_used - 1, *this ); }
-  reverse_iterator rend()   const { return reverse_iterator( size_t( -1 ), *this ); }
   size_t           size()   const { return alc.num_elements_used; }
   bool             empty()  const { return alc.num_elements_used == 0; }
 
@@ -308,7 +393,7 @@
     return alc.ptr[i];
   }
 
-  const Type &operator[]( const size_t i ) const
+  const Type &operator[]( const size_t i ) const override
   {
     return alc.ptr[i];
   }
@@ -393,7 +478,7 @@
   void assign( InputIterator first, InputIterator last )
   {
     clear();
-    
+
     while( first != last )
     {
       emplace_back( *first );
@@ -456,7 +541,7 @@
     {
       --alc.num_elements_used;
 
-      for( size_t i = it.GetIndex(); i < alc.num_elements_used; ++i )
+      for( size_t i = it.get_position(); i < alc.num_elements_used; ++i )
       {
         alc.ptr[i] = std::move( alc.ptr[i + 1] );
       }
@@ -493,7 +578,7 @@
     }
   }
 
-  void push_back( const Type &t )
+  void push_back( const Type &t ) override
   {
     if( alc.num_elements_used == capacity() )
       vector_ReAllocate( vector_GetNextCapacity() );
@@ -524,5 +609,377 @@
   }
 };
 
+// specialization for pointer types
+template<class Type, typename Allocator> class MVKVectorImpl<Type*, Allocator> : public MVKVector<Type*>
+{
+  friend class MVKVectorImpl;
+
+  Allocator  alc;
+
+public:
+  class iterator
+  {
+    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 = tm_max( 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 );
+  }
+
+  void clear()
+  {
+    alc.num_elements_used = 0;
+  }
+
+  void reset()
+  {
+    alc.deallocate();
+  }
+
+  iterator begin()        { return iterator( 0, *this ); }
+  iterator end()          { return iterator( alc.num_elements_used, *this ); }
+  size_t   size()   const { return alc.num_elements_used; }
+  bool     empty()  const { return alc.num_elements_used == 0; }
+
+  Type *at( const size_t i ) const
+  {
+    return alc.ptr[i];
+  }
+
+  Type * const &operator[]( const size_t i ) const override
+  {
+    return alc.ptr[i];
+  }
+
+  Type *&operator[]( const size_t i )
+  {
+    return alc.ptr[i];
+  }
+
+  const Type * const *data() const
+  {
+    return &alc.ptr[0];
+  }
+
+  Type **data()
+  {
+    return &alc.ptr[0];
+  }
+
+  size_t capacity() const
+  {
+    return alc.get_capacity();
+  }
+
+  const Type *back() const
+  {
+    return alc.ptr[alc.num_elements_used - 1];
+  }
+
+  Type *back()
+  {
+    return alc.ptr[alc.num_elements_used - 1];
+  }
+
+  void pop_back()
+  {
+    if ( alc.num_elements_used > 0 )
+    {
+      --alc.num_elements_used;
+    }
+  }
+
+  void reserve( const size_t new_size )
+  {
+    if ( new_size > capacity() )
+    {
+      vector_ReAllocate( new_size );
+    }
+  }
+
+  void assign( const size_t new_size, const Type *t )
+  {
+    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 )
+  {
+    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] = nullptr;
+        ++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()
+  {
+    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];
+      }
+    }
+  }
+
+  // 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
index 442e0ac..a5c320a 100755
--- a/MoltenVK/MoltenVK/Utility/MVKVectorAllocator.h
+++ b/MoltenVK/MoltenVK/Utility/MVKVectorAllocator.h
@@ -1,7 +1,7 @@
 /*
  * MVKVectorAllocator.h
  *
- * Copyright (c) 2012-2018 Dr. Torsten Hans (hans@ipacs.de)
+ * Copyright (c) 2012-2019 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.
@@ -37,16 +37,42 @@
 
 //////////////////////////////////////////////////////////////////////////////////////////
 //
-// mvk_vector_allocator_default -> malloc based allocator for MVKVector
+// mvk_vector_allocator_base -> base class so we can use MVKVector with template parameter
 //
 //////////////////////////////////////////////////////////////////////////////////////////
-template <typename T>
-class mvk_vector_allocator_default final
+template<typename T>
+class mvk_vector_allocator_base
 {
 public:
   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 { return ptr[i]; }
+  T       &operator[]( const size_t i )       { 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;
 
@@ -77,38 +103,38 @@
   template<class S> typename std::enable_if< !std::is_trivially_destructible<S>::value >::type
     destruct_all()
   {
-    for( size_t i = 0; i < num_elements_used; ++i )
+    for( size_t i = 0; i < mvk_vector_allocator_base<S>::num_elements_used; ++i )
     {
-      ptr[i].~S();
+      mvk_vector_allocator_base<S>::ptr[i].~S();
     }
 
-    num_elements_used = 0;
+    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()
   {
-    num_elements_used = 0;
+    mvk_vector_allocator_base<T>::num_elements_used = 0;
   }
 
 public:
-  constexpr mvk_vector_allocator_default() : ptr{ nullptr }, num_elements_used{ 0 }, num_elements_reserved{ 0 }
+  constexpr mvk_vector_allocator_default() : mvk_vector_allocator_base<T>{}, num_elements_reserved{ 0 }
   {
   }
 
-  mvk_vector_allocator_default( mvk_vector_allocator_default &&a ) : ptr{ a.ptr }, num_elements_used{ a.num_elements_used }, num_elements_reserved{ a.num_elements_reserved }
+  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.ptr                   = nullptr;
+    a.num_elements_used     = 0;
     a.num_elements_reserved = 0;
   }
 
-  ~mvk_vector_allocator_default()
+  virtual ~mvk_vector_allocator_default()
   {
     deallocate();
   }
 
-  size_t get_capacity() const
+  size_t get_capacity() const override
   {
     return num_elements_reserved;
   }
@@ -119,25 +145,25 @@
     const auto copy_num_elements_used     = a.num_elements_used;
     const auto copy_num_elements_reserved = a.num_elements_reserved;
 
-    a.ptr                   = ptr;
-    a.num_elements_used     = num_elements_used;
+    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;
 
-    ptr                   = copy_ptr;
-    num_elements_used     = copy_num_elements_used;
+    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 )
+  void allocate( const size_t num_elements_to_reserve ) override
   {
     deallocate();
 
-    ptr                   = reinterpret_cast< T* >( mvk_memory_allocator::alloc( num_elements_to_reserve * sizeof( T ) ) );
-    num_elements_used     = 0;
+    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 )
+  void re_allocate( const size_t num_elements_to_reserve ) override
   {
     //if constexpr( std::is_trivially_copyable<T>::value )
     //{
@@ -147,53 +173,53 @@
     {
       auto *new_ptr = reinterpret_cast< T* >( mvk_memory_allocator::alloc( num_elements_to_reserve * sizeof( T ) ) );
 
-      for( size_t i = 0; i < num_elements_used; ++i )
+      for( size_t i = 0; i < mvk_vector_allocator_base<T>::num_elements_used; ++i )
       {
-        construct( &new_ptr[i], std::move( ptr[i] ) );
-        destruct( &ptr[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( ptr );
+        mvk_memory_allocator::free( mvk_vector_allocator_base<T>::ptr );
       }
 
-      ptr = new_ptr;
+      mvk_vector_allocator_base<T>::ptr = new_ptr;
     }
 
     num_elements_reserved = num_elements_to_reserve;
   }
 
-  void shrink_to_fit()
+  void shrink_to_fit() override
   {
-    if( num_elements_used == 0 )
+    if( mvk_vector_allocator_base<T>::num_elements_used == 0 )
     {
       deallocate();
     }
     else
     {
-      auto *new_ptr = reinterpret_cast< T* >( mvk_memory_allocator::alloc( num_elements_used * sizeof( T ) ) );
+      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 < num_elements_used; ++i )
+      for( size_t i = 0; i < mvk_vector_allocator_base<T>::num_elements_used; ++i )
       {
-        construct( &new_ptr[i], std::move( ptr[i] ) );
-        destruct( &ptr[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( ptr );
+      mvk_memory_allocator::free( mvk_vector_allocator_base<T>::ptr );
 
-      ptr = new_ptr;
-      num_elements_reserved = num_elements_used;
+      mvk_vector_allocator_base<T>::ptr = new_ptr;
+      num_elements_reserved = mvk_vector_allocator_base<T>::num_elements_used;
     }
   }
 
-  void deallocate()
+  void deallocate() override
   {
     destruct_all<T>();
 
-    mvk_memory_allocator::free( ptr );
+    mvk_memory_allocator::free( mvk_vector_allocator_base<T>::ptr );
 
-    ptr = nullptr;
+    mvk_vector_allocator_base<T>::ptr = nullptr;
     num_elements_reserved = 0;
   }
 };
@@ -201,16 +227,12 @@
 
 //////////////////////////////////////////////////////////////////////////////////////////
 //
-// mvk_vector_allocator_with_stack -> malloc based MVKVector allocator with stack storage
+// mvk_vector_allocator_with_stack -> malloc based MVKVector allocator with preallocated storage
 //
 //////////////////////////////////////////////////////////////////////////////////////////
 template <typename T, int N>
-class mvk_vector_allocator_with_stack
+class mvk_vector_allocator_with_stack final : public mvk_vector_allocator_base<T>
 {
-public:
-  T      *ptr;
-  size_t  num_elements_used;
-
 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 )];
@@ -219,10 +241,9 @@
 
   void set_num_elements_reserved( const size_t num_elements_reserved )
   {
-    *reinterpret_cast< size_t* >( &elements_stack[0] ) = num_elements_reserved;
+    *reinterpret_cast<size_t*>( &elements_stack[0] ) = num_elements_reserved;
   }
 
-
 public:
   //
   // faster element construction and destruction using type traits
@@ -253,18 +274,18 @@
   template<class S> typename std::enable_if< !std::is_trivially_destructible<S>::value >::type
     destruct_all()
   {
-    for( size_t i = 0; i < num_elements_used; ++i )
+    for( size_t i = 0; i < mvk_vector_allocator_base<S>::num_elements_used; ++i )
     {
-      ptr[i].~S();
+      mvk_vector_allocator_base<S>::ptr[i].~S();
     }
 
-    num_elements_used = 0;
+    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()
   {
-    num_elements_used = 0;
+    mvk_vector_allocator_base<S>::num_elements_used = 0;
   }
 
   template<class S> typename std::enable_if< !std::is_trivially_destructible<S>::value >::type
@@ -272,19 +293,19 @@
   {
     T stack_copy[N];
 
-    for( size_t i = 0; i < num_elements_used; ++i )
+    for( size_t i = 0; i < mvk_vector_allocator_base<S>::num_elements_used; ++i )
     {
-      construct( &stack_copy[i], std::move( ptr[i] ) );
-      destruct( &ptr[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( &ptr[i], std::move( a.ptr[i] ) );
-      destruct( &ptr[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 < num_elements_used; ++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] );
@@ -304,26 +325,26 @@
   }
 
 public:
-  mvk_vector_allocator_with_stack() : ptr{ reinterpret_cast< T* >( &elements_stack[0] ) }, num_elements_used{ 0 }
+  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 ) : num_elements_used{ a.num_elements_used }
+  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() )
     {
-      ptr = a.ptr;
+      mvk_vector_allocator_base<T>::ptr = a.ptr;
       set_num_elements_reserved( a.get_capacity() );
 
       a.ptr = a.get_default_ptr();
     }
     else
     {
-      ptr = get_default_ptr();
+      mvk_vector_allocator_base<T>::ptr = get_default_ptr();
       for( size_t i = 0; i < a.num_elements_used; ++i )
       {
-        construct( &ptr[i], std::move( a.ptr[i] ) );
+        construct( &mvk_vector_allocator_base<T>::ptr[i], std::move( a.ptr[i] ) );
         destruct( &a.ptr[i] );
       }
     }
@@ -336,9 +357,9 @@
     deallocate();
   }
 
-  size_t get_capacity() const
+  size_t get_capacity() const override
   {
-    return get_data_on_stack() ? N : *reinterpret_cast< const size_t* >( &elements_stack[0] );
+    return get_data_on_stack() ? N : *reinterpret_cast<const size_t*>( &elements_stack[0] );
   }
 
   constexpr T *get_default_ptr() const
@@ -348,7 +369,7 @@
 
   bool get_data_on_stack() const
   {
-    return ptr == get_default_ptr();
+    return mvk_vector_allocator_base<T>::ptr == get_default_ptr();
   }
 
   void swap( mvk_vector_allocator_with_stack &a )
@@ -356,9 +377,9 @@
     // both allocators on heap -> easy case
     if( !get_data_on_stack() && !a.get_data_on_stack() )
     {
-      auto copy_ptr = ptr;
+      auto copy_ptr = mvk_vector_allocator_base<T>::ptr;
       auto copy_num_elements_reserved = get_capacity();
-      ptr = a.ptr;
+      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 );
@@ -374,24 +395,24 @@
       auto copy_num_elements_reserved = a.get_capacity();
 
       a.ptr = a.get_default_ptr();
-      for( size_t i = 0; i < num_elements_used; ++i )
+      for( size_t i = 0; i < mvk_vector_allocator_base<T>::num_elements_used; ++i )
       {
-        construct( &a.ptr[i], std::move( ptr[i] ) );
-        destruct( &ptr[i] );
+        construct( &a.ptr[i], std::move( mvk_vector_allocator_base<T>::ptr[i] ) );
+        destruct( &mvk_vector_allocator_base<T>::ptr[i] );
       }
 
-      ptr = copy_ptr;
+      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 = ptr;
+      auto copy_ptr = mvk_vector_allocator_base<T>::ptr;
       auto copy_num_elements_reserved = get_capacity();
 
-      ptr = get_default_ptr();
+      mvk_vector_allocator_base<T>::ptr = get_default_ptr();
       for( size_t i = 0; i < a.num_elements_used; ++i )
       {
-        construct( &ptr[i], std::move( a.ptr[i] ) );
+        construct( &mvk_vector_allocator_base<T>::ptr[i], std::move( a.ptr[i] ) );
         destruct( &a.ptr[i] );
       }
 
@@ -399,15 +420,15 @@
       a.set_num_elements_reserved( copy_num_elements_reserved );
     }
 
-    auto copy_num_elements_used = num_elements_used;
-    num_elements_used = a.num_elements_used;
+    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 )
+  void allocate( const size_t num_elements_to_reserve ) override
   {
     deallocate();
 
@@ -417,8 +438,8 @@
       return;
     }
 
-    ptr               = reinterpret_cast< T* >( mvk_memory_allocator::alloc( num_elements_to_reserve * sizeof( T ) ) );
-    num_elements_used = 0;
+    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 );
   }
 
@@ -427,18 +448,18 @@
   {
     auto *new_ptr = reinterpret_cast< T* >( mvk_memory_allocator::alloc( num_elements_to_reserve * sizeof( T ) ) );
 
-    for( size_t i = 0; i < num_elements_used; ++i )
+    for( size_t i = 0; i < mvk_vector_allocator_base<T>::num_elements_used; ++i )
     {
-      construct( &new_ptr[i], std::move( ptr[i] ) );
-      destruct( &ptr[i] );
+      construct( &new_ptr[i], std::move( mvk_vector_allocator_base<T>::ptr[i] ) );
+      destruct( &mvk_vector_allocator_base<T>::ptr[i] );
     }
 
-    if( ptr != get_default_ptr() )
+    if( mvk_vector_allocator_base<T>::ptr != get_default_ptr() )
     {
-      mvk_memory_allocator::free( ptr );
+      mvk_memory_allocator::free( mvk_vector_allocator_base<T>::ptr );
     }
 
-    ptr = new_ptr;
+    mvk_vector_allocator_base<T>::ptr = new_ptr;
     set_num_elements_reserved( num_elements_to_reserve );
   }
 
@@ -460,7 +481,7 @@
   //  set_num_elements_reserved( num_elements_to_reserve );
   //}
 
-  void re_allocate( const size_t num_elements_to_reserve )
+  void re_allocate( const size_t num_elements_to_reserve ) override
   {
     //TM_ASSERT( num_elements_to_reserve > get_capacity() );
 
@@ -470,56 +491,56 @@
     }
   }
 
-  void shrink_to_fit()
+  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( num_elements_used <= N )
+    if( mvk_vector_allocator_base<T>::num_elements_used <= N )
     {
-      const auto num_elements_reserved = get_capacity();
+      //const auto num_elements_reserved = get_capacity();
 
       auto *stack_ptr = get_default_ptr();
-      for( size_t i = 0; i < num_elements_used; ++i )
+      for( size_t i = 0; i < mvk_vector_allocator_base<T>::num_elements_used; ++i )
       {
-        construct( &stack_ptr[i], std::move( ptr[i] ) );
-        destruct( &ptr[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( ptr );
+      mvk_memory_allocator::free( mvk_vector_allocator_base<T>::ptr );
 
-      ptr = stack_ptr;
+      mvk_vector_allocator_base<T>::ptr = stack_ptr;
     }
     else
     {
-      auto *new_ptr = reinterpret_cast< T* >( mvk_memory_allocator::alloc( ptr, num_elements_used * sizeof( T ) ) );
+      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 < num_elements_used; ++i )
+      for( size_t i = 0; i < mvk_vector_allocator_base<T>::num_elements_used; ++i )
       {
-        construct( &new_ptr[i], std::move( ptr[i] ) );
-        destruct( &ptr[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( ptr );
+      mvk_memory_allocator::free( mvk_vector_allocator_base<T>::ptr );
 
-      ptr = new_ptr;
-      set_num_elements_reserved( num_elements_used );
+      mvk_vector_allocator_base<T>::ptr = new_ptr;
+      set_num_elements_reserved( mvk_vector_allocator_base<T>::num_elements_used );
     }
   }
 
-  void deallocate()
+  void deallocate() override
   {
     destruct_all<T>();
 
     if( !get_data_on_stack() )
     {
-      mvk_memory_allocator::free( ptr );
+      mvk_memory_allocator::free( mvk_vector_allocator_base<T>::ptr );
     }
 
-    ptr = get_default_ptr();
-    num_elements_used = 0;
+    mvk_vector_allocator_base<T>::ptr = get_default_ptr();
+    mvk_vector_allocator_base<T>::num_elements_used = 0;
   }
 };