diff --git a/src/Device/Context.cpp b/src/Device/Context.cpp
index 550a815..64148a5 100644
--- a/src/Device/Context.cpp
+++ b/src/Device/Context.cpp
@@ -531,6 +531,30 @@
 				blendConstants.w = colorBlendState->blendConstants[3];
 			}
 
+			const VkBaseInStructure *extensionColorBlendInfo = reinterpret_cast<const VkBaseInStructure *>(colorBlendState->pNext);
+			while(extensionColorBlendInfo)
+			{
+				switch(extensionColorBlendInfo->sType)
+				{
+				case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT:
+					{
+						const VkPipelineColorBlendAdvancedStateCreateInfoEXT *colorBlendAdvancedCreateInfo = reinterpret_cast<const VkPipelineColorBlendAdvancedStateCreateInfoEXT *>(extensionColorBlendInfo);
+						ASSERT(colorBlendAdvancedCreateInfo->blendOverlap == VK_BLEND_OVERLAP_UNCORRELATED_EXT);
+						ASSERT(colorBlendAdvancedCreateInfo->dstPremultiplied == VK_TRUE);
+						ASSERT(colorBlendAdvancedCreateInfo->srcPremultiplied == VK_TRUE);
+					}
+					break;
+				case VK_STRUCTURE_TYPE_MAX_ENUM:
+					// dEQP tests that this value is ignored.
+					break;
+				default:
+					UNSUPPORTED("pCreateInfo->colorBlendState->pNext sType = %s", vk::Stringify(extensionColorBlendInfo->sType).c_str());
+					break;
+				}
+
+				extensionColorBlendInfo = extensionColorBlendInfo->pNext;
+			}
+
 			ASSERT(colorBlendState->attachmentCount <= sw::MAX_COLOR_BUFFERS);
 			for(auto i = 0u; i < colorBlendState->attachmentCount; i++)
 			{
@@ -725,8 +749,22 @@
 	case VK_BLEND_OP_REVERSE_SUBTRACT:
 		return blendState[index].sourceBlendFactor;
 	case VK_BLEND_OP_MIN:
-		return VK_BLEND_FACTOR_ONE;
 	case VK_BLEND_OP_MAX:
+	case VK_BLEND_OP_MULTIPLY_EXT:
+	case VK_BLEND_OP_SCREEN_EXT:
+	case VK_BLEND_OP_OVERLAY_EXT:
+	case VK_BLEND_OP_DARKEN_EXT:
+	case VK_BLEND_OP_LIGHTEN_EXT:
+	case VK_BLEND_OP_COLORDODGE_EXT:
+	case VK_BLEND_OP_COLORBURN_EXT:
+	case VK_BLEND_OP_HARDLIGHT_EXT:
+	case VK_BLEND_OP_SOFTLIGHT_EXT:
+	case VK_BLEND_OP_DIFFERENCE_EXT:
+	case VK_BLEND_OP_EXCLUSION_EXT:
+	case VK_BLEND_OP_HSL_HUE_EXT:
+	case VK_BLEND_OP_HSL_SATURATION_EXT:
+	case VK_BLEND_OP_HSL_COLOR_EXT:
+	case VK_BLEND_OP_HSL_LUMINOSITY_EXT:
 		return VK_BLEND_FACTOR_ONE;
 	default:
 		ASSERT(false);
@@ -748,8 +786,22 @@
 	case VK_BLEND_OP_REVERSE_SUBTRACT:
 		return blendState[index].destBlendFactor;
 	case VK_BLEND_OP_MIN:
-		return VK_BLEND_FACTOR_ONE;
 	case VK_BLEND_OP_MAX:
+	case VK_BLEND_OP_MULTIPLY_EXT:
+	case VK_BLEND_OP_SCREEN_EXT:
+	case VK_BLEND_OP_OVERLAY_EXT:
+	case VK_BLEND_OP_DARKEN_EXT:
+	case VK_BLEND_OP_LIGHTEN_EXT:
+	case VK_BLEND_OP_COLORDODGE_EXT:
+	case VK_BLEND_OP_COLORBURN_EXT:
+	case VK_BLEND_OP_HARDLIGHT_EXT:
+	case VK_BLEND_OP_SOFTLIGHT_EXT:
+	case VK_BLEND_OP_DIFFERENCE_EXT:
+	case VK_BLEND_OP_EXCLUSION_EXT:
+	case VK_BLEND_OP_HSL_HUE_EXT:
+	case VK_BLEND_OP_HSL_SATURATION_EXT:
+	case VK_BLEND_OP_HSL_COLOR_EXT:
+	case VK_BLEND_OP_HSL_LUMINOSITY_EXT:
 		return VK_BLEND_FACTOR_ONE;
 	default:
 		ASSERT(false);
@@ -862,9 +914,23 @@
 			}
 		}
 	case VK_BLEND_OP_MIN:
-		return VK_BLEND_OP_MIN;
 	case VK_BLEND_OP_MAX:
-		return VK_BLEND_OP_MAX;
+	case VK_BLEND_OP_MULTIPLY_EXT:
+	case VK_BLEND_OP_SCREEN_EXT:
+	case VK_BLEND_OP_OVERLAY_EXT:
+	case VK_BLEND_OP_DARKEN_EXT:
+	case VK_BLEND_OP_LIGHTEN_EXT:
+	case VK_BLEND_OP_COLORDODGE_EXT:
+	case VK_BLEND_OP_COLORBURN_EXT:
+	case VK_BLEND_OP_HARDLIGHT_EXT:
+	case VK_BLEND_OP_SOFTLIGHT_EXT:
+	case VK_BLEND_OP_DIFFERENCE_EXT:
+	case VK_BLEND_OP_EXCLUSION_EXT:
+	case VK_BLEND_OP_HSL_HUE_EXT:
+	case VK_BLEND_OP_HSL_SATURATION_EXT:
+	case VK_BLEND_OP_HSL_COLOR_EXT:
+	case VK_BLEND_OP_HSL_LUMINOSITY_EXT:
+		return blendState[index].blendOperation;
 	default:
 		ASSERT(false);
 	}
@@ -883,8 +949,22 @@
 	case VK_BLEND_OP_REVERSE_SUBTRACT:
 		return blendState[index].sourceBlendFactorAlpha;
 	case VK_BLEND_OP_MIN:
-		return VK_BLEND_FACTOR_ONE;
 	case VK_BLEND_OP_MAX:
+	case VK_BLEND_OP_MULTIPLY_EXT:
+	case VK_BLEND_OP_SCREEN_EXT:
+	case VK_BLEND_OP_OVERLAY_EXT:
+	case VK_BLEND_OP_DARKEN_EXT:
+	case VK_BLEND_OP_LIGHTEN_EXT:
+	case VK_BLEND_OP_COLORDODGE_EXT:
+	case VK_BLEND_OP_COLORBURN_EXT:
+	case VK_BLEND_OP_HARDLIGHT_EXT:
+	case VK_BLEND_OP_SOFTLIGHT_EXT:
+	case VK_BLEND_OP_DIFFERENCE_EXT:
+	case VK_BLEND_OP_EXCLUSION_EXT:
+	case VK_BLEND_OP_HSL_HUE_EXT:
+	case VK_BLEND_OP_HSL_SATURATION_EXT:
+	case VK_BLEND_OP_HSL_COLOR_EXT:
+	case VK_BLEND_OP_HSL_LUMINOSITY_EXT:
 		return VK_BLEND_FACTOR_ONE;
 	default:
 		ASSERT(false);
@@ -904,8 +984,22 @@
 	case VK_BLEND_OP_REVERSE_SUBTRACT:
 		return blendState[index].destBlendFactorAlpha;
 	case VK_BLEND_OP_MIN:
-		return VK_BLEND_FACTOR_ONE;
 	case VK_BLEND_OP_MAX:
+	case VK_BLEND_OP_MULTIPLY_EXT:
+	case VK_BLEND_OP_SCREEN_EXT:
+	case VK_BLEND_OP_OVERLAY_EXT:
+	case VK_BLEND_OP_DARKEN_EXT:
+	case VK_BLEND_OP_LIGHTEN_EXT:
+	case VK_BLEND_OP_COLORDODGE_EXT:
+	case VK_BLEND_OP_COLORBURN_EXT:
+	case VK_BLEND_OP_HARDLIGHT_EXT:
+	case VK_BLEND_OP_SOFTLIGHT_EXT:
+	case VK_BLEND_OP_DIFFERENCE_EXT:
+	case VK_BLEND_OP_EXCLUSION_EXT:
+	case VK_BLEND_OP_HSL_HUE_EXT:
+	case VK_BLEND_OP_HSL_SATURATION_EXT:
+	case VK_BLEND_OP_HSL_COLOR_EXT:
+	case VK_BLEND_OP_HSL_LUMINOSITY_EXT:
 		return VK_BLEND_FACTOR_ONE;
 	default:
 		ASSERT(false);
@@ -1019,6 +1113,24 @@
 		return VK_BLEND_OP_MIN;
 	case VK_BLEND_OP_MAX:
 		return VK_BLEND_OP_MAX;
+	case VK_BLEND_OP_MULTIPLY_EXT:
+	case VK_BLEND_OP_SCREEN_EXT:
+	case VK_BLEND_OP_OVERLAY_EXT:
+	case VK_BLEND_OP_DARKEN_EXT:
+	case VK_BLEND_OP_LIGHTEN_EXT:
+	case VK_BLEND_OP_COLORDODGE_EXT:
+	case VK_BLEND_OP_COLORBURN_EXT:
+	case VK_BLEND_OP_HARDLIGHT_EXT:
+	case VK_BLEND_OP_SOFTLIGHT_EXT:
+	case VK_BLEND_OP_DIFFERENCE_EXT:
+	case VK_BLEND_OP_EXCLUSION_EXT:
+	case VK_BLEND_OP_HSL_HUE_EXT:
+	case VK_BLEND_OP_HSL_SATURATION_EXT:
+	case VK_BLEND_OP_HSL_COLOR_EXT:
+	case VK_BLEND_OP_HSL_LUMINOSITY_EXT:
+		// All of the currently supported advanced blend modes compute the alpha the same way
+		// Use VK_BLEND_OP_MULTIPLY_EXT as a placeholder
+		return VK_BLEND_OP_MULTIPLY_EXT;
 	default:
 		ASSERT(false);
 	}
diff --git a/src/Pipeline/PixelRoutine.cpp b/src/Pipeline/PixelRoutine.cpp
index 8053391..ab1187c 100644
--- a/src/Pipeline/PixelRoutine.cpp
+++ b/src/Pipeline/PixelRoutine.cpp
@@ -1948,6 +1948,243 @@
 	}
 }
 
+Float4 PixelRoutine::blendOpOverlay(Float4 &src, Float4 &dst)
+{
+	Int4 largeDst = CmpGT(dst, Float4(0.5f));
+	return As<Float4>(
+	    (~largeDst &
+	     As<Int4>(Float4(2.0f) * src * dst)) |
+	    (largeDst &
+	     As<Int4>(Float4(1.0f) - (Float4(2.0f) * (Float4(1.0f) - src) * (Float4(1.0f) - dst)))));
+}
+
+Float4 PixelRoutine::blendOpColorDodge(Float4 &src, Float4 &dst)
+{
+	Int4 srcBelowOne = CmpLT(src, Float4(1.0f));
+	Int4 positiveDst = CmpGT(dst, Float4(0.0f));
+	return As<Float4>(positiveDst & ((~srcBelowOne &
+	                                  As<Int4>(Float4(1.0f))) |
+	                                 (srcBelowOne &
+	                                  As<Int4>(Min(Float4(1.0f), (dst / (Float4(1.0f) - src)))))));
+}
+
+Float4 PixelRoutine::blendOpColorBurn(Float4 &src, Float4 &dst)
+{
+	Int4 dstBelowOne = CmpLT(dst, Float4(1.0f));
+	Int4 positiveSrc = CmpGT(src, Float4(0.0f));
+	return As<Float4>(
+	    (~dstBelowOne &
+	     As<Int4>(Float4(1.0f))) |
+	    (dstBelowOne & positiveSrc &
+	     As<Int4>(Float4(1.0f) - Min(Float4(1.0f), (Float4(1.0f) - dst) / src))));
+}
+
+Float4 PixelRoutine::blendOpHardlight(Float4 &src, Float4 &dst)
+{
+	Int4 largeSrc = CmpGT(src, Float4(0.5f));
+	return As<Float4>(
+	    (~largeSrc &
+	     As<Int4>(Float4(2.0f) * src * dst)) |
+	    (largeSrc &
+	     As<Int4>(Float4(1.0f) - (Float4(2.0f) * (Float4(1.0f) - src) * (Float4(1.0f) - dst)))));
+}
+
+Float4 PixelRoutine::blendOpSoftlight(Float4 &src, Float4 &dst)
+{
+	Int4 largeSrc = CmpGT(src, Float4(0.5f));
+	Int4 largeDst = CmpGT(dst, Float4(0.25f));
+
+	return As<Float4>(
+	    (~largeSrc &
+	     As<Int4>(dst - ((Float4(1.0f) - (Float4(2.0f) * src)) * dst * (Float4(1.0f) - dst)))) |
+	    (largeSrc & ((~largeDst &
+	                  As<Int4>(dst + (((Float4(2.0f) * src) - Float4(1.0f)) * dst * ((((Float4(16.0f) * dst) - Float4(12.0f)) * dst) + Float4(3.0f))))) |
+	                 (largeDst &
+	                  As<Int4>(dst + (((Float4(2.0f) * src) - Float4(1.0f)) * (Sqrt(dst) - dst)))))));
+}
+
+Float4 PixelRoutine::maxRGB(Vector4f &c)
+{
+	return Max(Max(c.x, c.y), c.z);
+}
+
+Float4 PixelRoutine::minRGB(Vector4f &c)
+{
+	return Min(Min(c.x, c.y), c.z);
+}
+
+void PixelRoutine::setLumSat(Vector4f &cbase, Vector4f &csat, Vector4f &clum, Float4 &x, Float4 &y, Float4 &z)
+{
+	Float4 minbase = minRGB(cbase);
+	Float4 sbase = maxRGB(cbase) - minbase;
+	Float4 ssat = maxRGB(csat) - minRGB(csat);
+	Int4 isNonZero = CmpGT(sbase, Float4(0.0f));
+	Vector4f color;
+	color.x = As<Float4>(isNonZero & As<Int4>((cbase.x - minbase) * ssat / sbase));
+	color.y = As<Float4>(isNonZero & As<Int4>((cbase.y - minbase) * ssat / sbase));
+	color.z = As<Float4>(isNonZero & As<Int4>((cbase.z - minbase) * ssat / sbase));
+	setLum(color, clum, x, y, z);
+}
+
+Float4 PixelRoutine::lumRGB(Vector4f &c)
+{
+	return c.x * Float4(0.3f) + c.y * Float4(0.59f) + c.z * Float4(0.11f);
+}
+
+Float4 PixelRoutine::computeLum(Float4 &color, Float4 &lum, Float4 &mincol, Float4 &maxcol, Int4 &negative, Int4 &aboveOne)
+{
+	return As<Float4>(
+	    (negative &
+	     As<Int4>(lum + ((color - lum) * lum) / (lum - mincol))) |
+	    (~negative &
+	     ((aboveOne &
+	       As<Int4>(lum + ((color - lum) * (Float4(1.0f) - lum)) / (Float4(maxcol) - lum))) |
+	      (~aboveOne &
+	       As<Int4>(color)))));
+}
+
+void PixelRoutine::setLum(Vector4f &cbase, Vector4f &clum, Float4 &x, Float4 &y, Float4 &z)
+{
+	Float4 lbase = lumRGB(cbase);
+	Float4 llum = lumRGB(clum);
+	Float4 ldiff = llum - lbase;
+
+	Vector4f color;
+	color.x = cbase.x + ldiff;
+	color.y = cbase.y + ldiff;
+	color.z = cbase.z + ldiff;
+
+	Float4 lum = lumRGB(color);
+	Float4 mincol = minRGB(color);
+	Float4 maxcol = maxRGB(color);
+
+	Int4 negative = CmpLT(mincol, Float4(0.0f));
+	Int4 aboveOne = CmpGT(maxcol, Float4(1.0f));
+
+	x = computeLum(color.x, lum, mincol, maxcol, negative, aboveOne);
+	y = computeLum(color.y, lum, mincol, maxcol, negative, aboveOne);
+	z = computeLum(color.z, lum, mincol, maxcol, negative, aboveOne);
+}
+
+void PixelRoutine::premultiply(Vector4f &c)
+{
+	Int4 nonZeroAlpha = CmpNEQ(c.w, Float4(0.0f));
+	c.x = As<Float4>(nonZeroAlpha & As<Int4>(c.x / c.w));
+	c.y = As<Float4>(nonZeroAlpha & As<Int4>(c.y / c.w));
+	c.z = As<Float4>(nonZeroAlpha & As<Int4>(c.z / c.w));
+}
+
+Vector4f PixelRoutine::computeAdvancedBlendMode(int index, const Vector4f &src, const Vector4f &dst, const Vector4f &srcFactor, const Vector4f &dstFactor)
+{
+	Vector4f srcColor = src;
+	srcColor.x *= srcFactor.x;
+	srcColor.y *= srcFactor.y;
+	srcColor.z *= srcFactor.z;
+	srcColor.w *= srcFactor.w;
+
+	Vector4f dstColor = dst;
+	dstColor.x *= dstFactor.x;
+	dstColor.y *= dstFactor.y;
+	dstColor.z *= dstFactor.z;
+	dstColor.w *= dstFactor.w;
+
+	premultiply(srcColor);
+	premultiply(dstColor);
+
+	Vector4f blendedColor;
+
+	switch(state.blendState[index].blendOperation)
+	{
+	case VK_BLEND_OP_MULTIPLY_EXT:
+		blendedColor.x = (srcColor.x * dstColor.x);
+		blendedColor.y = (srcColor.y * dstColor.y);
+		blendedColor.z = (srcColor.z * dstColor.z);
+		break;
+	case VK_BLEND_OP_SCREEN_EXT:
+		blendedColor.x = srcColor.x + dstColor.x - (srcColor.x * dstColor.x);
+		blendedColor.y = srcColor.y + dstColor.y - (srcColor.y * dstColor.y);
+		blendedColor.z = srcColor.z + dstColor.z - (srcColor.z * dstColor.z);
+		break;
+	case VK_BLEND_OP_OVERLAY_EXT:
+		blendedColor.x = blendOpOverlay(srcColor.x, dstColor.x);
+		blendedColor.y = blendOpOverlay(srcColor.y, dstColor.y);
+		blendedColor.z = blendOpOverlay(srcColor.z, dstColor.z);
+		break;
+	case VK_BLEND_OP_DARKEN_EXT:
+		blendedColor.x = Min(srcColor.x, dstColor.x);
+		blendedColor.y = Min(srcColor.y, dstColor.y);
+		blendedColor.z = Min(srcColor.z, dstColor.z);
+		break;
+	case VK_BLEND_OP_LIGHTEN_EXT:
+		blendedColor.x = Max(srcColor.x, dstColor.x);
+		blendedColor.y = Max(srcColor.y, dstColor.y);
+		blendedColor.z = Max(srcColor.z, dstColor.z);
+		break;
+	case VK_BLEND_OP_COLORDODGE_EXT:
+		blendedColor.x = blendOpColorDodge(srcColor.x, dstColor.x);
+		blendedColor.y = blendOpColorDodge(srcColor.y, dstColor.y);
+		blendedColor.z = blendOpColorDodge(srcColor.z, dstColor.z);
+		break;
+	case VK_BLEND_OP_COLORBURN_EXT:
+		blendedColor.x = blendOpColorBurn(srcColor.x, dstColor.x);
+		blendedColor.y = blendOpColorBurn(srcColor.y, dstColor.y);
+		blendedColor.z = blendOpColorBurn(srcColor.z, dstColor.z);
+		break;
+	case VK_BLEND_OP_HARDLIGHT_EXT:
+		blendedColor.x = blendOpHardlight(srcColor.x, dstColor.x);
+		blendedColor.y = blendOpHardlight(srcColor.y, dstColor.y);
+		blendedColor.z = blendOpHardlight(srcColor.z, dstColor.z);
+		break;
+	case VK_BLEND_OP_SOFTLIGHT_EXT:
+		blendedColor.x = blendOpSoftlight(srcColor.x, dstColor.x);
+		blendedColor.y = blendOpSoftlight(srcColor.y, dstColor.y);
+		blendedColor.z = blendOpSoftlight(srcColor.z, dstColor.z);
+		break;
+	case VK_BLEND_OP_DIFFERENCE_EXT:
+		blendedColor.x = Abs(srcColor.x - dstColor.x);
+		blendedColor.y = Abs(srcColor.y - dstColor.y);
+		blendedColor.z = Abs(srcColor.z - dstColor.z);
+		break;
+	case VK_BLEND_OP_EXCLUSION_EXT:
+		blendedColor.x = srcColor.x + dstColor.x - (srcColor.x * dstColor.x * Float4(2.0f));
+		blendedColor.y = srcColor.y + dstColor.y - (srcColor.y * dstColor.y * Float4(2.0f));
+		blendedColor.z = srcColor.z + dstColor.z - (srcColor.z * dstColor.z * Float4(2.0f));
+		break;
+	case VK_BLEND_OP_HSL_HUE_EXT:
+		setLumSat(srcColor, dstColor, dstColor, blendedColor.x, blendedColor.y, blendedColor.z);
+		break;
+	case VK_BLEND_OP_HSL_SATURATION_EXT:
+		setLumSat(dstColor, srcColor, dstColor, blendedColor.x, blendedColor.y, blendedColor.z);
+		break;
+	case VK_BLEND_OP_HSL_COLOR_EXT:
+		setLum(srcColor, dstColor, blendedColor.x, blendedColor.y, blendedColor.z);
+		break;
+	case VK_BLEND_OP_HSL_LUMINOSITY_EXT:
+		setLum(dstColor, srcColor, blendedColor.x, blendedColor.y, blendedColor.z);
+		break;
+	default:
+		UNSUPPORTED("Unsupported advanced VkBlendOp: %d", int(state.blendState[index].blendOperation));
+		break;
+	}
+
+	Float4 p = srcColor.w * dstColor.w;
+	blendedColor.x *= p;
+	blendedColor.y *= p;
+	blendedColor.z *= p;
+
+	p = srcColor.w * (Float4(1.0f) - dstColor.w);
+	blendedColor.x += srcColor.x * p;
+	blendedColor.y += srcColor.y * p;
+	blendedColor.z += srcColor.z * p;
+
+	p = dstColor.w * (Float4(1.0f) - srcColor.w);
+	blendedColor.x += dstColor.x * p;
+	blendedColor.y += dstColor.y * p;
+	blendedColor.z += dstColor.z * p;
+
+	return blendedColor;
+}
+
 bool PixelRoutine::blendFactorCanExceedFormatRange(VkBlendFactor blendFactor, vk::Format format)
 {
 	switch(blendFactor)
@@ -2162,6 +2399,8 @@
 
 	blendFactorRGB(sourceFactor, sourceColor, destColor, state.blendState[index].sourceBlendFactor, format);
 	blendFactorRGB(destFactor, sourceColor, destColor, state.blendState[index].destBlendFactor, format);
+	blendFactorAlpha(sourceFactor.w, sourceColor.w, destColor.w, state.blendState[index].sourceBlendFactorAlpha, format);
+	blendFactorAlpha(destFactor.w, sourceColor.w, destColor.w, state.blendState[index].destBlendFactorAlpha, format);
 
 	Vector4f blendedColor;
 
@@ -2207,13 +2446,27 @@
 		blendedColor.y = Float4(0.0f);
 		blendedColor.z = Float4(0.0f);
 		break;
+	case VK_BLEND_OP_MULTIPLY_EXT:
+	case VK_BLEND_OP_SCREEN_EXT:
+	case VK_BLEND_OP_OVERLAY_EXT:
+	case VK_BLEND_OP_DARKEN_EXT:
+	case VK_BLEND_OP_LIGHTEN_EXT:
+	case VK_BLEND_OP_COLORDODGE_EXT:
+	case VK_BLEND_OP_COLORBURN_EXT:
+	case VK_BLEND_OP_HARDLIGHT_EXT:
+	case VK_BLEND_OP_SOFTLIGHT_EXT:
+	case VK_BLEND_OP_DIFFERENCE_EXT:
+	case VK_BLEND_OP_EXCLUSION_EXT:
+	case VK_BLEND_OP_HSL_HUE_EXT:
+	case VK_BLEND_OP_HSL_SATURATION_EXT:
+	case VK_BLEND_OP_HSL_COLOR_EXT:
+	case VK_BLEND_OP_HSL_LUMINOSITY_EXT:
+		blendedColor = computeAdvancedBlendMode(index, sourceColor, destColor, sourceFactor, destFactor);
+		break;
 	default:
 		UNSUPPORTED("VkBlendOp: %d", int(state.blendState[index].blendOperation));
 	}
 
-	blendFactorAlpha(sourceFactor.w, sourceColor.w, destColor.w, state.blendState[index].sourceBlendFactorAlpha, format);
-	blendFactorAlpha(destFactor.w, sourceColor.w, destColor.w, state.blendState[index].destBlendFactorAlpha, format);
-
 	switch(state.blendState[index].blendOperationAlpha)
 	{
 	case VK_BLEND_OP_ADD:
@@ -2240,6 +2493,11 @@
 	case VK_BLEND_OP_ZERO_EXT:
 		blendedColor.w = Float4(0.0f);
 		break;
+	case VK_BLEND_OP_MULTIPLY_EXT:
+		// All of the currently supported advanced blend modes compute the alpha the same way
+		// Use VK_BLEND_OP_MULTIPLY_EXT as a placeholder
+		blendedColor.w = sourceColor.w + destColor.w - (sourceColor.w * destColor.w);
+		break;
 	default:
 		UNSUPPORTED("VkBlendOp: %d", int(state.blendState[index].blendOperationAlpha));
 	}
diff --git a/src/Pipeline/PixelRoutine.hpp b/src/Pipeline/PixelRoutine.hpp
index 3f410e7..ba5f28d 100644
--- a/src/Pipeline/PixelRoutine.hpp
+++ b/src/Pipeline/PixelRoutine.hpp
@@ -77,6 +77,19 @@
 	void blendFactorRGB(Vector4f &blendFactorRGB, const Vector4f &sourceColor, const Vector4f &destColor, VkBlendFactor colorBlendFactor, vk::Format format);
 	void blendFactorAlpha(Float4 &blendFactorAlpha, const Float4 &sourceAlpha, const Float4 &destAlpha, VkBlendFactor alphaBlendFactor, vk::Format format);
 	bool blendFactorCanExceedFormatRange(VkBlendFactor blendFactor, vk::Format format);
+	Vector4f computeAdvancedBlendMode(int index, const Vector4f &src, const Vector4f &dst, const Vector4f &srcFactor, const Vector4f &dstFactor);
+	Float4 blendOpOverlay(Float4 &src, Float4 &dst);
+	Float4 blendOpColorDodge(Float4 &src, Float4 &dst);
+	Float4 blendOpColorBurn(Float4 &src, Float4 &dst);
+	Float4 blendOpHardlight(Float4 &src, Float4 &dst);
+	Float4 blendOpSoftlight(Float4 &src, Float4 &dst);
+	void setLumSat(Vector4f &cbase, Vector4f &csat, Vector4f &clum, Float4 &x, Float4 &y, Float4 &z);
+	void setLum(Vector4f &cbase, Vector4f &clum, Float4 &x, Float4 &y, Float4 &z);
+	Float4 computeLum(Float4 &color, Float4 &lum, Float4 &mincol, Float4 &maxcol, Int4 &negative, Int4 &aboveOne);
+	Float4 maxRGB(Vector4f &c);
+	Float4 minRGB(Vector4f &c);
+	Float4 lumRGB(Vector4f &c);
+	void premultiply(Vector4f &c);
 	void writeStencil(Pointer<Byte> &sBuffer, const Int &x, const Int sMask[4], const Int zMask[4], const Int cMask[4], const SampleSet &samples);
 	void writeDepth(Pointer<Byte> &zBuffer, const Int &x, const Int zMask[4], const SampleSet &samples);
 	void occlusionSampleCount(const Int zMask[4], const Int sMask[4], const SampleSet &samples);
diff --git a/src/Vulkan/VkPhysicalDevice.cpp b/src/Vulkan/VkPhysicalDevice.cpp
index be9e649..fe8f840 100644
--- a/src/Vulkan/VkPhysicalDevice.cpp
+++ b/src/Vulkan/VkPhysicalDevice.cpp
@@ -332,12 +332,17 @@
 	features->depthClipEnable = VK_TRUE;
 }
 
-static void getPhysicalDevicCustomBorderColorFeaturesExt(VkPhysicalDeviceCustomBorderColorFeaturesEXT *features)
+static void getPhysicalDeviceCustomBorderColorFeaturesExt(VkPhysicalDeviceCustomBorderColorFeaturesEXT *features)
 {
 	features->customBorderColors = VK_TRUE;
 	features->customBorderColorWithoutFormat = VK_TRUE;
 }
 
+static void getPhysicalDeviceBlendOperationAdvancedFeaturesExt(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *features)
+{
+	features->advancedBlendCoherentOperations = VK_FALSE;
+}
+
 static void getPhysicalDevice4444FormatsFeaturesExt(VkPhysicalDevice4444FormatsFeaturesEXT *features)
 {
 	features->formatA4R4G4B4 = VK_TRUE;
@@ -437,7 +442,10 @@
 			getPhysicalDeviceDepthClipEnableFeaturesExt(reinterpret_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT *>(curExtension));
 			break;
 		case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
-			getPhysicalDevicCustomBorderColorFeaturesExt(reinterpret_cast<VkPhysicalDeviceCustomBorderColorFeaturesEXT *>(curExtension));
+			getPhysicalDeviceCustomBorderColorFeaturesExt(reinterpret_cast<VkPhysicalDeviceCustomBorderColorFeaturesEXT *>(curExtension));
+			break;
+		case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
+			getPhysicalDeviceBlendOperationAdvancedFeaturesExt(reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *>(curExtension));
 			break;
 		case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
 			getPhysicalDevice4444FormatsFeaturesExt(reinterpret_cast<struct VkPhysicalDevice4444FormatsFeaturesEXT *>(curExtension));
@@ -1034,6 +1042,18 @@
 	properties->maxCustomBorderColorSamplers = MAX_SAMPLER_ALLOCATION_COUNT;
 }
 
+void PhysicalDevice::getProperties(VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *properties) const
+{
+	// Note: advancedBlendMaxColorAttachments could already support sw::MAX_COLOR_BUFFERS as is,
+	//       but using a value of 1 is enough for ANGLE to implement GL_KHR_blend_equation_advanced
+	properties->advancedBlendMaxColorAttachments = 1;
+	properties->advancedBlendIndependentBlend = VK_FALSE;
+	properties->advancedBlendNonPremultipliedSrcColor = VK_FALSE;
+	properties->advancedBlendNonPremultipliedDstColor = VK_FALSE;
+	properties->advancedBlendCorrelatedOverlap = VK_FALSE;
+	properties->advancedBlendAllOperations = VK_FALSE;
+}
+
 template<typename T>
 static void getSamplerFilterMinmaxProperties(T *properties)
 {
@@ -1121,6 +1141,7 @@
 InstantiateHasExtendedFeatures(VkPhysicalDeviceVulkan11Features);
 InstantiateHasExtendedFeatures(VkPhysicalDeviceVulkan12Features);
 InstantiateHasExtendedFeatures(VkPhysicalDeviceDepthClipEnableFeaturesEXT);
+InstantiateHasExtendedFeatures(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT);
 #undef InstantiateHasExtendedFeatures
 
 void PhysicalDevice::GetFormatProperties(Format format, VkFormatProperties *pFormatProperties)
diff --git a/src/Vulkan/VkPhysicalDevice.hpp b/src/Vulkan/VkPhysicalDevice.hpp
index 068011a..080d1af 100644
--- a/src/Vulkan/VkPhysicalDevice.hpp
+++ b/src/Vulkan/VkPhysicalDevice.hpp
@@ -68,6 +68,7 @@
 	void getProperties(VkPhysicalDeviceDescriptorIndexingProperties *properties) const;
 	void getProperties(VkPhysicalDeviceDepthStencilResolveProperties *properties) const;
 	void getProperties(VkPhysicalDeviceCustomBorderColorPropertiesEXT *properties) const;
+	void getProperties(VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *properties) const;
 	void getProperties(VkPhysicalDeviceVulkan11Properties *properties) const;
 
 	static void GetFormatProperties(Format format, VkFormatProperties *pFormatProperties);
diff --git a/src/Vulkan/libVulkan.cpp b/src/Vulkan/libVulkan.cpp
index 2017350..5faaf75 100644
--- a/src/Vulkan/libVulkan.cpp
+++ b/src/Vulkan/libVulkan.cpp
@@ -371,6 +371,8 @@
 	{ { VK_EXT_IMAGE_ROBUSTNESS_EXTENSION_NAME, VK_EXT_IMAGE_ROBUSTNESS_SPEC_VERSION } },
 	// Useful for D3D emulation
 	{ { VK_EXT_4444_FORMATS_EXTENSION_NAME, VK_EXT_4444_FORMATS_SPEC_VERSION } },
+	// Used by ANGLE to support GL_KHR_blend_equation_advanced
+	{ { VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME, VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION } },
 #ifndef __ANDROID__
 	// We fully support the KHR_swapchain v70 additions, so just track the spec version.
 	{ { VK_KHR_SWAPCHAIN_EXTENSION_NAME, VK_KHR_SWAPCHAIN_SPEC_VERSION } },
@@ -917,6 +919,16 @@
 				}
 			}
 			break;
+		case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
+			{
+				const auto *blendOpFeatures = reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *>(extensionCreateInfo);
+				bool hasFeatures = vk::Cast(physicalDevice)->hasExtendedFeatures(blendOpFeatures);
+				if(!hasFeatures)
+				{
+					return VK_ERROR_FEATURE_NOT_PRESENT;
+				}
+			}
+			break;
 		// These structs are supported, but no behavior changes based on their feature bools
 		case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
 		case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
@@ -3253,6 +3265,12 @@
 				vk::Cast(physicalDevice)->getProperties(properties);
 			}
 			break;
+		case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
+			{
+				auto properties = reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *>(extensionProperties);
+				vk::Cast(physicalDevice)->getProperties(properties);
+			}
+			break;
 		case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR:
 			break;
 		default: