diff --git a/src/Device/Context.hpp b/src/Device/Context.hpp
index 9a2864a..4f31d00 100644
--- a/src/Device/Context.hpp
+++ b/src/Device/Context.hpp
@@ -96,6 +96,7 @@
 
 		// Instancing
 		int instanceID;
+		int viewID;
 
 		bool occlusionEnabled;
 
diff --git a/src/Device/Renderer.cpp b/src/Device/Renderer.cpp
index b33ff0a..4df1b3c 100644
--- a/src/Device/Renderer.cpp
+++ b/src/Device/Renderer.cpp
@@ -348,11 +348,8 @@
 		}
 
 		data->indices = context->indexBuffer;
-
-		if(context->vertexShader->hasBuiltinInput(spv::BuiltInInstanceIndex))
-		{
-			data->instanceID = context->instanceID;
-		}
+		data->viewID = context->viewID;
+		data->instanceID = context->instanceID;
 
 		data->baseVertex = baseVertex;
 
@@ -426,7 +423,7 @@
 
 				if(draw->renderTarget[index])
 				{
-					data->colorBuffer[index] = (unsigned int*)context->renderTarget[index]->getOffsetPointer({0, 0, 0}, VK_IMAGE_ASPECT_COLOR_BIT, 0, 0);
+					data->colorBuffer[index] = (unsigned int*)context->renderTarget[index]->getOffsetPointer({0, 0, 0}, VK_IMAGE_ASPECT_COLOR_BIT, 0, data->viewID);
 					data->colorPitchB[index] = context->renderTarget[index]->rowPitchBytes(VK_IMAGE_ASPECT_COLOR_BIT, 0);
 					data->colorSliceB[index] = context->renderTarget[index]->slicePitchBytes(VK_IMAGE_ASPECT_COLOR_BIT, 0);
 				}
@@ -437,14 +434,14 @@
 
 			if(draw->depthBuffer)
 			{
-				data->depthBuffer = (float*)context->depthBuffer->getOffsetPointer({0, 0, 0}, VK_IMAGE_ASPECT_DEPTH_BIT, 0, 0);
+				data->depthBuffer = (float*)context->depthBuffer->getOffsetPointer({0, 0, 0}, VK_IMAGE_ASPECT_DEPTH_BIT, 0, data->viewID);
 				data->depthPitchB = context->depthBuffer->rowPitchBytes(VK_IMAGE_ASPECT_DEPTH_BIT, 0);
 				data->depthSliceB = context->depthBuffer->slicePitchBytes(VK_IMAGE_ASPECT_DEPTH_BIT, 0);
 			}
 
 			if(draw->stencilBuffer)
 			{
-				data->stencilBuffer = (unsigned char*)context->stencilBuffer->getOffsetPointer({0, 0, 0}, VK_IMAGE_ASPECT_STENCIL_BIT, 0, 0);
+				data->stencilBuffer = (unsigned char*)context->stencilBuffer->getOffsetPointer({0, 0, 0}, VK_IMAGE_ASPECT_STENCIL_BIT, 0, data->viewID);
 				data->stencilPitchB = context->stencilBuffer->rowPitchBytes(VK_IMAGE_ASPECT_STENCIL_BIT, 0);
 				data->stencilSliceB = context->stencilBuffer->slicePitchBytes(VK_IMAGE_ASPECT_STENCIL_BIT, 0);
 			}
diff --git a/src/Device/Renderer.hpp b/src/Device/Renderer.hpp
index fbff8d1..a8fb74a 100644
--- a/src/Device/Renderer.hpp
+++ b/src/Device/Renderer.hpp
@@ -60,6 +60,7 @@
 		int instanceID;
 		int baseVertex;
 		float lineWidth;
+		int viewID;
 
 		PixelProcessor::Stencil stencil[2];   // clockwise, counterclockwise
 		PixelProcessor::Factor factor;
diff --git a/src/Pipeline/PixelProgram.cpp b/src/Pipeline/PixelProgram.cpp
index 424b129..2391e19 100644
--- a/src/Pipeline/PixelProgram.cpp
+++ b/src/Pipeline/PixelProgram.cpp
@@ -24,6 +24,12 @@
 	{
 		routine.setImmutableInputBuiltins(spirvShader);
 
+		routine.setInputBuiltin(spirvShader, spv::BuiltInViewIndex, [&](const SpirvShader::BuiltinMapping& builtin, Array<SIMD::Float>& value)
+		{
+			assert(builtin.SizeInComponents == 1);
+			value[builtin.FirstComponent] = As<Float4>(Int4((*Pointer<Int>(data + OFFSET(DrawData, viewID)))));
+		});
+
 		routine.setInputBuiltin(spirvShader, spv::BuiltInFragCoord, [&](const SpirvShader::BuiltinMapping& builtin, Array<SIMD::Float>& value)
 		{
 			assert(builtin.SizeInComponents == 4);
@@ -50,6 +56,7 @@
 
 		routine.windowSpacePosition[0] = x + SIMD::Int(0,1,0,1);
 		routine.windowSpacePosition[1] = y + SIMD::Int(0,0,1,1);
+		routine.viewID = *Pointer<Int>(data + OFFSET(DrawData, viewID));
 	}
 
 	void PixelProgram::applyShader(Int cMask[4])
diff --git a/src/Pipeline/SpirvShader.cpp b/src/Pipeline/SpirvShader.cpp
index 061d9cf..5ec62c4 100644
--- a/src/Pipeline/SpirvShader.cpp
+++ b/src/Pipeline/SpirvShader.cpp
@@ -1131,6 +1131,7 @@
 				if (!strcmp(ext, "SPV_KHR_16bit_storage")) break;
 				if (!strcmp(ext, "SPV_KHR_variable_pointers")) break;
 				if (!strcmp(ext, "SPV_KHR_device_group")) break;
+				if (!strcmp(ext, "SPV_KHR_multiview")) break;
 				UNSUPPORTED("SPIR-V Extension: %s", ext);
 				break;
 			}
@@ -5325,6 +5326,12 @@
 			ptr += coordinate.Int(dims) * slicePitch;
 		}
 
+		if (dim == spv::DimSubpassData)
+		{
+			// Multiview input attachment access is to the layer corresponding to the current view
+			ptr += SIMD::Int(routine->viewID) * slicePitch;
+		}
+
 		if (sampleId.value())
 		{
 			GenericValue sample(this, state, sampleId);
diff --git a/src/Pipeline/SpirvShader.hpp b/src/Pipeline/SpirvShader.hpp
index 6d77117..49736c0 100644
--- a/src/Pipeline/SpirvShader.hpp
+++ b/src/Pipeline/SpirvShader.hpp
@@ -1299,6 +1299,7 @@
 		Pointer<Byte> constants;
 		Int killMask = Int{0};
 		SIMD::Int windowSpacePosition[2];
+		Int viewID;	// slice offset into input attachments for multiview, even if the shader doesn't use ViewIndex
 
 		void createVariable(SpirvShader::Object::ID id, uint32_t size)
 		{
diff --git a/src/Pipeline/VertexProgram.cpp b/src/Pipeline/VertexProgram.cpp
index 4a56280..c7f020c 100644
--- a/src/Pipeline/VertexProgram.cpp
+++ b/src/Pipeline/VertexProgram.cpp
@@ -34,6 +34,12 @@
 	{
 		routine.setImmutableInputBuiltins(spirvShader);
 
+		routine.setInputBuiltin(spirvShader, spv::BuiltInViewIndex, [&](const SpirvShader::BuiltinMapping& builtin, Array<SIMD::Float>& value)
+		{
+			assert(builtin.SizeInComponents == 1);
+			value[builtin.FirstComponent] = As<Float4>(Int4((*Pointer<Int>(data + OFFSET(DrawData, viewID)))));
+		});
+
 		routine.setInputBuiltin(spirvShader, spv::BuiltInInstanceIndex, [&](const SpirvShader::BuiltinMapping& builtin, Array<SIMD::Float>& value)
 		{
 			// TODO: we could do better here; we know InstanceIndex is uniform across all lanes
diff --git a/src/Vulkan/VkCommandBuffer.cpp b/src/Vulkan/VkCommandBuffer.cpp
index 92f03e5..fde05d6 100644
--- a/src/Vulkan/VkCommandBuffer.cpp
+++ b/src/Vulkan/VkCommandBuffer.cpp
@@ -515,7 +515,7 @@
 	{
 		auto const &pipelineState = executionState.pipelineState[VK_PIPELINE_BIND_POINT_GRAPHICS];
 
-		GraphicsPipeline* pipeline = static_cast<GraphicsPipeline*>(pipelineState.pipeline);
+		GraphicsPipeline *pipeline = static_cast<GraphicsPipeline *>(pipelineState.pipeline);
 
 		sw::Context context = pipeline->getContext();
 
@@ -527,12 +527,13 @@
 
 		// Apply either pipeline state or dynamic state
 		executionState.renderer->setScissor(pipeline->hasDynamicState(VK_DYNAMIC_STATE_SCISSOR) ?
-		                                    executionState.dynamicState.scissor : pipeline->getScissor());
+											executionState.dynamicState.scissor : pipeline->getScissor());
 		executionState.renderer->setViewport(pipeline->hasDynamicState(VK_DYNAMIC_STATE_VIEWPORT) ?
-		                                     executionState.dynamicState.viewport : pipeline->getViewport());
+											 executionState.dynamicState.viewport : pipeline->getViewport());
 		executionState.renderer->setBlendConstant(pipeline->hasDynamicState(VK_DYNAMIC_STATE_BLEND_CONSTANTS) ?
-		                                          executionState.dynamicState.blendConstants : pipeline->getBlendConstants());
-		if(pipeline->hasDynamicState(VK_DYNAMIC_STATE_DEPTH_BIAS))
+												  executionState.dynamicState.blendConstants
+																											  : pipeline->getBlendConstants());
+		if (pipeline->hasDynamicState(VK_DYNAMIC_STATE_DEPTH_BIAS))
 		{
 			// If the depth bias clamping feature is not enabled, depthBiasClamp must be 0.0
 			ASSERT(executionState.dynamicState.depthBiasClamp == 0.0f);
@@ -540,25 +541,27 @@
 			context.depthBias = executionState.dynamicState.depthBiasConstantFactor;
 			context.slopeDepthBias = executionState.dynamicState.depthBiasSlopeFactor;
 		}
-		if(pipeline->hasDynamicState(VK_DYNAMIC_STATE_DEPTH_BOUNDS) && context.depthBoundsTestEnable)
+		if (pipeline->hasDynamicState(VK_DYNAMIC_STATE_DEPTH_BOUNDS) && context.depthBoundsTestEnable)
 		{
 			// Unless the VK_EXT_depth_range_unrestricted extension is enabled minDepthBounds and maxDepthBounds must be between 0.0 and 1.0, inclusive
-			ASSERT(executionState.dynamicState.minDepthBounds >= 0.0f && executionState.dynamicState.minDepthBounds <= 1.0f);
-			ASSERT(executionState.dynamicState.maxDepthBounds >= 0.0f && executionState.dynamicState.maxDepthBounds <= 1.0f);
+			ASSERT(executionState.dynamicState.minDepthBounds >= 0.0f &&
+				   executionState.dynamicState.minDepthBounds <= 1.0f);
+			ASSERT(executionState.dynamicState.maxDepthBounds >= 0.0f &&
+				   executionState.dynamicState.maxDepthBounds <= 1.0f);
 
 			UNIMPLEMENTED("depthBoundsTestEnable");
 		}
-		if(pipeline->hasDynamicState(VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK) && context.stencilEnable)
+		if (pipeline->hasDynamicState(VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK) && context.stencilEnable)
 		{
 			context.frontStencil.compareMask = executionState.dynamicState.compareMask[0];
 			context.backStencil.compareMask = executionState.dynamicState.compareMask[1];
 		}
-		if(pipeline->hasDynamicState(VK_DYNAMIC_STATE_STENCIL_WRITE_MASK) && context.stencilEnable)
+		if (pipeline->hasDynamicState(VK_DYNAMIC_STATE_STENCIL_WRITE_MASK) && context.stencilEnable)
 		{
 			context.frontStencil.writeMask = executionState.dynamicState.writeMask[0];
 			context.backStencil.writeMask = executionState.dynamicState.writeMask[1];
 		}
-		if(pipeline->hasDynamicState(VK_DYNAMIC_STATE_STENCIL_REFERENCE) && context.stencilEnable)
+		if (pipeline->hasDynamicState(VK_DYNAMIC_STATE_STENCIL_REFERENCE) && context.stencilEnable)
 		{
 			context.frontStencil.reference = executionState.dynamicState.reference[0];
 			context.backStencil.reference = executionState.dynamicState.reference[1];
@@ -566,23 +569,23 @@
 
 		executionState.bindAttachments(context);
 
-		context.multiSampleMask = context.sampleMask & ((unsigned)0xFFFFFFFF >> (32 - context.sampleCount));
+		context.multiSampleMask = context.sampleMask & ((unsigned) 0xFFFFFFFF >> (32 - context.sampleCount));
 		context.occlusionEnabled = executionState.renderer->hasOcclusionQuery();
 
-		std::vector<std::pair<uint32_t, void*>> indexBuffers;
-		if(indexed)
+		std::vector<std::pair<uint32_t, void *>> indexBuffers;
+		if (indexed)
 		{
-			void* indexBuffer = executionState.indexBufferBinding.buffer->getOffsetPointer(
-				executionState.indexBufferBinding.offset + first * bytesPerIndex(executionState));
-			if(pipeline->hasPrimitiveRestartEnable())
+			void *indexBuffer = executionState.indexBufferBinding.buffer->getOffsetPointer(
+					executionState.indexBufferBinding.offset + first * bytesPerIndex(executionState));
+			if (pipeline->hasPrimitiveRestartEnable())
 			{
-				switch(executionState.indexType)
+				switch (executionState.indexType)
 				{
 				case VK_INDEX_TYPE_UINT16:
-					processPrimitiveRestart(static_cast<uint16_t*>(indexBuffer), count, pipeline, indexBuffers);
+					processPrimitiveRestart(static_cast<uint16_t *>(indexBuffer), count, pipeline, indexBuffers);
 					break;
 				case VK_INDEX_TYPE_UINT32:
-					processPrimitiveRestart(static_cast<uint32_t*>(indexBuffer), count, pipeline, indexBuffers);
+					processPrimitiveRestart(static_cast<uint32_t *>(indexBuffer), count, pipeline, indexBuffers);
 					break;
 				default:
 					UNIMPLEMENTED("executionState.indexType %d", int(executionState.indexType));
@@ -590,23 +593,32 @@
 			}
 			else
 			{
-				indexBuffers.push_back({ pipeline->computePrimitiveCount(count), indexBuffer });
+				indexBuffers.push_back({pipeline->computePrimitiveCount(count), indexBuffer});
 			}
 		}
 		else
 		{
-			indexBuffers.push_back({ pipeline->computePrimitiveCount(count), nullptr });
+			indexBuffers.push_back({pipeline->computePrimitiveCount(count), nullptr});
 		}
 
-		for(uint32_t instance = firstInstance; instance != firstInstance + instanceCount; instance++)
+		for (uint32_t instance = firstInstance; instance != firstInstance + instanceCount; instance++)
 		{
 			context.instanceID = instance;
 
-			for(auto indexBuffer : indexBuffers)
+			// FIXME: reconsider instances/views nesting.
+			auto viewMask = executionState.renderPass->getViewMask();
+			while (viewMask)
 			{
-				const uint32_t primitiveCount = indexBuffer.first;
-				context.indexBuffer = indexBuffer.second;
-				executionState.renderer->draw(&context, executionState.indexType, primitiveCount, vertexOffset, executionState.events);
+				context.viewID = sw::log2i(viewMask);
+				viewMask &= ~(1 << context.viewID);
+
+				for (auto indexBuffer : indexBuffers)
+				{
+					const uint32_t primitiveCount = indexBuffer.first;
+					context.indexBuffer = indexBuffer.second;
+					executionState.renderer->draw(&context, executionState.indexType, primitiveCount, vertexOffset,
+												  executionState.events);
+				}
 			}
 
 			executionState.renderer->advanceInstanceAttributes(context.input);
diff --git a/src/Vulkan/VkFramebuffer.cpp b/src/Vulkan/VkFramebuffer.cpp
index 768c492..f9c0716 100644
--- a/src/Vulkan/VkFramebuffer.cpp
+++ b/src/Vulkan/VkFramebuffer.cpp
@@ -17,6 +17,7 @@
 #include "VkRenderPass.hpp"
 #include <algorithm>
 #include <memory.h>
+#include <System/Math.hpp>
 
 namespace vk
 {
@@ -60,15 +61,38 @@
 
 			if(clearDepth || clearStencil)
 			{
-				attachments[i]->clear(pClearValues[i],
-				                      (clearDepth ? VK_IMAGE_ASPECT_DEPTH_BIT : 0) |
-				                      (clearStencil ? VK_IMAGE_ASPECT_STENCIL_BIT : 0),
-				                      renderArea);
+				auto aspectMask = (clearDepth ? VK_IMAGE_ASPECT_DEPTH_BIT : 0) |
+								  (clearStencil ? VK_IMAGE_ASPECT_STENCIL_BIT : 0);
+				if (renderPass->isMultiView())
+				{
+					auto viewMask = renderPass->getAttachmentViewMask(i);
+					while (viewMask)
+					{
+						uint32_t view = sw::log2i(viewMask);
+						viewMask &= ~(1 << view);
+						VkClearRect r{renderArea, view, 1};
+						attachments[i]->clear(pClearValues[i], aspectMask, r);
+					}
+				}
+				else
+					attachments[i]->clear(pClearValues[i], aspectMask, renderArea);
 			}
 		}
 		else if(attachment.loadOp == VK_ATTACHMENT_LOAD_OP_CLEAR)
 		{
-			attachments[i]->clear(pClearValues[i], VK_IMAGE_ASPECT_COLOR_BIT, renderArea);
+			if (renderPass->isMultiView())
+			{
+				auto viewMask = renderPass->getAttachmentViewMask(i);
+				while (viewMask)
+				{
+					uint32_t view = sw::log2i(viewMask);
+					viewMask &= ~(1 << view);
+					VkClearRect r{renderArea, view, 1};
+					attachments[i]->clear(pClearValues[i], VK_IMAGE_ASPECT_COLOR_BIT, r);
+				}
+			}
+			else
+				attachments[i]->clear(pClearValues[i], VK_IMAGE_ASPECT_COLOR_BIT, renderArea);
 		}
 	}
 }
@@ -84,8 +108,21 @@
 			ASSERT(attachment.colorAttachment < subpass.colorAttachmentCount);
 			ASSERT(subpass.pColorAttachments[attachment.colorAttachment].attachment < attachmentCount);
 
-			attachments[subpass.pColorAttachments[attachment.colorAttachment].attachment]->clear(
-				attachment.clearValue, attachment.aspectMask, rect);
+			if (renderPass->isMultiView())
+			{
+				auto viewMask = renderPass->getViewMask();
+				while (viewMask)
+				{
+					int view = sw::log2i(viewMask);
+					viewMask &= ~(1 << view);
+					VkClearRect r = rect;
+					r.baseArrayLayer = view;
+					attachments[subpass.pColorAttachments[attachment.colorAttachment].attachment]->clear(attachment.clearValue, attachment.aspectMask, r);
+				}
+			}
+			else
+				attachments[subpass.pColorAttachments[attachment.colorAttachment].attachment]->clear(
+					attachment.clearValue, attachment.aspectMask, rect);
 		}
 	}
 	else if(attachment.aspectMask & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT))
@@ -94,7 +131,20 @@
 
 		ASSERT(subpass.pDepthStencilAttachment->attachment < attachmentCount);
 
-		attachments[subpass.pDepthStencilAttachment->attachment]->clear(attachment.clearValue, attachment.aspectMask, rect);
+		if (renderPass->isMultiView())
+			{
+				auto viewMask = renderPass->getViewMask();
+				while (viewMask)
+				{
+					int view = sw::log2i(viewMask);
+					viewMask &= ~(1 << view);
+					VkClearRect r = rect;
+					r.baseArrayLayer = view;
+					attachments[subpass.pDepthStencilAttachment->attachment]->clear(attachment.clearValue, attachment.aspectMask, r);
+				}
+			}
+		else
+			attachments[subpass.pDepthStencilAttachment->attachment]->clear(attachment.clearValue, attachment.aspectMask, rect);
 	}
 }
 
@@ -113,7 +163,20 @@
 			uint32_t resolveAttachment = subpass.pResolveAttachments[i].attachment;
 			if(resolveAttachment != VK_ATTACHMENT_UNUSED)
 			{
-				attachments[subpass.pColorAttachments[i].attachment]->resolve(attachments[resolveAttachment]);
+				if (renderPass->isMultiView())
+				{
+					auto viewMask = renderPass->getViewMask();
+					while (viewMask)
+					{
+						int view = sw::log2i(viewMask);
+						viewMask &= ~(1 << view);
+						attachments[subpass.pColorAttachments[i].attachment]->resolve(attachments[resolveAttachment], view);
+					}
+				}
+				else
+				{
+					attachments[subpass.pColorAttachments[i].attachment]->resolve(attachments[resolveAttachment]);
+				}
 			}
 		}
 	}
diff --git a/src/Vulkan/VkImageView.cpp b/src/Vulkan/VkImageView.cpp
index a65f391..b0216fd 100644
--- a/src/Vulkan/VkImageView.cpp
+++ b/src/Vulkan/VkImageView.cpp
@@ -154,6 +154,36 @@
 	image->clear(clearValue, format, renderArea.rect, sr);
 }
 
+void ImageView::resolve(ImageView* resolveAttachment, int layer)
+{
+	if((subresourceRange.levelCount != 1) || (resolveAttachment->subresourceRange.levelCount != 1))
+	{
+		UNIMPLEMENTED("levelCount");
+	}
+
+	VkImageCopy region;
+	region.srcSubresource =
+	{
+		subresourceRange.aspectMask,
+		subresourceRange.baseMipLevel,
+		subresourceRange.baseArrayLayer + layer,
+		1
+	};
+	region.srcOffset = { 0, 0, 0 };
+	region.dstSubresource =
+	{
+		resolveAttachment->subresourceRange.aspectMask,
+		resolveAttachment->subresourceRange.baseMipLevel,
+		resolveAttachment->subresourceRange.baseArrayLayer + layer,
+		1
+	};
+	region.dstOffset = { 0, 0, 0 };
+	region.extent = image->getMipLevelExtent(static_cast<VkImageAspectFlagBits>(subresourceRange.aspectMask),
+	                                         subresourceRange.baseMipLevel);
+
+	image->copyTo(resolveAttachment->image, region);
+}
+
 void ImageView::resolve(ImageView* resolveAttachment)
 {
 	if((subresourceRange.levelCount != 1) || (resolveAttachment->subresourceRange.levelCount != 1))
diff --git a/src/Vulkan/VkImageView.hpp b/src/Vulkan/VkImageView.hpp
index db3848e..3d9942c 100644
--- a/src/Vulkan/VkImageView.hpp
+++ b/src/Vulkan/VkImageView.hpp
@@ -42,6 +42,7 @@
 	void clear(const VkClearValue& clearValues, VkImageAspectFlags aspectMask, const VkRect2D& renderArea);
 	void clear(const VkClearValue& clearValue, VkImageAspectFlags aspectMask, const VkClearRect& renderArea);
 	void resolve(ImageView* resolveAttachment);
+	void resolve(ImageView* resolveAttachment, int layer);
 
 	VkImageViewType getType() const { return viewType; }
 	Format getFormat(Usage usage = RAW) const;
diff --git a/src/Vulkan/VkPhysicalDevice.cpp b/src/Vulkan/VkPhysicalDevice.cpp
index 601c403..5e5b74c 100644
--- a/src/Vulkan/VkPhysicalDevice.cpp
+++ b/src/Vulkan/VkPhysicalDevice.cpp
@@ -119,7 +119,7 @@
 
 void PhysicalDevice::getFeatures(VkPhysicalDeviceMultiviewFeatures* features) const
 {
-	features->multiview = VK_FALSE;
+	features->multiview = VK_TRUE;
 	features->multiviewGeometryShader = VK_FALSE;
 	features->multiviewTessellationShader = VK_FALSE;
 }
@@ -295,8 +295,8 @@
 
 void PhysicalDevice::getProperties(VkPhysicalDeviceMultiviewProperties* properties) const
 {
-	properties->maxMultiviewViewCount = 0;
-	properties->maxMultiviewInstanceIndex = 0;
+	properties->maxMultiviewViewCount = 6;
+	properties->maxMultiviewInstanceIndex = 1u<<27;
 }
 
 void PhysicalDevice::getProperties(VkPhysicalDevicePointClippingProperties* properties) const
diff --git a/src/Vulkan/VkRenderPass.cpp b/src/Vulkan/VkRenderPass.cpp
index 9a23c0a..852679b 100644
--- a/src/Vulkan/VkRenderPass.cpp
+++ b/src/Vulkan/VkRenderPass.cpp
@@ -15,15 +15,6 @@
 #include "VkRenderPass.hpp"
 #include <cstring>
 
-namespace
-{
-	void MarkFirstUse(int& attachment, int subpass)
-	{
-		if (attachment == -1)
-			attachment = subpass;
-	}
-}
-
 namespace vk
 {
 
@@ -41,6 +32,8 @@
 	subpasses = reinterpret_cast<VkSubpassDescription*>(hostMemory);
 	memcpy(subpasses, pCreateInfo->pSubpasses, subpassesSize);
 	hostMemory += subpassesSize;
+	uint32_t *masks = reinterpret_cast<uint32_t *>(hostMemory);
+	hostMemory += pCreateInfo->subpassCount * sizeof(uint32_t);
 
 	if(pCreateInfo->attachmentCount > 0)
 	{
@@ -51,9 +44,43 @@
 
 		size_t firstUseSize = pCreateInfo->attachmentCount * sizeof(int);
 		attachmentFirstUse = reinterpret_cast<int*>(hostMemory);
-		for (auto i = 0u; i < pCreateInfo->attachmentCount; i++)
-			attachmentFirstUse[i] = -1;
 		hostMemory += firstUseSize;
+
+		attachmentViewMasks = reinterpret_cast<uint32_t *>(hostMemory);
+		hostMemory += pCreateInfo->attachmentCount * sizeof(uint32_t);
+		for (auto i = 0u; i < pCreateInfo->attachmentCount; i++)
+		{
+			attachmentFirstUse[i] = -1;
+			attachmentViewMasks[i] = 0;
+		}
+	}
+
+	const VkBaseInStructure* extensionCreateInfo = reinterpret_cast<const VkBaseInStructure*>(pCreateInfo->pNext);
+	while (extensionCreateInfo)
+	{
+		switch (extensionCreateInfo->sType)
+		{
+		case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
+		{
+			// Renderpass uses multiview if this structure is present AND some subpass specifies
+			// a nonzero view mask
+			auto const *multiviewCreateInfo = reinterpret_cast<VkRenderPassMultiviewCreateInfo const *>(extensionCreateInfo);
+			for (auto i = 0u; i < pCreateInfo->subpassCount; i++)
+			{
+				masks[i] = multiviewCreateInfo->pViewMasks[i];
+				// This is now a multiview renderpass, so make the masks available
+				if (masks[i])
+					viewMasks = masks;
+			}
+
+			break;
+		}
+		default:
+			/* Unknown structure in pNext chain must be ignored */
+			break;
+		}
+
+		extensionCreateInfo = extensionCreateInfo->pNext;
 	}
 
 	// Deep copy subpasses
@@ -77,7 +104,7 @@
 			for (auto j = 0u; j < subpasses[i].inputAttachmentCount; j++)
 			{
 				if (subpass.pInputAttachments[j].attachment != VK_ATTACHMENT_UNUSED)
-					MarkFirstUse(attachmentFirstUse[subpass.pInputAttachments[j].attachment], i);
+					MarkFirstUse(subpass.pInputAttachments[j].attachment, i);
 			}
 		}
 
@@ -100,10 +127,10 @@
 			for (auto j = 0u; j < subpasses[i].colorAttachmentCount; j++)
 			{
 				if (subpass.pColorAttachments[j].attachment != VK_ATTACHMENT_UNUSED)
-					MarkFirstUse(attachmentFirstUse[subpass.pColorAttachments[j].attachment], i);
+					MarkFirstUse(subpass.pColorAttachments[j].attachment, i);
 				if (subpass.pResolveAttachments &&
 					subpass.pResolveAttachments[j].attachment != VK_ATTACHMENT_UNUSED)
-					MarkFirstUse(attachmentFirstUse[subpass.pResolveAttachments[j].attachment], i);
+					MarkFirstUse(subpass.pResolveAttachments[j].attachment, i);
 			}
 		}
 
@@ -115,7 +142,7 @@
 			hostMemory += sizeof(VkAttachmentReference);
 
 			if (subpass.pDepthStencilAttachment->attachment != VK_ATTACHMENT_UNUSED)
-				MarkFirstUse(attachmentFirstUse[subpass.pDepthStencilAttachment->attachment], i);
+				MarkFirstUse(subpass.pDepthStencilAttachment->attachment, i);
 		}
 
 		if(subpass.preserveAttachmentCount > 0)
@@ -129,7 +156,7 @@
 			for (auto j = 0u; j < subpasses[i].preserveAttachmentCount; j++)
 			{
 				if (subpass.pPreserveAttachments[j] != VK_ATTACHMENT_UNUSED)
-					MarkFirstUse(attachmentFirstUse[subpass.pPreserveAttachments[j]], i);
+					MarkFirstUse(subpass.pPreserveAttachments[j], i);
 			}
 		}
 	}
@@ -150,7 +177,8 @@
 size_t RenderPass::ComputeRequiredAllocationSize(const VkRenderPassCreateInfo* pCreateInfo)
 {
 	size_t attachmentSize = pCreateInfo->attachmentCount * sizeof(VkAttachmentDescription)
-			+ pCreateInfo->attachmentCount * sizeof(int);
+			+ pCreateInfo->attachmentCount * sizeof(int)			// first use
+			+ pCreateInfo->attachmentCount * sizeof(uint32_t);		// union of subpass view masks, per attachment
 	size_t subpassesSize = 0;
 	for(uint32_t i = 0; i < pCreateInfo->subpassCount; ++i)
 	{
@@ -166,7 +194,8 @@
 		}
 		subpassesSize += sizeof(VkSubpassDescription) +
 		                 sizeof(VkAttachmentReference) * nbAttachments +
-		                 sizeof(uint32_t) * subpass.preserveAttachmentCount;
+		                 sizeof(uint32_t) * subpass.preserveAttachmentCount +
+		                 sizeof(uint32_t);			// view mask
 	}
 	size_t dependenciesSize = pCreateInfo->dependencyCount * sizeof(VkSubpassDependency);
 
@@ -195,4 +224,16 @@
 	currentSubpass = 0;
 }
 
+void RenderPass::MarkFirstUse(int attachment, int subpass)
+{
+	// FIXME: we may not actually need to track attachmentFirstUse if we're going to eagerly
+	//  clear attachments at the start of the renderpass; can use attachmentViewMasks always instead.
+
+	if (attachmentFirstUse[attachment] == -1)
+		attachmentFirstUse[attachment] = subpass;
+
+	if (isMultiView())
+		attachmentViewMasks[attachment] |= viewMasks[subpass];
+}
+
 } // namespace vk
\ No newline at end of file
diff --git a/src/Vulkan/VkRenderPass.hpp b/src/Vulkan/VkRenderPass.hpp
index 0fe9e22..2d0841f 100644
--- a/src/Vulkan/VkRenderPass.hpp
+++ b/src/Vulkan/VkRenderPass.hpp
@@ -76,6 +76,21 @@
 		return attachmentFirstUse[i] >= 0;
 	}
 
+	uint32_t getViewMask() const
+	{
+		return viewMasks ? viewMasks[currentSubpass] : 1;
+	}
+
+	bool isMultiView() const
+	{
+		return viewMasks != nullptr;
+	}
+
+	uint32_t getAttachmentViewMask(uint32_t i) const
+	{
+		return attachmentViewMasks[i];
+	}
+
 private:
 	uint32_t                 attachmentCount = 0;
 	VkAttachmentDescription* attachments = nullptr;
@@ -85,6 +100,10 @@
 	VkSubpassDependency*     dependencies = nullptr;
 	uint32_t                 currentSubpass = 0;
 	int*                     attachmentFirstUse = nullptr;
+	uint32_t*                viewMasks = nullptr;
+	uint32_t*                attachmentViewMasks = nullptr;
+
+	void MarkFirstUse(int attachment, int subpass);
 };
 
 static inline RenderPass* Cast(VkRenderPass object)
diff --git a/src/Vulkan/libVulkan.cpp b/src/Vulkan/libVulkan.cpp
index f2bbf2f..1c66491 100644
--- a/src/Vulkan/libVulkan.cpp
+++ b/src/Vulkan/libVulkan.cpp
@@ -511,8 +511,7 @@
 			{
 				const VkPhysicalDeviceMultiviewFeatures* multiviewFeatures = reinterpret_cast<const VkPhysicalDeviceMultiviewFeatures*>(extensionCreateInfo);
 
-				if (multiviewFeatures->multiview ||
-				    multiviewFeatures->multiviewGeometryShader ||
+				if (multiviewFeatures->multiviewGeometryShader ||
 				    multiviewFeatures->multiviewTessellationShader)
 				{
 					return VK_ERROR_FEATURE_NOT_PRESENT;