diff --git a/src/Device/QuadRasterizer.cpp b/src/Device/QuadRasterizer.cpp
index e2848c3..b69945e 100644
--- a/src/Device/QuadRasterizer.cpp
+++ b/src/Device/QuadRasterizer.cpp
@@ -122,20 +122,20 @@
 			x1 = Max(x1, Max(x1a, x1b));
 		}
 
-		Float4 yyyy = Float4(Float(y)) + *Pointer<Float4>(primitive + OFFSET(Primitive, yQuad), 16);
+		SIMD::Float yyyy = SIMD::Float(Float(y)) + SIMD::Float(*Pointer<Float4>(primitive + OFFSET(Primitive, yQuad), 16));
 
 		if(interpolateZ())
 		{
 			for(unsigned int q = 0; q < state.multiSampleCount; q++)
 			{
-				Float4 y = yyyy;
+				SIMD::Float y = yyyy;
 
 				if(state.enableMultiSampling)
 				{
-					y += Float4(*Pointer<Float>(constants + OFFSET(Constants, SampleLocationsY) + q * sizeof(float)));
+					y += SIMD::Float(*Pointer<Float>(constants + OFFSET(Constants, SampleLocationsY) + q * sizeof(float)));
 				}
 
-				Dz[q] = Float4(*Pointer<Float>(primitive + OFFSET(Primitive, z.C))) + y * Float4(*Pointer<Float>(primitive + OFFSET(Primitive, z.B)));
+				Dz[q] = SIMD::Float(*Pointer<Float>(primitive + OFFSET(Primitive, z.C))) + y * SIMD::Float(*Pointer<Float>(primitive + OFFSET(Primitive, z.B)));
 			}
 		}
 
@@ -143,7 +143,7 @@
 		{
 			if(interpolateW())
 			{
-				Dw = Float4(*Pointer<Float>(primitive + OFFSET(Primitive, w.C))) + yyyy * Float4(*Pointer<Float>(primitive + OFFSET(Primitive, w.B)));
+				Dw = SIMD::Float(*Pointer<Float>(primitive + OFFSET(Primitive, w.C))) + yyyy * SIMD::Float(*Pointer<Float>(primitive + OFFSET(Primitive, w.B)));
 			}
 
 			if(spirvShader)
@@ -153,11 +153,11 @@
 				{
 					if(spirvShader->inputs[interfaceInterpolant].Type != SpirvShader::ATTRIBTYPE_UNUSED)
 					{
-						Dv[interfaceInterpolant] = Float4(*Pointer<Float>(primitive + OFFSET(Primitive, V[packedInterpolant].C)));
+						Dv[interfaceInterpolant] = *Pointer<Float>(primitive + OFFSET(Primitive, V[packedInterpolant].C));
 						if(!spirvShader->inputs[interfaceInterpolant].Flat)
 						{
 							Dv[interfaceInterpolant] +=
-							    yyyy * Float4(*Pointer<Float>(primitive + OFFSET(Primitive, V[packedInterpolant].B)));
+							    yyyy * SIMD::Float(*Pointer<Float>(primitive + OFFSET(Primitive, V[packedInterpolant].B)));
 						}
 						packedInterpolant++;
 					}
@@ -165,14 +165,14 @@
 
 				for(unsigned int i = 0; i < state.numClipDistances; i++)
 				{
-					DclipDistance[i] = Float4(*Pointer<Float>(primitive + OFFSET(Primitive, clipDistance[i].C))) +
-					                   yyyy * Float4(*Pointer<Float>(primitive + OFFSET(Primitive, clipDistance[i].B)));
+					DclipDistance[i] = SIMD::Float(*Pointer<Float>(primitive + OFFSET(Primitive, clipDistance[i].C))) +
+					                   yyyy * SIMD::Float(*Pointer<Float>(primitive + OFFSET(Primitive, clipDistance[i].B)));
 				}
 
 				for(unsigned int i = 0; i < state.numCullDistances; i++)
 				{
-					DcullDistance[i] = Float4(*Pointer<Float>(primitive + OFFSET(Primitive, cullDistance[i].C))) +
-					                   yyyy * Float4(*Pointer<Float>(primitive + OFFSET(Primitive, cullDistance[i].B)));
+					DcullDistance[i] = SIMD::Float(*Pointer<Float>(primitive + OFFSET(Primitive, cullDistance[i].C))) +
+					                   yyyy * SIMD::Float(*Pointer<Float>(primitive + OFFSET(Primitive, cullDistance[i].B)));
 				}
 			}
 
@@ -230,14 +230,14 @@
 	Until(y >= yMax);
 }
 
-Float4 QuadRasterizer::interpolate(Float4 &x, Float4 &D, Float4 &rhw, Pointer<Byte> planeEquation, bool flat, bool perspective)
+SIMD::Float QuadRasterizer::interpolate(SIMD::Float &x, SIMD::Float &D, SIMD::Float &rhw, Pointer<Byte> planeEquation, bool flat, bool perspective)
 {
 	if(flat)
 	{
 		return D;
 	}
 
-	Float4 interpolant = mulAdd(x, Float4(*Pointer<Float>(planeEquation + OFFSET(PlaneEquation, A))), D);
+	SIMD::Float interpolant = mulAdd(x, SIMD::Float(*Pointer<Float>(planeEquation + OFFSET(PlaneEquation, A))), D);
 
 	if(perspective)
 	{
diff --git a/src/Device/QuadRasterizer.hpp b/src/Device/QuadRasterizer.hpp
index 2f19d1d..9ef2ee1 100644
--- a/src/Device/QuadRasterizer.hpp
+++ b/src/Device/QuadRasterizer.hpp
@@ -33,12 +33,12 @@
 protected:
 	Pointer<Byte> constants;
 
-	Float4 Dz[4];
-	Float4 Dw;
-	Float4 Dv[MAX_INTERFACE_COMPONENTS];
-	Float4 Df;
-	Float4 DclipDistance[MAX_CLIP_DISTANCES];
-	Float4 DcullDistance[MAX_CULL_DISTANCES];
+	SIMD::Float Dz[4];
+	SIMD::Float Dw;
+	SIMD::Float Dv[MAX_INTERFACE_COMPONENTS];
+	SIMD::Float Df;
+	SIMD::Float DclipDistance[MAX_CLIP_DISTANCES];
+	SIMD::Float DcullDistance[MAX_CULL_DISTANCES];
 
 	UInt occlusion;
 
@@ -46,7 +46,7 @@
 
 	bool interpolateZ() const;
 	bool interpolateW() const;
-	Float4 interpolate(Float4 &x, Float4 &D, Float4 &rhw, Pointer<Byte> planeEquation, bool flat, bool perspective);
+	SIMD::Float interpolate(SIMD::Float &x, SIMD::Float &D, SIMD::Float &rhw, Pointer<Byte> planeEquation, bool flat, bool perspective);
 
 	const PixelProcessor::State &state;
 	const SpirvShader *const spirvShader;
diff --git a/src/Pipeline/ComputeProgram.cpp b/src/Pipeline/ComputeProgram.cpp
index cbdf4ce..d142bb8 100644
--- a/src/Pipeline/ComputeProgram.cpp
+++ b/src/Pipeline/ComputeProgram.cpp
@@ -106,7 +106,7 @@
 		localInvocationID[0] = idx;
 	}
 
-	Int4 wgID = Insert(Insert(Insert(SIMD::Int(0), workgroupID[0], 0), workgroupID[1], 1), workgroupID[2], 2);
+	Int4 wgID = Insert(Insert(Insert(Int4(0), workgroupID[0], 0), workgroupID[1], 1), workgroupID[2], 2);
 	auto localBase = workgroupSize * wgID;
 	SIMD::Int globalInvocationID[3];
 	globalInvocationID[0] = SIMD::Int(Extract(localBase, 0)) + localInvocationID[0];
diff --git a/src/Pipeline/PixelProgram.cpp b/src/Pipeline/PixelProgram.cpp
index cfdf2d2..3405458 100644
--- a/src/Pipeline/PixelProgram.cpp
+++ b/src/Pipeline/PixelProgram.cpp
@@ -31,9 +31,10 @@
 {
 }
 
-// Union all cMask and return it as 4 booleans
-Int4 PixelProgram::maskAny(Int cMask[4], const SampleSet &samples)
+// Union all cMask and return it as Booleans
+SIMD::Int PixelProgram::maskAny(Int cMask[4], const SampleSet &samples)
 {
+	ASSERT(SIMD::Width == 4);
 	// See if at least 1 sample is used
 	Int maskUnion = 0;
 	for(unsigned int q : samples)
@@ -41,17 +42,18 @@
 		maskUnion |= cMask[q];
 	}
 
-	// Convert to 4 booleans
-	Int4 laneBits = Int4(1, 2, 4, 8);
-	Int4 laneShiftsToMSB = Int4(31, 30, 29, 28);
-	Int4 mask(maskUnion);
-	mask = ((mask & laneBits) << laneShiftsToMSB) >> Int4(31);
+	// Convert to Booleans
+	SIMD::Int laneBits = SIMD::Int(1, 2, 4, 8);
+	SIMD::Int laneShiftsToMSB = SIMD::Int(31, 30, 29, 28);
+	SIMD::Int mask(maskUnion);
+	mask = ((mask & laneBits) << laneShiftsToMSB) >> 31;
 	return mask;
 }
 
-// Union all cMask/sMask/zMask and return it as 4 booleans
-Int4 PixelProgram::maskAny(Int cMask[4], Int sMask[4], Int zMask[4], const SampleSet &samples)
+// Union all cMask/sMask/zMask and return it as Booleans
+SIMD::Int PixelProgram::maskAny(Int cMask[4], Int sMask[4], Int zMask[4], const SampleSet &samples)
 {
+	ASSERT(SIMD::Width == 4);
 	// See if at least 1 sample is used
 	Int maskUnion = 0;
 	for(unsigned int q : samples)
@@ -59,15 +61,15 @@
 		maskUnion |= (cMask[q] & sMask[q] & zMask[q]);
 	}
 
-	// Convert to 4 booleans
-	Int4 laneBits = Int4(1, 2, 4, 8);
-	Int4 laneShiftsToMSB = Int4(31, 30, 29, 28);
-	Int4 mask(maskUnion);
-	mask = ((mask & laneBits) << laneShiftsToMSB) >> Int4(31);
+	// Convert to Booleans
+	SIMD::Int laneBits = SIMD::Int(1, 2, 4, 8);
+	SIMD::Int laneShiftsToMSB = SIMD::Int(31, 30, 29, 28);
+	SIMD::Int mask(maskUnion);
+	mask = ((mask & laneBits) << laneShiftsToMSB) >> 31;
 	return mask;
 }
 
-void PixelProgram::setBuiltins(Int &x, Int &y, Float4 (&z)[4], Float4 &w, Int cMask[4], const SampleSet &samples)
+void PixelProgram::setBuiltins(Int &x, Int &y, SIMD::Float (&z)[4], SIMD::Float &w, Int cMask[4], const SampleSet &samples)
 {
 	routine.setImmutableInputBuiltins(spirvShader);
 
@@ -148,28 +150,28 @@
 	if(it != spirvShader->inputBuiltins.end())
 	{
 		ASSERT(it->second.SizeInComponents == 1);
-		auto frontFacing = Int4(*Pointer<Int>(primitive + OFFSET(Primitive, clockwiseMask)));
-		routine.getVariable(it->second.Id)[it->second.FirstComponent] = As<Float4>(frontFacing);
+		auto frontFacing = SIMD::Int(*Pointer<Int>(primitive + OFFSET(Primitive, clockwiseMask)));
+		routine.getVariable(it->second.Id)[it->second.FirstComponent] = As<SIMD::Float>(frontFacing);
 	}
 
 	it = spirvShader->inputBuiltins.find(spv::BuiltInSampleMask);
 	if(it != spirvShader->inputBuiltins.end())
 	{
-		static_assert(SIMD::Width == 4, "Expects SIMD width to be 4");
-		Int4 laneBits = Int4(1, 2, 4, 8);
+		ASSERT(SIMD::Width == 4);
+		SIMD::Int laneBits = SIMD::Int(1, 2, 4, 8);
 
-		Int4 inputSampleMask = 0;
+		SIMD::Int inputSampleMask = 0;
 		for(unsigned int q : samples)
 		{
-			inputSampleMask |= Int4(1 << q) & CmpNEQ(Int4(cMask[q]) & laneBits, Int4(0));
+			inputSampleMask |= SIMD::Int(1 << q) & CmpNEQ(SIMD::Int(cMask[q]) & laneBits, 0);
 		}
 
-		routine.getVariable(it->second.Id)[it->second.FirstComponent] = As<Float4>(inputSampleMask);
+		routine.getVariable(it->second.Id)[it->second.FirstComponent] = As<SIMD::Float>(inputSampleMask);
 		// Sample mask input is an array, as the spec contemplates MSAA levels higher than 32.
 		// Fill any non-zero indices with 0.
 		for(auto i = 1u; i < it->second.SizeInComponents; i++)
 		{
-			routine.getVariable(it->second.Id)[it->second.FirstComponent + i] = Float4(0);
+			routine.getVariable(it->second.Id)[it->second.FirstComponent + i] = 0;
 		}
 	}
 
@@ -195,8 +197,8 @@
 
 	// Note: all lanes initially active to facilitate derivatives etc. Actual coverage is
 	// handled separately, through the cMask.
-	auto activeLaneMask = SIMD::Int(0xFFFFFFFF);
-	auto storesAndAtomicsMask = maskAny(cMask, sMask, zMask, samples);
+	SIMD::Int activeLaneMask = 0xFFFFFFFF;
+	SIMD::Int storesAndAtomicsMask = maskAny(cMask, sMask, zMask, samples);
 	routine.discardMask = 0;
 
 	spirvShader->emit(&routine, activeLaneMask, storesAndAtomicsMask, descriptorSets, state.multiSampleCount);
@@ -395,10 +397,10 @@
 		case VK_FORMAT_A8B8G8R8_SRGB_PACK32:
 		case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
 		case VK_FORMAT_A2R10G10B10_UNORM_PACK32:
-			color[index].x = Min(Max(color[index].x, Float4(0.0f)), Float4(1.0f));
-			color[index].y = Min(Max(color[index].y, Float4(0.0f)), Float4(1.0f));
-			color[index].z = Min(Max(color[index].z, Float4(0.0f)), Float4(1.0f));
-			color[index].w = Min(Max(color[index].w, Float4(0.0f)), Float4(1.0f));
+			color[index].x = Min(Max(color[index].x, 0.0f), 1.0f);
+			color[index].y = Min(Max(color[index].y, 0.0f), 1.0f);
+			color[index].z = Min(Max(color[index].z, 0.0f), 1.0f);
+			color[index].w = Min(Max(color[index].w, 0.0f), 1.0f);
 			break;
 		case VK_FORMAT_R32_SFLOAT:
 		case VK_FORMAT_R32G32_SFLOAT:
diff --git a/src/Pipeline/PixelProgram.hpp b/src/Pipeline/PixelProgram.hpp
index 465d185..f367fee 100644
--- a/src/Pipeline/PixelProgram.hpp
+++ b/src/Pipeline/PixelProgram.hpp
@@ -31,7 +31,7 @@
 	virtual ~PixelProgram() {}
 
 protected:
-	virtual void setBuiltins(Int &x, Int &y, Float4 (&z)[4], Float4 &w, Int cMask[4], const SampleSet &samples);
+	virtual void setBuiltins(Int &x, Int &y, SIMD::Float (&z)[4], SIMD::Float &w, Int cMask[4], const SampleSet &samples);
 	virtual void executeShader(Int cMask[4], Int sMask[4], Int zMask[4], const SampleSet &samples);
 	virtual Bool alphaTest(Int cMask[4], const SampleSet &samples);
 	virtual void blendColor(Pointer<Byte> cBuffer[4], Int &x, Int sMask[4], Int zMask[4], Int cMask[4], const SampleSet &samples);
@@ -43,8 +43,8 @@
 	// Raster operations
 	void clampColor(Vector4f color[MAX_COLOR_BUFFERS]);
 
-	static Int4 maskAny(Int cMask[4], const SampleSet &samples);
-	static Int4 maskAny(Int cMask[4], Int sMask[4], Int zMask[4], const SampleSet &samples);
+	static SIMD::Int maskAny(Int cMask[4], const SampleSet &samples);
+	static SIMD::Int maskAny(Int cMask[4], Int sMask[4], Int zMask[4], const SampleSet &samples);
 };
 
 }  // namespace sw
diff --git a/src/Pipeline/PixelRoutine.cpp b/src/Pipeline/PixelRoutine.cpp
index 74fac88..05cc345 100644
--- a/src/Pipeline/PixelRoutine.cpp
+++ b/src/Pipeline/PixelRoutine.cpp
@@ -73,7 +73,7 @@
 
 	Int zMask[4];  // Depth mask
 	Int sMask[4];  // Stencil mask
-	Float4 unclampedZ[4];
+	SIMD::Float unclampedZ[4];
 
 	for(int invocation = 0; invocation < invocationCount; invocation++)
 	{
@@ -92,26 +92,26 @@
 
 		stencilTest(sBuffer, x, sMask, samples);
 
-		Float4 rhwCentroid;
+		SIMD::Float rhwCentroid;
 
-		Float4 xxxx = Float4(Float(x)) + *Pointer<Float4>(primitive + OFFSET(Primitive, xQuad), 16);
+		SIMD::Float xxxx = Float4(Float(x)) + *Pointer<Float4>(primitive + OFFSET(Primitive, xQuad), 16);
 
 		if(interpolateZ())
 		{
 			for(unsigned int q : samples)
 			{
-				Float4 x = xxxx;
+				SIMD::Float x = xxxx;
 
 				if(state.enableMultiSampling)
 				{
-					x -= Float4(*Pointer<Float>(constants + OFFSET(Constants, SampleLocationsX) + q * sizeof(float)));
+					x -= SIMD::Float(*Pointer<Float>(constants + OFFSET(Constants, SampleLocationsX) + q * sizeof(float)));
 				}
 
 				z[q] = interpolate(x, Dz[q], z[q], primitive + OFFSET(Primitive, z), false, false);
 
 				if(state.depthBias)
 				{
-					z[q] += Float4(*Pointer<Float>(primitive + OFFSET(Primitive, zBias)));
+					z[q] += SIMD::Float(*Pointer<Float>(primitive + OFFSET(Primitive, zBias)));
 				}
 
 				unclampedZ[q] = z[q];
@@ -140,21 +140,21 @@
 				occlusionSampleCount(zMask, sMask, samples);
 			}
 
-			Float4 yyyy = Float4(Float(y)) + *Pointer<Float4>(primitive + OFFSET(Primitive, yQuad), 16);
+			SIMD::Float yyyy = SIMD::Float(Float(y)) + SIMD::Float(*Pointer<Float4>(primitive + OFFSET(Primitive, yQuad), 16));
 
 			// Centroid locations
-			Float4 XXXX = 0.0f;
-			Float4 YYYY = 0.0f;
+			SIMD::Float XXXX = 0.0f;
+			SIMD::Float YYYY = 0.0f;
 
 			if(state.centroid || shaderContainsInterpolation)  // TODO(b/194714095)
 			{
-				Float4 WWWW(1.0e-9f);
+				SIMD::Float WWWW = 1.0e-9f;
 
 				for(unsigned int q : samples)
 				{
-					XXXX += *Pointer<Float4>(constants + OFFSET(Constants, sampleX[q]) + 16 * cMask[q]);
-					YYYY += *Pointer<Float4>(constants + OFFSET(Constants, sampleY[q]) + 16 * cMask[q]);
-					WWWW += *Pointer<Float4>(constants + OFFSET(Constants, weight) + 16 * cMask[q]);
+					XXXX += SIMD::Float(*Pointer<Float4>(constants + OFFSET(Constants, sampleX[q]) + 16 * cMask[q]));
+					YYYY += SIMD::Float(*Pointer<Float4>(constants + OFFSET(Constants, sampleY[q]) + 16 * cMask[q]));
+					WWWW += SIMD::Float(*Pointer<Float4>(constants + OFFSET(Constants, weight) + 16 * cMask[q]));
 				}
 
 				WWWW = Rcp(WWWW, true /* relaxedPrecision */);
@@ -417,9 +417,9 @@
 	}
 }
 
-Bool PixelRoutine::depthTest32F(const Pointer<Byte> &zBuffer, int q, const Int &x, const Float4 &z, const Int &sMask, Int &zMask, const Int &cMask)
+Bool PixelRoutine::depthTest32F(const Pointer<Byte> &zBuffer, int q, const Int &x, const SIMD::Float &z, const Int &sMask, Int &zMask, const Int &cMask)
 {
-	Float4 Z = z;
+	SIMD::Float Z = z;
 
 	Pointer<Byte> buffer = zBuffer + 4 * x;
 	Int pitch = *Pointer<Int>(data + OFFSET(DrawData, depthPitchB));
@@ -429,14 +429,14 @@
 		buffer += q * *Pointer<Int>(data + OFFSET(DrawData, depthSliceB));
 	}
 
-	Float4 zValue;
+	SIMD::Float zValue;
 
 	if(state.depthCompareMode != VK_COMPARE_OP_NEVER || (state.depthCompareMode != VK_COMPARE_OP_ALWAYS && !state.depthWriteEnable))
 	{
 		zValue = Float4(*Pointer<Float2>(buffer), *Pointer<Float2>(buffer + pitch));
 	}
 
-	Int4 zTest;
+	SIMD::Int zTest;
 
 	switch(state.depthCompareMode)
 	{
@@ -489,7 +489,7 @@
 	return zMask != 0;
 }
 
-Bool PixelRoutine::depthTest16(const Pointer<Byte> &zBuffer, int q, const Int &x, const Float4 &z, const Int &sMask, Int &zMask, const Int &cMask)
+Bool PixelRoutine::depthTest16(const Pointer<Byte> &zBuffer, int q, const Int &x, const SIMD::Float &z, const Int &sMask, Int &zMask, const Int &cMask)
 {
 	Short4 Z = convertFixed16(z, true);
 
@@ -566,7 +566,7 @@
 	return zMask != 0;
 }
 
-Float4 PixelRoutine::clampDepth(const Float4 &z)
+SIMD::Float PixelRoutine::clampDepth(const SIMD::Float &z)
 {
 	if(!state.depthClamp)
 	{
@@ -576,7 +576,7 @@
 	return Min(Max(z, state.minDepthClamp), state.maxDepthClamp);
 }
 
-Bool PixelRoutine::depthTest(const Pointer<Byte> &zBuffer, int q, const Int &x, const Float4 &z, const Int &sMask, Int &zMask, const Int &cMask)
+Bool PixelRoutine::depthTest(const Pointer<Byte> &zBuffer, int q, const Int &x, const SIMD::Float &z, const Int &sMask, Int &zMask, const Int &cMask)
 {
 	if(!state.depthTestActive)
 	{
@@ -663,7 +663,7 @@
 	}
 }
 
-void PixelRoutine::alphaToCoverage(Int cMask[4], const Float4 &alpha, const SampleSet &samples)
+void PixelRoutine::alphaToCoverage(Int cMask[4], const SIMD::Float &alpha, const SampleSet &samples)
 {
 	static const int a2c[4] = {
 		OFFSET(DrawData, a2c0),
@@ -674,7 +674,7 @@
 
 	for(unsigned int q : samples)
 	{
-		Int4 coverage = CmpNLT(alpha, Float4(*Pointer<Float>(data + a2c[q])));
+		SIMD::Int coverage = CmpNLT(alpha, SIMD::Float(*Pointer<Float>(data + a2c[q])));
 		Int aMask = SignMask(coverage);
 		cMask[q] &= aMask;
 	}
@@ -1919,7 +1919,7 @@
 	}
 }
 
-void PixelRoutine::blendFactorAlpha(Float4 &blendFactorAlpha, const Float4 &sourceAlpha, const Float4 &destAlpha, VkBlendFactor alphaBlendFactor, vk::Format format)
+void PixelRoutine::blendFactorAlpha(SIMD::Float &blendFactorAlpha, const SIMD::Float &sourceAlpha, const SIMD::Float &destAlpha, VkBlendFactor alphaBlendFactor, vk::Format format)
 {
 	switch(alphaBlendFactor)
 	{
@@ -1984,103 +1984,103 @@
 	}
 }
 
-Float4 PixelRoutine::blendOpOverlay(Float4 &src, Float4 &dst)
+SIMD::Float PixelRoutine::blendOpOverlay(SIMD::Float &src, SIMD::Float &dst)
 {
-	Int4 largeDst = CmpGT(dst, 0.5f);
-	return As<Float4>(
-	    (~largeDst & As<Int4>(2.0f * src * dst)) |
-	    (largeDst & As<Int4>(1.0f - (2.0f * (1.0f - src) * (1.0f - dst)))));
+	SIMD::Int largeDst = CmpGT(dst, 0.5f);
+	return As<SIMD::Float>(
+	    (~largeDst & As<SIMD::Int>(2.0f * src * dst)) |
+	    (largeDst & As<SIMD::Int>(1.0f - (2.0f * (1.0f - src) * (1.0f - dst)))));
 }
 
-Float4 PixelRoutine::blendOpColorDodge(Float4 &src, Float4 &dst)
+SIMD::Float PixelRoutine::blendOpColorDodge(SIMD::Float &src, SIMD::Float &dst)
 {
-	Int4 srcBelowOne = CmpLT(src, 1.0f);
-	Int4 positiveDst = CmpGT(dst, 0.0f);
-	return As<Float4>(positiveDst & ((~srcBelowOne & As<Int4>(Float4(1.0f))) |
-	                                 (srcBelowOne & As<Int4>(Min(1.0f, (dst / (1.0f - src)))))));
+	SIMD::Int srcBelowOne = CmpLT(src, 1.0f);
+	SIMD::Int positiveDst = CmpGT(dst, 0.0f);
+	return As<SIMD::Float>(positiveDst & ((~srcBelowOne & As<SIMD::Int>(SIMD::Float(1.0f))) |
+	                                      (srcBelowOne & As<SIMD::Int>(Min(1.0f, (dst / (1.0f - src)))))));
 }
 
-Float4 PixelRoutine::blendOpColorBurn(Float4 &src, Float4 &dst)
+SIMD::Float PixelRoutine::blendOpColorBurn(SIMD::Float &src, SIMD::Float &dst)
 {
-	Int4 dstBelowOne = CmpLT(dst, 1.0f);
-	Int4 positiveSrc = CmpGT(src, 0.0f);
-	return As<Float4>(
-	    (~dstBelowOne & As<Int4>(Float4(1.0f))) |
-	    (dstBelowOne & positiveSrc & As<Int4>(1.0f - Min(1.0f, (1.0f - dst) / src))));
+	SIMD::Int dstBelowOne = CmpLT(dst, 1.0f);
+	SIMD::Int positiveSrc = CmpGT(src, 0.0f);
+	return As<SIMD::Float>(
+	    (~dstBelowOne & As<SIMD::Int>(SIMD::Float(1.0f))) |
+	    (dstBelowOne & positiveSrc & As<SIMD::Int>(1.0f - Min(1.0f, (1.0f - dst) / src))));
 }
 
-Float4 PixelRoutine::blendOpHardlight(Float4 &src, Float4 &dst)
+SIMD::Float PixelRoutine::blendOpHardlight(SIMD::Float &src, SIMD::Float &dst)
 {
-	Int4 largeSrc = CmpGT(src, 0.5f);
-	return As<Float4>(
-	    (~largeSrc & As<Int4>(2.0f * src * dst)) |
-	    (largeSrc & As<Int4>(1.0f - (2.0f * (1.0f - src) * (1.0f - dst)))));
+	SIMD::Int largeSrc = CmpGT(src, 0.5f);
+	return As<SIMD::Float>(
+	    (~largeSrc & As<SIMD::Int>(2.0f * src * dst)) |
+	    (largeSrc & As<SIMD::Int>(1.0f - (2.0f * (1.0f - src) * (1.0f - dst)))));
 }
 
-Float4 PixelRoutine::blendOpSoftlight(Float4 &src, Float4 &dst)
+SIMD::Float PixelRoutine::blendOpSoftlight(SIMD::Float &src, SIMD::Float &dst)
 {
-	Int4 largeSrc = CmpGT(src, 0.5f);
-	Int4 largeDst = CmpGT(dst, 0.25f);
+	SIMD::Int largeSrc = CmpGT(src, 0.5f);
+	SIMD::Int largeDst = CmpGT(dst, 0.25f);
 
-	return As<Float4>(
-	    (~largeSrc & As<Int4>(dst - ((1.0f - (2.0f * src)) * dst * (1.0f - dst)))) |
-	    (largeSrc & ((~largeDst & As<Int4>(dst + (((2.0f * src) - 1.0f) * dst * ((((16.0f * dst) - 12.0f) * dst) + 3.0f)))) |
-	                 (largeDst & As<Int4>(dst + (((2.0f * src) - 1.0f) * (Sqrt<Mediump>(dst) - dst)))))));
+	return As<SIMD::Float>(
+	    (~largeSrc & As<SIMD::Int>(dst - ((1.0f - (2.0f * src)) * dst * (1.0f - dst)))) |
+	    (largeSrc & ((~largeDst & As<SIMD::Int>(dst + (((2.0f * src) - 1.0f) * dst * ((((16.0f * dst) - 12.0f) * dst) + 3.0f)))) |
+	                 (largeDst & As<SIMD::Int>(dst + (((2.0f * src) - 1.0f) * (Sqrt<Mediump>(dst) - dst)))))));
 }
 
-Float4 PixelRoutine::maxRGB(Vector4f &c)
+SIMD::Float PixelRoutine::maxRGB(Vector4f &c)
 {
 	return Max(Max(c.x, c.y), c.z);
 }
 
-Float4 PixelRoutine::minRGB(Vector4f &c)
+SIMD::Float 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)
+void PixelRoutine::setLumSat(Vector4f &cbase, Vector4f &csat, Vector4f &clum, SIMD::Float &x, SIMD::Float &y, SIMD::Float &z)
 {
-	Float4 minbase = minRGB(cbase);
-	Float4 sbase = maxRGB(cbase) - minbase;
-	Float4 ssat = maxRGB(csat) - minRGB(csat);
-	Int4 isNonZero = CmpGT(sbase, 0.0f);
+	SIMD::Float minbase = minRGB(cbase);
+	SIMD::Float sbase = maxRGB(cbase) - minbase;
+	SIMD::Float ssat = maxRGB(csat) - minRGB(csat);
+	SIMD::Int isNonZero = CmpGT(sbase, 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));
+	color.x = As<SIMD::Float>(isNonZero & As<SIMD::Int>((cbase.x - minbase) * ssat / sbase));
+	color.y = As<SIMD::Float>(isNonZero & As<SIMD::Int>((cbase.y - minbase) * ssat / sbase));
+	color.z = As<SIMD::Float>(isNonZero & As<SIMD::Int>((cbase.z - minbase) * ssat / sbase));
 	setLum(color, clum, x, y, z);
 }
 
-Float4 PixelRoutine::lumRGB(Vector4f &c)
+SIMD::Float PixelRoutine::lumRGB(Vector4f &c)
 {
 	return c.x * 0.3f + c.y * 0.59f + c.z * 0.11f;
 }
 
-Float4 PixelRoutine::computeLum(Float4 &color, Float4 &lum, Float4 &mincol, Float4 &maxcol, Int4 &negative, Int4 &aboveOne)
+SIMD::Float PixelRoutine::computeLum(SIMD::Float &color, SIMD::Float &lum, SIMD::Float &mincol, SIMD::Float &maxcol, SIMD::Int &negative, SIMD::Int &aboveOne)
 {
-	return As<Float4>(
-	    (negative & As<Int4>(lum + ((color - lum) * lum) / (lum - mincol))) |
-	    (~negative & ((aboveOne & As<Int4>(lum + ((color - lum) * (1.0f - lum)) / (maxcol - lum))) |
-	                  (~aboveOne & As<Int4>(color)))));
+	return As<SIMD::Float>(
+	    (negative & As<SIMD::Int>(lum + ((color - lum) * lum) / (lum - mincol))) |
+	    (~negative & ((aboveOne & As<SIMD::Int>(lum + ((color - lum) * (1.0f - lum)) / (maxcol - lum))) |
+	                  (~aboveOne & As<SIMD::Int>(color)))));
 }
 
-void PixelRoutine::setLum(Vector4f &cbase, Vector4f &clum, Float4 &x, Float4 &y, Float4 &z)
+void PixelRoutine::setLum(Vector4f &cbase, Vector4f &clum, SIMD::Float &x, SIMD::Float &y, SIMD::Float &z)
 {
-	Float4 lbase = lumRGB(cbase);
-	Float4 llum = lumRGB(clum);
-	Float4 ldiff = llum - lbase;
+	SIMD::Float lbase = lumRGB(cbase);
+	SIMD::Float llum = lumRGB(clum);
+	SIMD::Float 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);
+	SIMD::Float lum = lumRGB(color);
+	SIMD::Float mincol = minRGB(color);
+	SIMD::Float maxcol = maxRGB(color);
 
-	Int4 negative = CmpLT(mincol, 0.0f);
-	Int4 aboveOne = CmpGT(maxcol, 1.0f);
+	SIMD::Int negative = CmpLT(mincol, 0.0f);
+	SIMD::Int aboveOne = CmpGT(maxcol, 1.0f);
 
 	x = computeLum(color.x, lum, mincol, maxcol, negative, aboveOne);
 	y = computeLum(color.y, lum, mincol, maxcol, negative, aboveOne);
@@ -2089,10 +2089,10 @@
 
 void PixelRoutine::premultiply(Vector4f &c)
 {
-	Int4 nonZeroAlpha = CmpNEQ(c.w, 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));
+	SIMD::Int nonZeroAlpha = CmpNEQ(c.w, 0.0f);
+	c.x = As<SIMD::Float>(nonZeroAlpha & As<SIMD::Int>(c.x / c.w));
+	c.y = As<SIMD::Float>(nonZeroAlpha & As<SIMD::Int>(c.y / c.w));
+	c.z = As<SIMD::Float>(nonZeroAlpha & As<SIMD::Int>(c.z / c.w));
 }
 
 Vector4f PixelRoutine::computeAdvancedBlendMode(int index, const Vector4f &src, const Vector4f &dst, const Vector4f &srcFactor, const Vector4f &dstFactor)
@@ -2188,7 +2188,7 @@
 		break;
 	}
 
-	Float4 p = srcColor.w * dstColor.w;
+	SIMD::Float p = srcColor.w * dstColor.w;
 	blendedColor.x *= p;
 	blendedColor.y *= p;
 	blendedColor.z *= p;
diff --git a/src/Pipeline/PixelRoutine.hpp b/src/Pipeline/PixelRoutine.hpp
index 855021e..229455d 100644
--- a/src/Pipeline/PixelRoutine.hpp
+++ b/src/Pipeline/PixelRoutine.hpp
@@ -37,14 +37,14 @@
 protected:
 	using SampleSet = std::vector<int>;
 
-	Float4 z[4];  // Multisampled z
-	Float4 w;     // Used as is
-	Float4 rhw;   // Reciprocal w
+	SIMD::Float z[4];  // Multisampled z
+	SIMD::Float w;     // Used as is
+	SIMD::Float rhw;   // Reciprocal w
 
 	SpirvRoutine routine;
 	const vk::DescriptorSet::Bindings &descriptorSets;
 
-	virtual void setBuiltins(Int &x, Int &y, Float4 (&z)[4], Float4 &w, Int cMask[4], const SampleSet &samples) = 0;
+	virtual void setBuiltins(Int &x, Int &y, SIMD::Float (&z)[4], SIMD::Float &w, Int cMask[4], const SampleSet &samples) = 0;
 	virtual void executeShader(Int cMask[4], Int sMask[4], Int zMask[4], const SampleSet &samples) = 0;
 	virtual Bool alphaTest(Int cMask[4], const SampleSet &samples) = 0;
 	virtual void blendColor(Pointer<Byte> cBuffer[4], Int &x, Int sMask[4], Int zMask[4], Int cMask[4], const SampleSet &samples) = 0;
@@ -52,7 +52,7 @@
 	void quad(Pointer<Byte> cBuffer[4], Pointer<Byte> &zBuffer, Pointer<Byte> &sBuffer, Int cMask[4], Int &x, Int &y) override;
 
 	void alphaTest(Int &aMask, const Short4 &alpha);
-	void alphaToCoverage(Int cMask[4], const Float4 &alpha, const SampleSet &samples);
+	void alphaToCoverage(Int cMask[4], const SIMD::Float &alpha, const SampleSet &samples);
 
 	void writeColor(int index, const Pointer<Byte> &cBuffer, const Int &x, Vector4f &color, const Int &sMask, const Int &zMask, const Int &cMask);
 	Vector4f alphaBlend(int index, const Pointer<Byte> &cBuffer, const Vector4f &sourceColor, const Int &x);
@@ -70,29 +70,31 @@
 	void stencilTest(Byte8 &value, VkCompareOp stencilCompareMode, bool isBack);
 	Byte8 stencilOperation(const Byte8 &bufferValue, const PixelProcessor::States::StencilOpState &ops, bool isBack, const Int &zMask, const Int &sMask);
 	Byte8 stencilOperation(const Byte8 &bufferValue, VkStencilOp operation, bool isBack);
-	Float4 clampDepth(const Float4 &z);
-	Bool depthTest(const Pointer<Byte> &zBuffer, int q, const Int &x, const Float4 &z, const Int &sMask, Int &zMask, const Int &cMask);
+	SIMD::Float clampDepth(const SIMD::Float &z);
+	Bool depthTest(const Pointer<Byte> &zBuffer, int q, const Int &x, const SIMD::Float &z, const Int &sMask, Int &zMask, const Int &cMask);
 	void depthBoundsTest(const Pointer<Byte> &zBuffer, int q, const Int &x, Int &zMask, Int &cMask);
 
 	void readPixel(int index, const Pointer<Byte> &cBuffer, const Int &x, Vector4s &pixel);
 	enum BlendFactorModifier { None, OneMinus };
 	Float blendConstant(vk::Format format, int component, BlendFactorModifier modifier = None);
 	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);
+	void blendFactorAlpha(SIMD::Float &blendFactorAlpha, const SIMD::Float &sourceAlpha, const SIMD::Float &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);
+	SIMD::Float blendOpOverlay(SIMD::Float &src, SIMD::Float &dst);
+	SIMD::Float blendOpColorDodge(SIMD::Float &src, SIMD::Float &dst);
+	SIMD::Float blendOpColorBurn(SIMD::Float &src, SIMD::Float &dst);
+	SIMD::Float blendOpHardlight(SIMD::Float &src, SIMD::Float &dst);
+	SIMD::Float blendOpSoftlight(SIMD::Float &src, SIMD::Float &dst);
+	void setLumSat(Vector4f &cbase, Vector4f &csat, Vector4f &clum, SIMD::Float &x, SIMD::Float &y, SIMD::Float &z);
+	void setLum(Vector4f &cbase, Vector4f &clum, SIMD::Float &x, SIMD::Float &y, SIMD::Float &z);
+	SIMD::Float computeLum(SIMD::Float &color, SIMD::Float &lum, SIMD::Float &mincol, SIMD::Float &maxcol, SIMD::Int &negative, SIMD::Int &aboveOne);
+	SIMD::Float maxRGB(Vector4f &c);
+	SIMD::Float minRGB(Vector4f &c);
+	SIMD::Float 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);
@@ -101,8 +103,8 @@
 	void linearToSRGB16_12_16(Vector4s &c);
 	Float4 sRGBtoLinear(const Float4 &x);
 
-	Bool depthTest32F(const Pointer<Byte> &zBuffer, int q, const Int &x, const Float4 &z, const Int &sMask, Int &zMask, const Int &cMask);
-	Bool depthTest16(const Pointer<Byte> &zBuffer, int q, const Int &x, const Float4 &z, const Int &sMask, Int &zMask, const Int &cMask);
+	Bool depthTest32F(const Pointer<Byte> &zBuffer, int q, const Int &x, const SIMD::Float &z, const Int &sMask, Int &zMask, const Int &cMask);
+	Bool depthTest16(const Pointer<Byte> &zBuffer, int q, const Int &x, const SIMD::Float &z, const Int &sMask, Int &zMask, const Int &cMask);
 
 	void writeDepth32F(Pointer<Byte> &zBuffer, int q, const Int &x, const Float4 &z, const Int &zMask);
 	void writeDepth16(Pointer<Byte> &zBuffer, int q, const Int &x, const Float4 &z, const Int &zMask);
diff --git a/src/Pipeline/SamplerCore.cpp b/src/Pipeline/SamplerCore.cpp
index d700a5d..3162e29 100644
--- a/src/Pipeline/SamplerCore.cpp
+++ b/src/Pipeline/SamplerCore.cpp
@@ -27,7 +27,8 @@
     , function(function)
 {
 }
-Vector4f SamplerCore::sampleTexture(Pointer<Byte> &texture, Float4 uvwa[4], Float4 &dRef, Float &&lodOrBias, Float4 &dsx, Float4 &dsy, Vector4i &offset, Int4 &sample)
+
+Vector4f SamplerCore::sampleTexture(Pointer<Byte> &texture, SIMD::Float uvwa[4], SIMD::Float &dRef, Float &&lodOrBias, SIMD::Float &dsx, SIMD::Float &dsy, Vector4i offset, SIMD::Int &sample)
 {
 	Vector4f c;
 
diff --git a/src/Pipeline/SamplerCore.hpp b/src/Pipeline/SamplerCore.hpp
index 757dc7c..632f894 100644
--- a/src/Pipeline/SamplerCore.hpp
+++ b/src/Pipeline/SamplerCore.hpp
@@ -61,7 +61,7 @@
 public:
 	SamplerCore(Pointer<Byte> &constants, const Sampler &state, SamplerFunction function);
 
-	Vector4f sampleTexture(Pointer<Byte> &texture, Float4 uvwa[4], Float4 &q, Float &&lodOrBias, Float4 &dsx, Float4 &dsy, Vector4i &offset, Int4 &sample);
+	Vector4f sampleTexture(Pointer<Byte> &texture, SIMD::Float uvwa[4], SIMD::Float &dRef, Float &&lodOrBias, SIMD::Float &dsx, SIMD::Float &dsy, Vector4i offset, SIMD::Int &sample);
 
 private:
 	Float4 applySwizzle(const Vector4f &c, VkComponentSwizzle swizzle, bool integer);
diff --git a/src/Pipeline/SpirvShader.hpp b/src/Pipeline/SpirvShader.hpp
index a01759a..5d8ddae 100644
--- a/src/Pipeline/SpirvShader.hpp
+++ b/src/Pipeline/SpirvShader.hpp
@@ -1027,7 +1027,7 @@
 	static bool IsStorageInterleavedByLane(spv::StorageClass storageClass);
 	static bool IsExplicitLayout(spv::StorageClass storageClass);
 
-	static sw::SIMD::Pointer GetElementPointer(sw::SIMD::Pointer structure, uint32_t offset, bool interleavedByLane);
+	static SIMD::Pointer GetElementPointer(SIMD::Pointer structure, uint32_t offset, bool interleavedByLane);
 
 	// Output storage buffers and images should not be affected by helper invocations
 	static bool StoresInHelperInvocation(spv::StorageClass storageClass);
@@ -1419,8 +1419,8 @@
 		AtSample,
 		AtOffset,
 	};
-	SIMD::Float Interpolate(SIMD::Pointer const &ptr, int32_t location, Object::ID paramId,
-	                        uint32_t component, EmitState *state, InterpolationType type) const;
+	SIMD::Float EmitInterpolate(SIMD::Pointer const &ptr, int32_t location, Object::ID paramId,
+	                            uint32_t component, EmitState *state, InterpolationType type) const;
 
 	// Helper for implementing OpStore, which doesn't take an InsnIterator so it
 	// can also store independent operands.
diff --git a/src/Pipeline/SpirvShaderGLSLstd450.cpp b/src/Pipeline/SpirvShaderGLSLstd450.cpp
index e4e341c..bbbd951 100644
--- a/src/Pipeline/SpirvShaderGLSLstd450.cpp
+++ b/src/Pipeline/SpirvShaderGLSLstd450.cpp
@@ -21,20 +21,21 @@
 #include <spirv/unified1/GLSL.std.450.h>
 #include <spirv/unified1/spirv.hpp>
 
-namespace {
-constexpr float PI = 3.141592653589793f;
+namespace sw {
 
-sw::SIMD::Float Interpolate(const sw::SIMD::Float &x, const sw::SIMD::Float &y, const sw::SIMD::Float &rhw,
-                            const sw::SIMD::Float &A, const sw::SIMD::Float &B, const sw::SIMD::Float &C,
-                            sw::SpirvRoutine::Interpolation interpolation)
+static constexpr float PI = 3.141592653589793f;
+
+static SIMD::Float Interpolate(const SIMD::Float &x, const SIMD::Float &y, const SIMD::Float &rhw,
+                               const SIMD::Float &A, const SIMD::Float &B, const SIMD::Float &C,
+                               SpirvRoutine::Interpolation interpolation)
 {
-	sw::SIMD::Float interpolant = C;
+	SIMD::Float interpolant = C;
 
-	if(interpolation != sw::SpirvRoutine::Flat)
+	if(interpolation != SpirvRoutine::Flat)
 	{
 		interpolant += x * A + y * B;
 
-		if(interpolation == sw::SpirvRoutine::Perspective)
+		if(interpolation == SpirvRoutine::Perspective)
 		{
 			interpolant *= rhw;
 		}
@@ -43,10 +44,6 @@
 	return interpolant;
 }
 
-}  // namespace
-
-namespace sw {
-
 SpirvShader::EmitResult SpirvShader::EmitExtGLSLstd450(InsnIterator insn, EmitState *state) const
 {
 	auto &type = getType(insn.resultTypeId());
@@ -135,7 +132,7 @@
 				auto x = Round(src.Float(i));
 				// dst = round(src) + ((round(src) < src) * 2 - 1) * (fract(src) == 0.5) * isOdd(round(src));
 				dst.move(i, x + ((SIMD::Float(CmpLT(x, src.Float(i)) & SIMD::Int(1)) * SIMD::Float(2.0f)) - SIMD::Float(1.0f)) *
-				                    SIMD::Float(CmpEQ(Frac(src.Float(i)), SIMD::Float(0.5f)) & SIMD::Int(1)) * SIMD::Float(Int4(x) & SIMD::Int(1)));
+				                    SIMD::Float(CmpEQ(Frac(src.Float(i)), SIMD::Float(0.5f)) & SIMD::Int(1)) * SIMD::Float(SIMD::Int(x) & SIMD::Int(1)));
 			}
 		}
 		break;
@@ -216,11 +213,8 @@
 			auto x = Operand(this, state, insn.word(7));
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
-				auto tx = Min(Max((x.Float(i) - edge0.Float(i)) /
-				                      (edge1.Float(i) - edge0.Float(i)),
-				                  SIMD::Float(0.0f)),
-				              SIMD::Float(1.0f));
-				dst.move(i, tx * tx * (Float4(3.0f) - Float4(2.0f) * tx));
+				auto tx = Min(Max((x.Float(i) - edge0.Float(i)) / (edge1.Float(i) - edge0.Float(i)), 0.0f), 1.0f);
+				dst.move(i, tx * tx * (3.0f - 2.0f * tx));
 			}
 		}
 		break;
@@ -602,7 +596,7 @@
 
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
-				dst.move(i, sw::Sin(radians.Float(i), d.RelaxedPrecision));
+				dst.move(i, Sin(radians.Float(i), d.RelaxedPrecision));
 			}
 		}
 		break;
@@ -613,7 +607,7 @@
 
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
-				dst.move(i, sw::Cos(radians.Float(i), d.RelaxedPrecision));
+				dst.move(i, Cos(radians.Float(i), d.RelaxedPrecision));
 			}
 		}
 		break;
@@ -624,7 +618,7 @@
 
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
-				dst.move(i, sw::Tan(radians.Float(i), d.RelaxedPrecision));
+				dst.move(i, Tan(radians.Float(i), d.RelaxedPrecision));
 			}
 		}
 		break;
@@ -635,7 +629,7 @@
 
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
-				dst.move(i, sw::Asin(val.Float(i), d.RelaxedPrecision));
+				dst.move(i, Asin(val.Float(i), d.RelaxedPrecision));
 			}
 		}
 		break;
@@ -646,7 +640,7 @@
 
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
-				dst.move(i, sw::Acos(val.Float(i), d.RelaxedPrecision));
+				dst.move(i, Acos(val.Float(i), d.RelaxedPrecision));
 			}
 		}
 		break;
@@ -657,7 +651,7 @@
 
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
-				dst.move(i, sw::Atan(val.Float(i), d.RelaxedPrecision));
+				dst.move(i, Atan(val.Float(i), d.RelaxedPrecision));
 			}
 		}
 		break;
@@ -668,7 +662,7 @@
 
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
-				dst.move(i, sw::Sinh(val.Float(i), d.RelaxedPrecision));
+				dst.move(i, Sinh(val.Float(i), d.RelaxedPrecision));
 			}
 		}
 		break;
@@ -679,7 +673,7 @@
 
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
-				dst.move(i, sw::Cosh(val.Float(i), d.RelaxedPrecision));
+				dst.move(i, Cosh(val.Float(i), d.RelaxedPrecision));
 			}
 		}
 		break;
@@ -690,7 +684,7 @@
 
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
-				dst.move(i, sw::Tanh(val.Float(i), d.RelaxedPrecision));
+				dst.move(i, Tanh(val.Float(i), d.RelaxedPrecision));
 			}
 		}
 		break;
@@ -701,7 +695,7 @@
 
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
-				dst.move(i, sw::Asinh(val.Float(i), d.RelaxedPrecision));
+				dst.move(i, Asinh(val.Float(i), d.RelaxedPrecision));
 			}
 		}
 		break;
@@ -712,7 +706,7 @@
 
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
-				dst.move(i, sw::Acosh(val.Float(i), d.RelaxedPrecision));
+				dst.move(i, Acosh(val.Float(i), d.RelaxedPrecision));
 			}
 		}
 		break;
@@ -723,7 +717,7 @@
 
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
-				dst.move(i, sw::Atanh(val.Float(i), d.RelaxedPrecision));
+				dst.move(i, Atanh(val.Float(i), d.RelaxedPrecision));
 			}
 		}
 		break;
@@ -735,7 +729,7 @@
 
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
-				dst.move(i, sw::Atan2(x.Float(i), y.Float(i), d.RelaxedPrecision));
+				dst.move(i, Atan2(x.Float(i), y.Float(i), d.RelaxedPrecision));
 			}
 		}
 		break;
@@ -747,7 +741,7 @@
 
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
-				dst.move(i, sw::Pow(x.Float(i), y.Float(i), d.RelaxedPrecision));
+				dst.move(i, Pow(x.Float(i), y.Float(i), d.RelaxedPrecision));
 			}
 		}
 		break;
@@ -758,7 +752,7 @@
 
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
-				dst.move(i, sw::Exp(val.Float(i), d.RelaxedPrecision));
+				dst.move(i, Exp(val.Float(i), d.RelaxedPrecision));
 			}
 		}
 		break;
@@ -769,7 +763,7 @@
 
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
-				dst.move(i, sw::Log(val.Float(i), d.RelaxedPrecision));
+				dst.move(i, Log(val.Float(i), d.RelaxedPrecision));
 			}
 		}
 		break;
@@ -780,7 +774,7 @@
 
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
-				dst.move(i, sw::Exp2(val.Float(i), d.RelaxedPrecision));
+				dst.move(i, Exp2(val.Float(i), d.RelaxedPrecision));
 			}
 		}
 		break;
@@ -791,7 +785,7 @@
 
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
-				dst.move(i, sw::Log2(val.Float(i), d.RelaxedPrecision));
+				dst.move(i, Log2(val.Float(i), d.RelaxedPrecision));
 			}
 		}
 		break;
@@ -943,7 +937,7 @@
 			auto ptr = state->getPointer(insn.word(5));
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
-				dst.move(i, Interpolate(ptr, d.Location, 0, i, state, SpirvShader::Centroid));
+				dst.move(i, EmitInterpolate(ptr, d.Location, 0, i, state, SpirvShader::Centroid));
 			}
 		}
 		break;
@@ -953,7 +947,7 @@
 			auto ptr = state->getPointer(insn.word(5));
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
-				dst.move(i, Interpolate(ptr, d.Location, insn.word(6), i, state, SpirvShader::AtSample));
+				dst.move(i, EmitInterpolate(ptr, d.Location, insn.word(6), i, state, SpirvShader::AtSample));
 			}
 		}
 		break;
@@ -963,7 +957,7 @@
 			auto ptr = state->getPointer(insn.word(5));
 			for(auto i = 0u; i < type.componentCount; i++)
 			{
-				dst.move(i, Interpolate(ptr, d.Location, insn.word(6), i, state, SpirvShader::AtOffset));
+				dst.move(i, EmitInterpolate(ptr, d.Location, insn.word(6), i, state, SpirvShader::AtOffset));
 			}
 		}
 		break;
@@ -1007,8 +1001,8 @@
 	return EmitResult::Continue;
 }
 
-SIMD::Float SpirvShader::Interpolate(SIMD::Pointer const &ptr, int32_t location, Object::ID paramId,
-                                     uint32_t component, EmitState *state, InterpolationType type) const
+SIMD::Float SpirvShader::EmitInterpolate(SIMD::Pointer const &ptr, int32_t location, Object::ID paramId,
+                                         uint32_t component, EmitState *state, InterpolationType type) const
 {
 	uint32_t interpolant = (location * 4);
 	uint32_t components_per_row = GetNumInputComponents(location);
@@ -1056,7 +1050,7 @@
 			// input variable is undefined, so we just clamp to avoid OOB accesses.
 			SIMD::Int samples = sampleOperand.Int(0) & SIMD::Int(NUM_SAMPLES - 1);
 
-			for(int i = 0; i < SIMD::Width; ++i)
+			for(int i = 0; i < SIMD::Width; i++)
 			{
 				Int sample = Extract(samples, i);
 				x = Insert(x, *Pointer<Float>(state->routine->constants + OFFSET(Constants, SampleLocationsX) + sample * sizeof(float)), i);
@@ -1098,7 +1092,7 @@
 		SIMD::Float B;
 		SIMD::Float C;
 
-		for(int i = 0; i < SIMD::Width; ++i)
+		for(int i = 0; i < SIMD::Width; i++)
 		{
 			Int offset = ((Extract(ptr.dynamicOffsets, i) + ptr.staticOffsets[i]) >> offsetShift) + component;
 			Pointer<Byte> planeEquationI = planeEquation + (offset * sizeof(PlaneEquation));
@@ -1107,7 +1101,7 @@
 			C = Insert(C, *Pointer<Float>(planeEquationI + OFFSET(PlaneEquation, C)), i);
 		}
 
-		return ::Interpolate(x, y, rhw, A, B, C, state->routine->inputsInterpolation[packedInterpolant]);
+		return Interpolate(x, y, rhw, A, B, C, state->routine->inputsInterpolation[packedInterpolant]);
 	}
 	else
 	{
@@ -1136,7 +1130,7 @@
 		B = *Pointer<Float>(planeEquation + OFFSET(PlaneEquation, B));
 	}
 
-	return ::Interpolate(x, y, rhw, A, B, C, interpolation);
+	return Interpolate(x, y, rhw, A, B, C, interpolation);
 }
 
 }  // namespace sw
\ No newline at end of file
diff --git a/src/Pipeline/SpirvShaderMemory.cpp b/src/Pipeline/SpirvShaderMemory.cpp
index b3caa83..9b27561 100644
--- a/src/Pipeline/SpirvShaderMemory.cpp
+++ b/src/Pipeline/SpirvShaderMemory.cpp
@@ -574,10 +574,10 @@
 {
 	if(interleavedByLane)
 	{
-		structure.staticOffsets[0] += 0 * sizeof(float);
-		structure.staticOffsets[1] += 1 * sizeof(float);
-		structure.staticOffsets[2] += 2 * sizeof(float);
-		structure.staticOffsets[3] += 3 * sizeof(float);
+		for(int i = 0; i < SIMD::Width; i++)
+		{
+			structure.staticOffsets[i] += i * sizeof(float);
+		}
 
 		return structure + offset * sw::SIMD::Width;
 	}
diff --git a/src/Pipeline/VertexProgram.cpp b/src/Pipeline/VertexProgram.cpp
index 7583b12..5a3dc2a 100644
--- a/src/Pipeline/VertexProgram.cpp
+++ b/src/Pipeline/VertexProgram.cpp
@@ -80,7 +80,8 @@
 	}
 
 	auto activeLaneMask = SIMD::Int(0xFFFFFFFF);
-	Int4 storesAndAtomicsMask = CmpGE(UInt4(vertexCount), UInt4(1, 2, 3, 4));
+	ASSERT(SIMD::Width == 4);
+	SIMD::Int storesAndAtomicsMask = CmpGE(SIMD::UInt(vertexCount), SIMD::UInt(1, 2, 3, 4));
 	spirvShader->emit(&routine, activeLaneMask, storesAndAtomicsMask, descriptorSets);
 
 	spirvShader->emitEpilog(&routine);
diff --git a/src/Pipeline/VertexRoutine.cpp b/src/Pipeline/VertexRoutine.cpp
index 6e8d3cf..535dc97 100644
--- a/src/Pipeline/VertexRoutine.cpp
+++ b/src/Pipeline/VertexRoutine.cpp
@@ -124,10 +124,10 @@
 		auto posZ = pos[it->second.FirstComponent + 2];
 		auto posW = pos[it->second.FirstComponent + 3];
 
-		Int4 maxX = CmpLT(posW, posX);
-		Int4 maxY = CmpLT(posW, posY);
-		Int4 minX = CmpNLE(-posW, posX);
-		Int4 minY = CmpNLE(-posW, posY);
+		SIMD::Int maxX = CmpLT(posW, posX);
+		SIMD::Int maxY = CmpLT(posW, posY);
+		SIMD::Int minX = CmpNLE(-posW, posX);
+		SIMD::Int minY = CmpNLE(-posW, posY);
 
 		clipFlags = Pointer<Int>(constants + OFFSET(Constants, maxX))[SignMask(maxX)];
 		clipFlags |= Pointer<Int>(constants + OFFSET(Constants, maxY))[SignMask(maxY)];
@@ -135,18 +135,18 @@
 		clipFlags |= Pointer<Int>(constants + OFFSET(Constants, minY))[SignMask(minY)];
 		if(state.depthClipEnable)
 		{
-			Int4 maxZ = CmpLT(posW, posZ);
-			Int4 minZ = CmpNLE(Float4(0.0f), posZ);
+			SIMD::Int maxZ = CmpLT(posW, posZ);
+			SIMD::Int minZ = CmpNLE(0.0f, posZ);
 			clipFlags |= Pointer<Int>(constants + OFFSET(Constants, maxZ))[SignMask(maxZ)];
 			clipFlags |= Pointer<Int>(constants + OFFSET(Constants, minZ))[SignMask(minZ)];
 		}
 
-		Float4 maxPos = As<Float4>(Int4(0x7F7FFFFF));
-		Int4 finiteX = CmpLE(Abs(posX), maxPos);
-		Int4 finiteY = CmpLE(Abs(posY), maxPos);
-		Int4 finiteZ = CmpLE(Abs(posZ), maxPos);
+		SIMD::Float maxPos = As<SIMD::Float>(SIMD::Int(0x7F7FFFFF));
+		SIMD::Int finiteX = CmpLE(Abs(posX), maxPos);
+		SIMD::Int finiteY = CmpLE(Abs(posY), maxPos);
+		SIMD::Int finiteZ = CmpLE(Abs(posZ), maxPos);
 
-		Int4 finiteXYZ = finiteX & finiteY & finiteZ;
+		SIMD::Int finiteXYZ = finiteX & finiteY & finiteZ;
 		clipFlags |= Pointer<Int>(constants + OFFSET(Constants, fini))[SignMask(finiteXYZ)];
 	}
 }
@@ -597,12 +597,12 @@
 		pos.w = position[it->second.FirstComponent + 3];
 
 		// Projection and viewport transform.
-		Float4 w = As<Float4>(As<Int4>(pos.w) | (As<Int4>(CmpEQ(pos.w, Float4(0.0f))) & As<Int4>(Float4(1.0f))));
-		Float4 rhw = Float4(1.0f) / w;
+		SIMD::Float w = As<SIMD::Float>(As<SIMD::Int>(pos.w) | (As<SIMD::Int>(CmpEQ(pos.w, 0.0f)) & As<SIMD::Int>(SIMD::Float(1.0f))));
+		SIMD::Float rhw = 1.0f / w;
 
 		Vector4f proj;
-		proj.x = As<Float4>(RoundIntClamped(Float4(*Pointer<Float>(data + OFFSET(DrawData, X0xF))) + pos.x * rhw * Float4(*Pointer<Float>(data + OFFSET(DrawData, WxF)))));
-		proj.y = As<Float4>(RoundIntClamped(Float4(*Pointer<Float>(data + OFFSET(DrawData, Y0xF))) + pos.y * rhw * Float4(*Pointer<Float>(data + OFFSET(DrawData, HxF)))));
+		proj.x = As<Float4>(RoundIntClamped(SIMD::Float(*Pointer<Float>(data + OFFSET(DrawData, X0xF))) + pos.x * rhw * SIMD::Float(*Pointer<Float>(data + OFFSET(DrawData, WxF)))));
+		proj.y = As<Float4>(RoundIntClamped(SIMD::Float(*Pointer<Float>(data + OFFSET(DrawData, Y0xF))) + pos.y * rhw * SIMD::Float(*Pointer<Float>(data + OFFSET(DrawData, HxF)))));
 		proj.z = pos.z * rhw;
 		proj.w = rhw;