diff --git a/src/Pipeline/SpirvShader.cpp b/src/Pipeline/SpirvShader.cpp
index eac3fef..ee3e1a5 100644
--- a/src/Pipeline/SpirvShader.cpp
+++ b/src/Pipeline/SpirvShader.cpp
@@ -459,6 +459,7 @@
 				case spv::CapabilityUniformTexelBufferArrayDynamicIndexing: capabilities.UniformTexelBufferArrayDynamicIndexing = true; break;
 				case spv::CapabilityStorageTexelBufferArrayDynamicIndexing: capabilities.StorageTexelBufferArrayDynamicIndexing = true; break;
 				case spv::CapabilityUniformBufferArrayNonUniformIndexing: capabilities.UniformBufferArrayNonUniformIndex = true; break;
+				case spv::CapabilitySampledImageArrayNonUniformIndexing: capabilities.SampledImageArrayNonUniformIndexing = true; break;
 				case spv::CapabilityPhysicalStorageBufferAddresses: capabilities.PhysicalStorageBufferAddresses = true; break;
 				default:
 					UNSUPPORTED("Unsupported capability %u", insn.word(1));
diff --git a/src/Pipeline/SpirvShader.hpp b/src/Pipeline/SpirvShader.hpp
index 51df887..74dc1c6 100644
--- a/src/Pipeline/SpirvShader.hpp
+++ b/src/Pipeline/SpirvShader.hpp
@@ -393,10 +393,10 @@
 		Kind kind = Kind::Unknown;
 	};
 
-	class SampledImage : public SIMD::Pointer
+	class SampledImagePointer : public SIMD::Pointer
 	{
 	public:
-		SampledImage(SIMD::Pointer image, Object::ID sampler)
+		SampledImagePointer(SIMD::Pointer image, Object::ID sampler)
 		    : SIMD::Pointer(image)
 		    , samplerId(sampler)
 		{}
@@ -749,6 +749,7 @@
 		bool UniformTexelBufferArrayNonUniformIndexing : 1;
 		bool UniformTexelBufferArrayDynamicIndexing : 1;
 		bool UniformBufferArrayNonUniformIndex : 1;
+		bool SampledImageArrayNonUniformIndexing : 1;
 		bool PhysicalStorageBufferAddresses : 1;
 	};
 
@@ -1185,13 +1186,13 @@
 			return it->second;
 		}
 
-		void createSampledImage(Object::ID id, SampledImage ptr)
+		void createSampledImage(Object::ID id, SampledImagePointer ptr)
 		{
 			bool added = sampledImages.emplace(id, ptr).second;
 			ASSERT_MSG(added, "Sampled image %d created twice", id.value());
 		}
 
-		SampledImage const &getSampledImage(Object::ID id) const
+		SampledImagePointer const &getSampledImage(Object::ID id) const
 		{
 			auto it = sampledImages.find(id);
 			ASSERT_MSG(it != sampledImages.end(), "Unknown sampled image %d", id.value());
@@ -1211,7 +1212,7 @@
 	private:
 		std::unordered_map<Object::ID, Intermediate> intermediates;
 		std::unordered_map<Object::ID, SIMD::Pointer> pointers;
-		std::unordered_map<Object::ID, SampledImage> sampledImages;
+		std::unordered_map<Object::ID, SampledImagePointer> sampledImages;
 
 		const unsigned int multiSampleCount;
 	};
@@ -1278,7 +1279,7 @@
 			return (pointer != nullptr);
 		}
 
-		const SampledImage &SampledImage(uint32_t i) const
+		const SampledImagePointer &SampledImage(uint32_t i) const
 		{
 			ASSERT(intermediate == nullptr);
 
@@ -1299,7 +1300,7 @@
 		const uint32_t *constant;
 		const Intermediate *intermediate;
 		const SIMD::Pointer *pointer;
-		const SpirvShader::SampledImage *sampledImage;
+		const SampledImagePointer *sampledImage;
 
 	public:
 		const uint32_t componentCount;
@@ -1448,7 +1449,9 @@
 	// Emits code to sample an image, regardless of whether any SIMD lanes are active.
 	void EmitImageSampleUnconditional(Array<SIMD::Float> &out, const ImageInstruction &instruction, EmitState *state) const;
 
-	Pointer<Byte> lookupSamplerFunction(Pointer<Byte> imageDescriptor, const ImageInstruction &instruction, EmitState *state) const;
+	Pointer<Byte> getSamplerDescriptor(Pointer<Byte> imageDescriptor, const ImageInstruction &instruction, EmitState *state) const;
+	Pointer<Byte> getSamplerDescriptor(Pointer<Byte> imageDescriptor, const ImageInstruction &instruction, int laneIdx, EmitState *state) const;
+	Pointer<Byte> lookupSamplerFunction(Pointer<Byte> imageDescriptor, Pointer<Byte> samplerDescriptor, const ImageInstruction &instruction, EmitState *state) const;
 	void callSamplerFunction(Pointer<Byte> samplerFunction, Array<SIMD::Float> &out, Pointer<Byte> imageDescriptor, const ImageInstruction &instruction, EmitState *state) const;
 
 	void GetImageDimensions(EmitState const *state, Type const &resultTy, Object::ID imageId, Object::ID lodId, Intermediate &dst) const;
diff --git a/src/Pipeline/SpirvShaderImage.cpp b/src/Pipeline/SpirvShaderImage.cpp
index 4f28a39..1e7c97b 100644
--- a/src/Pipeline/SpirvShaderImage.cpp
+++ b/src/Pipeline/SpirvShaderImage.cpp
@@ -101,7 +101,7 @@
 
 			if(state->isSampledImage(sampledImageId))  // Result of an OpSampledImage instruction
 			{
-				const SampledImage &sampledImage = state->getSampledImage(sampledImageId);
+				const SampledImagePointer &sampledImage = state->getSampledImage(sampledImageId);
 				imageId = spirv.getObject(sampledImageId).definition.word(3);
 				samplerId = sampledImage.samplerId;
 			}
@@ -350,23 +350,56 @@
 
 void SpirvShader::EmitImageSampleUnconditional(Array<SIMD::Float> &out, const ImageInstruction &instruction, EmitState *state) const
 {
-	Pointer<Byte> imageDescriptor = state->getImage(instruction.imageId).getUniformPointer();  // vk::SampledImageDescriptor*
+	auto decorations = GetDecorationsForId(instruction.imageId);
 
-	Pointer<Byte> samplerFunction = lookupSamplerFunction(imageDescriptor, instruction, state);
+	if(decorations.NonUniform)
+	{
+		SIMD::Int activeLaneMask = state->activeLaneMask();
+		SIMD::Pointer imagePointer = state->getImage(instruction.imageId);
+		// PerLane output
+		for(int laneIdx = 0; laneIdx < SIMD::Width; laneIdx++)
+		{
+			Array<SIMD::Float> laneOut(out.getArraySize());
+			If(Extract(activeLaneMask, laneIdx) != 0)
+			{
+				Pointer<Byte> imageDescriptor = imagePointer.getPointerForLane(laneIdx);  // vk::SampledImageDescriptor*
+				Pointer<Byte> samplerDescriptor = getSamplerDescriptor(imageDescriptor, instruction, laneIdx, state);
 
-	callSamplerFunction(samplerFunction, out, imageDescriptor, instruction, state);
+				Pointer<Byte> samplerFunction = lookupSamplerFunction(imageDescriptor, samplerDescriptor, instruction, state);
+
+				callSamplerFunction(samplerFunction, laneOut, imageDescriptor, instruction, state);
+			}
+
+			for(int outIdx = 0; outIdx < out.getArraySize(); outIdx++)
+			{
+				out[outIdx] = Insert(out[outIdx], Extract(laneOut[outIdx], laneIdx), laneIdx);
+			}
+		}
+	}
+	else
+	{
+		Pointer<Byte> imageDescriptor = state->getImage(instruction.imageId).getUniformPointer();  // vk::SampledImageDescriptor*
+		Pointer<Byte> samplerDescriptor = getSamplerDescriptor(imageDescriptor, instruction, state);
+
+		Pointer<Byte> samplerFunction = lookupSamplerFunction(imageDescriptor, samplerDescriptor, instruction, state);
+
+		callSamplerFunction(samplerFunction, out, imageDescriptor, instruction, state);
+	}
 }
 
-Pointer<Byte> SpirvShader::lookupSamplerFunction(Pointer<Byte> imageDescriptor, const ImageInstruction &instruction, EmitState *state) const
+Pointer<Byte> SpirvShader::getSamplerDescriptor(Pointer<Byte> imageDescriptor, const ImageInstruction &instruction, EmitState *state) const
 {
-	Int samplerId = 0;
+	return ((instruction.samplerId == instruction.imageId) || (instruction.samplerId == 0)) ? imageDescriptor : state->getImage(instruction.samplerId).getUniformPointer();
+}
 
-	if(instruction.samplerId != 0)
-	{
-		Pointer<Byte> samplerDescriptor = state->getPointer(instruction.samplerId).getUniformPointer();  // vk::SampledImageDescriptor*
+Pointer<Byte> SpirvShader::getSamplerDescriptor(Pointer<Byte> imageDescriptor, const ImageInstruction &instruction, int laneIdx, EmitState *state) const
+{
+	return ((instruction.samplerId == instruction.imageId) || (instruction.samplerId == 0)) ? imageDescriptor : state->getImage(instruction.samplerId).getPointerForLane(laneIdx);
+}
 
-		samplerId = *Pointer<rr::Int>(samplerDescriptor + OFFSET(vk::SampledImageDescriptor, samplerId));  // vk::Sampler::id
-	}
+Pointer<Byte> SpirvShader::lookupSamplerFunction(Pointer<Byte> imageDescriptor, Pointer<Byte> samplerDescriptor, const ImageInstruction &instruction, EmitState *state) const
+{
+	Int samplerId = (instruction.samplerId != 0) ? *Pointer<rr::Int>(samplerDescriptor + OFFSET(vk::SampledImageDescriptor, samplerId)) : Int(0);
 
 	auto &cache = state->routine->samplerCache.at(instruction.position);
 	Bool cacheHit = (cache.imageDescriptor == imageDescriptor) && (cache.samplerId == samplerId);  // TODO(b/205566405): Skip sampler ID check for samplerless instructions.
@@ -1252,17 +1285,18 @@
 	SIMD::Pointer ptr = state->getPointer(instruction.imageId);
 	if(ptr.isBasePlusOffset)
 	{
-		Pointer<Byte> descriptor = ptr.getUniformPointer();  // vk::StorageImageDescriptor*
+		Pointer<Byte> imageDescriptor = ptr.getUniformPointer();  // vk::StorageImageDescriptor* or vk::SampledImageDescriptor*
+		Pointer<Byte> samplerDescriptor = getSamplerDescriptor(imageDescriptor, instruction, state);
 
 		if(imageFormat == VK_FORMAT_UNDEFINED)  // spv::ImageFormatUnknown
 		{
-			Pointer<Byte> samplerFunction = lookupSamplerFunction(descriptor, instruction, state);
+			Pointer<Byte> samplerFunction = lookupSamplerFunction(imageDescriptor, samplerDescriptor, instruction, state);
 
-			Call<ImageSampler>(samplerFunction, descriptor, &coord, &texelAndMask, state->routine->constants);
+			Call<ImageSampler>(samplerFunction, imageDescriptor, &coord, &texelAndMask, state->routine->constants);
 		}
 		else
 		{
-			WriteImage(instruction, descriptor, &coord, &texelAndMask, imageFormat);
+			WriteImage(instruction, imageDescriptor, &coord, &texelAndMask, imageFormat);
 		}
 	}
 	else
@@ -1272,16 +1306,17 @@
 			SIMD::Int singleLaneMask = 0;
 			singleLaneMask = Insert(singleLaneMask, 0xffffffff, j);
 			texelAndMask[4] = state->activeStoresAndAtomicsMask() & singleLaneMask;
-			Pointer<Byte> descriptor = ptr.getPointerForLane(j);
+			Pointer<Byte> imageDescriptor = ptr.getPointerForLane(j);
+			Pointer<Byte> samplerDescriptor = getSamplerDescriptor(imageDescriptor, instruction, j, state);
 			if(imageFormat == VK_FORMAT_UNDEFINED)  // spv::ImageFormatUnknown
 			{
-				Pointer<Byte> samplerFunction = lookupSamplerFunction(descriptor, instruction, state);
+				Pointer<Byte> samplerFunction = lookupSamplerFunction(imageDescriptor, samplerDescriptor, instruction, state);
 
-				Call<ImageSampler>(samplerFunction, descriptor, &coord, &texelAndMask, state->routine->constants);
+				Call<ImageSampler>(samplerFunction, imageDescriptor, &coord, &texelAndMask, state->routine->constants);
 			}
 			else
 			{
-				WriteImage(instruction, descriptor, &coord, &texelAndMask, imageFormat);
+				WriteImage(instruction, imageDescriptor, &coord, &texelAndMask, imageFormat);
 			}
 		}
 	}
diff --git a/src/Vulkan/VkPhysicalDevice.cpp b/src/Vulkan/VkPhysicalDevice.cpp
index 0f8d200..59eef6b 100644
--- a/src/Vulkan/VkPhysicalDevice.cpp
+++ b/src/Vulkan/VkPhysicalDevice.cpp
@@ -247,7 +247,7 @@
 	features->shaderUniformTexelBufferArrayDynamicIndexing = VK_TRUE;
 	features->shaderStorageTexelBufferArrayDynamicIndexing = VK_TRUE;
 	features->shaderUniformBufferArrayNonUniformIndexing = VK_TRUE;
-	features->shaderSampledImageArrayNonUniformIndexing = VK_FALSE;
+	features->shaderSampledImageArrayNonUniformIndexing = VK_TRUE;
 	features->shaderStorageBufferArrayNonUniformIndexing = VK_TRUE;
 	features->shaderStorageImageArrayNonUniformIndexing = VK_FALSE;
 	features->shaderInputAttachmentArrayNonUniformIndexing = VK_FALSE;