diff --git a/libraries/ZVulkan/include/zvulkan/vulkanbuilders.h b/libraries/ZVulkan/include/zvulkan/vulkanbuilders.h
index ce98cf1d4..d51203046 100644
--- a/libraries/ZVulkan/include/zvulkan/vulkanbuilders.h
+++ b/libraries/ZVulkan/include/zvulkan/vulkanbuilders.h
@@ -227,19 +227,6 @@ private:
 	friend class GLSLCompilerIncluderImpl;
 };
 
-class ShaderBuilder
-{
-public:
-	ShaderBuilder& Code(std::vector<uint32_t> spirv) { code = std::move(spirv); return *this; }
-	ShaderBuilder& DebugName(const char* name) { debugName = name; return *this; }
-
-	std::unique_ptr<VulkanShader> Create(const char* shadername, VulkanDevice* device);
-
-private:
-	std::vector<uint32_t> code;
-	const char* debugName = nullptr;
-};
-
 class AccelerationStructureBuilder
 {
 public:
@@ -264,7 +251,7 @@ public:
 
 	ComputePipelineBuilder& Cache(VulkanPipelineCache* cache);
 	ComputePipelineBuilder& Layout(VulkanPipelineLayout *layout);
-	ComputePipelineBuilder& ComputeShader(VulkanShader *shader);
+	ComputePipelineBuilder& ComputeShader(std::vector<uint32_t> spirv) { computeShader = std::move(spirv); return *this; }
 	ComputePipelineBuilder& DebugName(const char* name) { debugName = name; return *this; }
 
 	std::unique_ptr<VulkanPipeline> Create(VulkanDevice *device);
@@ -272,6 +259,7 @@ public:
 private:
 	VkComputePipelineCreateInfo pipelineInfo = {};
 	VkPipelineShaderStageCreateInfo stageInfo = {};
+	std::vector<uint32_t> computeShader;
 	VulkanPipelineCache* cache = nullptr;
 	const char* debugName = nullptr;
 };
@@ -386,8 +374,8 @@ public:
 
 	GraphicsPipelineBuilder& AddColorBlendAttachment(VkPipelineColorBlendAttachmentState state);
 
-	GraphicsPipelineBuilder& AddVertexShader(VulkanShader *shader);
-	GraphicsPipelineBuilder& AddFragmentShader(VulkanShader *shader);
+	GraphicsPipelineBuilder& AddVertexShader(std::vector<uint32_t> spirv);
+	GraphicsPipelineBuilder& AddFragmentShader(std::vector<uint32_t> spirv);
 
 	GraphicsPipelineBuilder& AddConstant(uint32_t constantID, const void* data, size_t size);
 	GraphicsPipelineBuilder& AddConstant(uint32_t constantID, uint32_t value);
@@ -431,6 +419,7 @@ private:
 	std::vector<VkVertexInputAttributeDescription> vertexInputAttributes;
 	std::vector<VkDynamicState> dynamicStates;
 	std::vector<VkPipeline> libraries;
+	std::vector<std::vector<uint32_t>> shaderCode;
 
 	struct ShaderSpecialization
 	{
diff --git a/libraries/ZVulkan/src/vulkanbuilders.cpp b/libraries/ZVulkan/src/vulkanbuilders.cpp
index 684aa9769..35a2208bb 100644
--- a/libraries/ZVulkan/src/vulkanbuilders.cpp
+++ b/libraries/ZVulkan/src/vulkanbuilders.cpp
@@ -205,26 +205,6 @@ std::vector<uint32_t> GLSLCompiler::Compile(uint32_t apiVersion)
 
 /////////////////////////////////////////////////////////////////////////////
 
-std::unique_ptr<VulkanShader> ShaderBuilder::Create(const char* shadername, VulkanDevice* device)
-{
-	VkShaderModuleCreateInfo createInfo = {};
-	createInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
-	createInfo.codeSize = code.size() * sizeof(uint32_t);
-	createInfo.pCode = code.data();
-
-	VkShaderModule shaderModule;
-	VkResult result = vkCreateShaderModule(device->device, &createInfo, nullptr, &shaderModule);
-	if (result != VK_SUCCESS)
-		VulkanError("Could not create vulkan shader module");
-
-	auto obj = std::make_unique<VulkanShader>(device, shaderModule);
-	if (debugName)
-		obj->SetDebugName(debugName);
-	return obj;
-}
-
-/////////////////////////////////////////////////////////////////////////////
-
 CommandPoolBuilder::CommandPoolBuilder()
 {
 }
@@ -627,6 +607,31 @@ std::unique_ptr<VulkanAccelerationStructure> AccelerationStructureBuilder::Creat
 
 /////////////////////////////////////////////////////////////////////////////
 
+static std::unique_ptr<VulkanShader> CreateShaderModule(VulkanDevice* device, const char* debugName, const uint32_t* code, size_t size)
+{
+	// To do:
+	// If we have VK_KHR_maintenance5 enabled or Vulkan 1.4 we can chain
+	// VkShaderModuleCreateInfo to VkPipelineShaderStageCreateInfo instead of
+	// creating this pointless object.
+
+	VkShaderModuleCreateInfo createInfo = {};
+	createInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
+	createInfo.codeSize = size * sizeof(uint32_t);
+	createInfo.pCode = code;
+
+	VkShaderModule shaderModule;
+	VkResult result = vkCreateShaderModule(device->device, &createInfo, nullptr, &shaderModule);
+	if (result != VK_SUCCESS)
+		VulkanError("Could not create vulkan shader module");
+
+	auto obj = std::make_unique<VulkanShader>(device, shaderModule);
+	if (debugName)
+		obj->SetDebugName(debugName);
+	return obj;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+
 ComputePipelineBuilder::ComputePipelineBuilder()
 {
 	pipelineInfo.sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO;
@@ -645,18 +650,14 @@ ComputePipelineBuilder& ComputePipelineBuilder::Layout(VulkanPipelineLayout* lay
 	return *this;
 }
 
-ComputePipelineBuilder& ComputePipelineBuilder::ComputeShader(VulkanShader* shader)
+std::unique_ptr<VulkanPipeline> ComputePipelineBuilder::Create(VulkanDevice* device)
 {
+	auto shader = CreateShaderModule(device, debugName, computeShader.data(), computeShader.size());
 	stageInfo.stage = VK_SHADER_STAGE_COMPUTE_BIT;
 	stageInfo.module = shader->module;
 	stageInfo.pName = "main";
-
 	pipelineInfo.stage = stageInfo;
-	return *this;
-}
 
-std::unique_ptr<VulkanPipeline> ComputePipelineBuilder::Create(VulkanDevice* device)
-{
 	VkPipeline pipeline;
 	vkCreateComputePipelines(device->device, cache ? cache->cache : VK_NULL_HANDLE, 1, &pipelineInfo, nullptr, &pipeline);
 	auto obj = std::make_unique<VulkanPipeline>(device, pipeline);
@@ -1087,31 +1088,25 @@ GraphicsPipelineBuilder& GraphicsPipelineBuilder::AddColorBlendAttachment(VkPipe
 	return *this;
 }
 
-GraphicsPipelineBuilder& GraphicsPipelineBuilder::AddVertexShader(VulkanShader* shader)
+GraphicsPipelineBuilder& GraphicsPipelineBuilder::AddVertexShader(std::vector<uint32_t> spirv)
 {
 	VkPipelineShaderStageCreateInfo vertShaderStageInfo = {};
 	vertShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
 	vertShaderStageInfo.stage = VK_SHADER_STAGE_VERTEX_BIT;
-	vertShaderStageInfo.module = shader->module;
 	vertShaderStageInfo.pName = "main";
 	shaderStages.push_back(vertShaderStageInfo);
-
-	pipelineInfo.stageCount = (uint32_t)shaderStages.size();
-	pipelineInfo.pStages = shaderStages.data();
+	shaderCode.push_back(std::move(spirv));
 	return *this;
 }
 
-GraphicsPipelineBuilder& GraphicsPipelineBuilder::AddFragmentShader(VulkanShader* shader)
+GraphicsPipelineBuilder& GraphicsPipelineBuilder::AddFragmentShader(std::vector<uint32_t> spirv)
 {
 	VkPipelineShaderStageCreateInfo fragShaderStageInfo = {};
 	fragShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
 	fragShaderStageInfo.stage = VK_SHADER_STAGE_FRAGMENT_BIT;
-	fragShaderStageInfo.module = shader->module;
 	fragShaderStageInfo.pName = "main";
 	shaderStages.push_back(fragShaderStageInfo);
-
-	pipelineInfo.stageCount = (uint32_t)shaderStages.size();
-	pipelineInfo.pStages = shaderStages.data();
+	shaderCode.push_back(std::move(spirv));
 	return *this;
 }
 
@@ -1208,6 +1203,17 @@ std::unique_ptr<VulkanPipeline> GraphicsPipelineBuilder::Create(VulkanDevice* de
 		libraryCreate.pLibraries = libraries.data();
 	}
 
+	std::vector<std::unique_ptr<VulkanShader>> shaders;
+	shaders.reserve(shaderStages.size());
+	for (size_t i = 0; i < shaderStages.size(); i++)
+	{
+		auto shader = CreateShaderModule(device, debugName, shaderCode[i].data(), shaderCode[i].size());
+		shaderStages[i].module = shader->module;
+		shaders.push_back(std::move(shader));
+	}
+	pipelineInfo.stageCount = (uint32_t)shaderStages.size();
+	pipelineInfo.pStages = shaderStages.data();
+
 	const void** ppNext = &pipelineInfo.pNext;
 
 	if (libraryCreate.libraryCount > 0 && device->SupportsExtension(VK_KHR_PIPELINE_LIBRARY_EXTENSION_NAME))
diff --git a/src/common/rendering/vulkan/commands/vk_commandbuffer.h b/src/common/rendering/vulkan/commands/vk_commandbuffer.h
index e3c5cb3b6..a2f1f0ed2 100644
--- a/src/common/rendering/vulkan/commands/vk_commandbuffer.h
+++ b/src/common/rendering/vulkan/commands/vk_commandbuffer.h
@@ -40,7 +40,6 @@ public:
 		std::vector<std::unique_ptr<VulkanAccelerationStructure>> AccelStructs;
 		std::vector<std::unique_ptr<VulkanDescriptorPool>> DescriptorPools;
 		std::vector<std::unique_ptr<VulkanDescriptorSet>> Descriptors;
-		std::vector<std::unique_ptr<VulkanShader>> Shaders;
 		std::vector<std::unique_ptr<VulkanCommandBuffer>> CommandBuffers;
 		size_t TotalSize = 0;
 
@@ -53,7 +52,6 @@ public:
 		void Add(std::unique_ptr<VulkanDescriptorPool> obj) { if (obj) { DescriptorPools.push_back(std::move(obj)); } }
 		void Add(std::unique_ptr<VulkanDescriptorSet> obj) { if (obj) { Descriptors.push_back(std::move(obj)); } }
 		void Add(std::unique_ptr<VulkanCommandBuffer> obj) { if (obj) { CommandBuffers.push_back(std::move(obj)); } }
-		void Add(std::unique_ptr<VulkanShader> obj) { if (obj) { Shaders.push_back(std::move(obj)); } }
 	};
 
 	std::unique_ptr<DeleteList> TransferDeleteList = std::make_unique<DeleteList>();
diff --git a/src/common/rendering/vulkan/pipelines/vk_pprenderpass.cpp b/src/common/rendering/vulkan/pipelines/vk_pprenderpass.cpp
index 7da074e23..f50501558 100644
--- a/src/common/rendering/vulkan/pipelines/vk_pprenderpass.cpp
+++ b/src/common/rendering/vulkan/pipelines/vk_pprenderpass.cpp
@@ -64,8 +64,8 @@ void VkPPRenderPassSetup::CreatePipeline(const VkPPRenderPassKey& key)
 {
 	GraphicsPipelineBuilder builder;
 	builder.Cache(fb->GetRenderPassManager()->GetCache());
-	builder.AddVertexShader(key.Shader->VertexShader.get());
-	builder.AddFragmentShader(key.Shader->FragmentShader.get());
+	builder.AddVertexShader(key.Shader->VertexShader);
+	builder.AddFragmentShader(key.Shader->FragmentShader);
 
 	builder.AddDynamicState(VK_DYNAMIC_STATE_VIEWPORT);
 	builder.AddDynamicState(VK_DYNAMIC_STATE_SCISSOR);
diff --git a/src/common/rendering/vulkan/pipelines/vk_renderpass.cpp b/src/common/rendering/vulkan/pipelines/vk_renderpass.cpp
index 8046414cf..66b007209 100644
--- a/src/common/rendering/vulkan/pipelines/vk_renderpass.cpp
+++ b/src/common/rendering/vulkan/pipelines/vk_renderpass.cpp
@@ -875,7 +875,7 @@ void VkRenderPassSetup::AddVertexInputInterface(GraphicsPipelineBuilder& builder
 void VkRenderPassSetup::AddPreRasterizationShaders(GraphicsPipelineBuilder& builder, const VkPipelineKey& key, VkShaderProgram* program)
 {
 	builder.PolygonMode(key.DrawLine ? VK_POLYGON_MODE_LINE : VK_POLYGON_MODE_FILL);
-	builder.AddVertexShader(program->vert.get());
+	builder.AddVertexShader(program->vert);
 	builder.AddConstant(0, (uint32_t)key.ShaderKey.AsQWORD);
 	builder.AddConstant(1, (uint32_t)(key.ShaderKey.AsQWORD >> 32));
 
@@ -890,9 +890,9 @@ void VkRenderPassSetup::AddPreRasterizationShaders(GraphicsPipelineBuilder& buil
 
 void VkRenderPassSetup::AddFragmentShader(GraphicsPipelineBuilder& builder, const VkPipelineKey& key, VkShaderProgram* program)
 {
-	if (program->frag)
+	if (!program->frag.empty())
 	{
-		builder.AddFragmentShader(program->frag.get());
+		builder.AddFragmentShader(program->frag);
 		builder.AddConstant(0, (uint32_t)key.ShaderKey.AsQWORD);
 		builder.AddConstant(1, (uint32_t)(key.ShaderKey.AsQWORD >> 32));
 	}
diff --git a/src/common/rendering/vulkan/shaders/vk_ppshader.cpp b/src/common/rendering/vulkan/shaders/vk_ppshader.cpp
index ec2107782..2e34c7e25 100644
--- a/src/common/rendering/vulkan/shaders/vk_ppshader.cpp
+++ b/src/common/rendering/vulkan/shaders/vk_ppshader.cpp
@@ -35,25 +35,19 @@ VkPPShader::VkPPShader(VulkanRenderDevice* fb, PPShader *shader) : fb(fb)
 		prolog = CreateUniformBlockDecl("Uniforms", shader->Uniforms, -1);
 	prolog += shader->Defines;
 
-	VertexShader = ShaderBuilder()
-		.Code(GLSLCompiler()
-			.Type(ShaderType::Vertex)
-			.AddSource(shader->VertexShader.GetChars(), LoadShaderCode(shader->VertexShader, "", shader->Version).GetChars())
-			.OnIncludeLocal([=](std::string headerName, std::string includerName, size_t depth) { return OnInclude(headerName.c_str(), includerName.c_str(), depth, false); })
-			.OnIncludeSystem([=](std::string headerName, std::string includerName, size_t depth) { return OnInclude(headerName.c_str(), includerName.c_str(), depth, true); })
-			.Compile(fb->GetDevice()))
-		.DebugName(shader->VertexShader.GetChars())
-		.Create(shader->VertexShader.GetChars(), fb->GetDevice());
+	VertexShader = GLSLCompiler()
+		.Type(ShaderType::Vertex)
+		.AddSource(shader->VertexShader.GetChars(), LoadShaderCode(shader->VertexShader, "", shader->Version).GetChars())
+		.OnIncludeLocal([=](std::string headerName, std::string includerName, size_t depth) { return OnInclude(headerName.c_str(), includerName.c_str(), depth, false); })
+		.OnIncludeSystem([=](std::string headerName, std::string includerName, size_t depth) { return OnInclude(headerName.c_str(), includerName.c_str(), depth, true); })
+		.Compile(fb->GetDevice());
 
-	FragmentShader = ShaderBuilder()
-		.Code(GLSLCompiler()
-			.Type(ShaderType::Fragment)
-			.AddSource(shader->FragmentShader.GetChars(), LoadShaderCode(shader->FragmentShader, prolog, shader->Version).GetChars())
-			.OnIncludeLocal([=](std::string headerName, std::string includerName, size_t depth) { return OnInclude(headerName.c_str(), includerName.c_str(), depth, false); })
-			.OnIncludeSystem([=](std::string headerName, std::string includerName, size_t depth) { return OnInclude(headerName.c_str(), includerName.c_str(), depth, true); })
-			.Compile(fb->GetDevice()))
-		.DebugName(shader->FragmentShader.GetChars())
-		.Create(shader->FragmentShader.GetChars(), fb->GetDevice());
+	FragmentShader = GLSLCompiler()
+		.Type(ShaderType::Fragment)
+		.AddSource(shader->FragmentShader.GetChars(), LoadShaderCode(shader->FragmentShader, prolog, shader->Version).GetChars())
+		.OnIncludeLocal([=](std::string headerName, std::string includerName, size_t depth) { return OnInclude(headerName.c_str(), includerName.c_str(), depth, false); })
+		.OnIncludeSystem([=](std::string headerName, std::string includerName, size_t depth) { return OnInclude(headerName.c_str(), includerName.c_str(), depth, true); })
+		.Compile(fb->GetDevice());
 
 	fb->GetShaderManager()->AddVkPPShader(this);
 }
@@ -64,15 +58,6 @@ VkPPShader::~VkPPShader()
 		fb->GetShaderManager()->RemoveVkPPShader(this);
 }
 
-void VkPPShader::Reset()
-{
-	if (fb)
-	{
-		fb->GetCommands()->DrawDeleteList->Add(std::move(VertexShader));
-		fb->GetCommands()->DrawDeleteList->Add(std::move(FragmentShader));
-	}
-}
-
 ShaderIncludeResult VkPPShader::OnInclude(FString headerName, FString includerName, size_t depth, bool system)
 {
 	if (depth > 8)
diff --git a/src/common/rendering/vulkan/shaders/vk_ppshader.h b/src/common/rendering/vulkan/shaders/vk_ppshader.h
index e1d22457a..57cb722b9 100644
--- a/src/common/rendering/vulkan/shaders/vk_ppshader.h
+++ b/src/common/rendering/vulkan/shaders/vk_ppshader.h
@@ -14,13 +14,11 @@ public:
 	VkPPShader(VulkanRenderDevice* fb, PPShader *shader);
 	~VkPPShader();
 
-	void Reset();
-
 	VulkanRenderDevice* fb = nullptr;
 	std::list<VkPPShader*>::iterator it;
 
-	std::unique_ptr<VulkanShader> VertexShader;
-	std::unique_ptr<VulkanShader> FragmentShader;
+	std::vector<uint32_t> VertexShader;
+	std::vector<uint32_t> FragmentShader;
 
 private:
 	FString LoadShaderCode(const FString &lumpname, const FString &defines, int version);
diff --git a/src/common/rendering/vulkan/shaders/vk_shader.cpp b/src/common/rendering/vulkan/shaders/vk_shader.cpp
index 9e833bb21..6d2d14aab 100644
--- a/src/common/rendering/vulkan/shaders/vk_shader.cpp
+++ b/src/common/rendering/vulkan/shaders/vk_shader.cpp
@@ -34,51 +34,36 @@
 
 VkShaderManager::VkShaderManager(VulkanRenderDevice* fb) : fb(fb)
 {
-	ZMinMax.vert = ShaderBuilder()
-		.Code(CachedGLSLCompiler()
-			.Type(ShaderType::Vertex)
-			.AddSource("VersionBlock", GetVersionBlock().GetChars())
-			.AddSource("shaders/scene/vert_zminmax.glsl", LoadPrivateShaderLump("shaders/scene/vert_zminmax.glsl").GetChars())
-			.Compile(fb))
-		.DebugName("ZMinMax.vert")
-		.Create("ZMinMax.vert", fb->GetDevice());
+	ZMinMax.vert = CachedGLSLCompiler()
+		.Type(ShaderType::Vertex)
+		.AddSource("VersionBlock", GetVersionBlock().GetChars())
+		.AddSource("shaders/scene/vert_zminmax.glsl", LoadPrivateShaderLump("shaders/scene/vert_zminmax.glsl").GetChars())
+		.Compile(fb);
 
-	ZMinMax.frag[0] = ShaderBuilder()
-		.Code(CachedGLSLCompiler()
-			.Type(ShaderType::Fragment)
-			.AddSource("VersionBlock", GetVersionBlock().GetChars())
-			.AddSource("shaders/scene/frag_zminmax0.glsl", LoadPrivateShaderLump("shaders/scene/frag_zminmax0.glsl").GetChars())
-			.Compile(fb))
-		.DebugName("ZMinMax0.frag")
-		.Create("ZMinMax0.frag", fb->GetDevice());
+	ZMinMax.frag[0] = CachedGLSLCompiler()
+		.Type(ShaderType::Fragment)
+		.AddSource("VersionBlock", GetVersionBlock().GetChars())
+		.AddSource("shaders/scene/frag_zminmax0.glsl", LoadPrivateShaderLump("shaders/scene/frag_zminmax0.glsl").GetChars())
+		.Compile(fb);
 
-	ZMinMax.frag[1] = ShaderBuilder()
-		.Code(CachedGLSLCompiler()
-			.Type(ShaderType::Fragment)
-			.AddSource("VersionBlock", GetVersionBlock().GetChars())
-			.AddSource("DefinesBlock", "#define MULTISAMPLE\n")
-			.AddSource("shaders/scene/frag_zminmax0.glsl", LoadPrivateShaderLump("shaders/scene/frag_zminmax0.glsl").GetChars())
-			.Compile(fb))
-		.DebugName("ZMinMax0.frag")
-		.Create("ZMinMax0.frag", fb->GetDevice());
+	ZMinMax.frag[1] = CachedGLSLCompiler()
+		.Type(ShaderType::Fragment)
+		.AddSource("VersionBlock", GetVersionBlock().GetChars())
+		.AddSource("DefinesBlock", "#define MULTISAMPLE\n")
+		.AddSource("shaders/scene/frag_zminmax0.glsl", LoadPrivateShaderLump("shaders/scene/frag_zminmax0.glsl").GetChars())
+		.Compile(fb);
 
-	ZMinMax.frag[2] = ShaderBuilder()
-		.Code(CachedGLSLCompiler()
-			.Type(ShaderType::Fragment)
-			.AddSource("VersionBlock", GetVersionBlock().GetChars())
-			.AddSource("shaders/scene/frag_zminmax1.glsl", LoadPrivateShaderLump("shaders/scene/frag_zminmax1.glsl").GetChars())
-			.Compile(fb))
-		.DebugName("ZMinMax1.frag")
-		.Create("ZMinMax1.frag", fb->GetDevice());
+	ZMinMax.frag[2] = CachedGLSLCompiler()
+		.Type(ShaderType::Fragment)
+		.AddSource("VersionBlock", GetVersionBlock().GetChars())
+		.AddSource("shaders/scene/frag_zminmax1.glsl", LoadPrivateShaderLump("shaders/scene/frag_zminmax1.glsl").GetChars())
+		.Compile(fb);
 
-	LightTiles = ShaderBuilder()
-		.Code(CachedGLSLCompiler()
-			.Type(ShaderType::Compute)
-			.AddSource("VersionBlock", GetVersionBlock().GetChars())
-			.AddSource("shaders/scene/comp_lighttiles.glsl", LoadPrivateShaderLump("shaders/scene/comp_lighttiles.glsl").GetChars())
-			.Compile(fb))
-		.DebugName("LightTiles.comp")
-		.Create("LightTiles.comp", fb->GetDevice());
+	LightTiles = CachedGLSLCompiler()
+		.Type(ShaderType::Compute)
+		.AddSource("VersionBlock", GetVersionBlock().GetChars())
+		.AddSource("shaders/scene/comp_lighttiles.glsl", LoadPrivateShaderLump("shaders/scene/comp_lighttiles.glsl").GetChars())
+		.Compile(fb);
 }
 
 VkShaderManager::~VkShaderManager()
@@ -94,7 +79,7 @@ void VkShaderManager::Deinit()
 VkShaderProgram* VkShaderManager::Get(const VkShaderKey& key, bool isUberShader)
 {
 	VkShaderProgram& program = isUberShader ? generic[key.GeneralizedShaderKey()] : specialized[key];
-	if (program.frag)
+	if (!program.frag.empty())
 		return &program;
 
 	const char* mainvp = "shaders/scene/vert_main.glsl";
@@ -468,7 +453,7 @@ void VkShaderManager::BuildDefinesBlock(FString &definesBlock, const char *defin
 	}
 }
 
-std::unique_ptr<VulkanShader> VkShaderManager::LoadVertShader(FString shadername, const char *vert_lump, const char *vert_lump_custom, const char *defines, const VkShaderKey& key, const UserShaderDesc *shader, bool isUberShader)
+std::vector<uint32_t> VkShaderManager::LoadVertShader(FString shadername, const char *vert_lump, const char *vert_lump_custom, const char *defines, const VkShaderKey& key, const UserShaderDesc *shader, bool isUberShader)
 {
 	FString definesBlock;
 	BuildDefinesBlock(definesBlock, defines, false, key, shader, isUberShader);
@@ -488,20 +473,17 @@ std::unique_ptr<VulkanShader> VkShaderManager::LoadVertShader(FString shadername
 		codeBlock << LoadPrivateShaderLump("shaders/scene/vert_nocustom.glsl").GetChars() << "\n";
 	}
 
-	return ShaderBuilder()
-		.Code(CachedGLSLCompiler()
-			.Type(ShaderType::Vertex)
-			.AddSource("VersionBlock", GetVersionBlock().GetChars())
-			.AddSource("DefinesBlock", definesBlock.GetChars())
-			.AddSource("LayoutBlock", layoutBlock.GetChars())
-			.AddSource("shaders/scene/layout_shared.glsl", LoadPrivateShaderLump("shaders/scene/layout_shared.glsl").GetChars())
-			.AddSource(vert_lump_custom ? vert_lump_custom : vert_lump, codeBlock.GetChars())
-			.Compile(fb))
-		.DebugName(shadername.GetChars())
-		.Create(shadername.GetChars(), fb->GetDevice());
+	return CachedGLSLCompiler()
+		.Type(ShaderType::Vertex)
+		.AddSource("VersionBlock", GetVersionBlock().GetChars())
+		.AddSource("DefinesBlock", definesBlock.GetChars())
+		.AddSource("LayoutBlock", layoutBlock.GetChars())
+		.AddSource("shaders/scene/layout_shared.glsl", LoadPrivateShaderLump("shaders/scene/layout_shared.glsl").GetChars())
+		.AddSource(vert_lump_custom ? vert_lump_custom : vert_lump, codeBlock.GetChars())
+		.Compile(fb);
 }
 
-std::unique_ptr<VulkanShader> VkShaderManager::LoadFragShader(FString shadername, const char *frag_lump, const char *material_lump, const char* mateffect_lump, const char *light_lump_shared, const char *light_lump, const char *defines, const VkShaderKey& key, const UserShaderDesc *shader, bool isUberShader)
+std::vector<uint32_t> VkShaderManager::LoadFragShader(FString shadername, const char *frag_lump, const char *material_lump, const char* mateffect_lump, const char *light_lump_shared, const char *light_lump, const char *defines, const VkShaderKey& key, const UserShaderDesc *shader, bool isUberShader)
 {
 	FString definesBlock;
 	BuildDefinesBlock(definesBlock, defines, true, key, shader, isUberShader);
@@ -587,21 +569,18 @@ std::unique_ptr<VulkanShader> VkShaderManager::LoadFragShader(FString shadername
 		mateffectBlock << LoadPrivateShaderLump(mateffect_lump).GetChars();
 	}
 
-	return ShaderBuilder()
-		.Code(CachedGLSLCompiler()
-			.Type(ShaderType::Fragment)
-			.AddSource("VersionBlock", GetVersionBlock().GetChars())
-			.AddSource("DefinesBlock", definesBlock.GetChars())
-			.AddSource("LayoutBlock", layoutBlock.GetChars())
-			.AddSource("shaders/scene/layout_shared.glsl", LoadPrivateShaderLump("shaders/scene/layout_shared.glsl").GetChars())
-			.AddSource("shaders/scene/includes.glsl", LoadPrivateShaderLump("shaders/scene/includes.glsl").GetChars())
-			.AddSource(mateffectname.GetChars(), mateffectBlock.GetChars())
-			.AddSource(materialname.GetChars(), materialBlock.GetChars())
-			.AddSource(lightname.GetChars(), lightBlock.GetChars())
-			.AddSource(frag_lump, codeBlock.GetChars())
-			.Compile(fb))
-		.DebugName(shadername.GetChars())
-		.Create(shadername.GetChars(), fb->GetDevice());
+	return CachedGLSLCompiler()
+		.Type(ShaderType::Fragment)
+		.AddSource("VersionBlock", GetVersionBlock().GetChars())
+		.AddSource("DefinesBlock", definesBlock.GetChars())
+		.AddSource("LayoutBlock", layoutBlock.GetChars())
+		.AddSource("shaders/scene/layout_shared.glsl", LoadPrivateShaderLump("shaders/scene/layout_shared.glsl").GetChars())
+		.AddSource("shaders/scene/includes.glsl", LoadPrivateShaderLump("shaders/scene/includes.glsl").GetChars())
+		.AddSource(mateffectname.GetChars(), mateffectBlock.GetChars())
+		.AddSource(materialname.GetChars(), materialBlock.GetChars())
+		.AddSource(lightname.GetChars(), lightBlock.GetChars())
+		.AddSource(frag_lump, codeBlock.GetChars())
+		.Compile(fb);
 }
 
 FString VkShaderManager::GetVersionBlock()
@@ -652,7 +631,6 @@ void VkShaderManager::AddVkPPShader(VkPPShader* shader)
 
 void VkShaderManager::RemoveVkPPShader(VkPPShader* shader)
 {
-	shader->Reset();
 	shader->fb = nullptr;
 	PPShaders.erase(shader->it);
 }
diff --git a/src/common/rendering/vulkan/shaders/vk_shader.h b/src/common/rendering/vulkan/shaders/vk_shader.h
index b50f2af4a..1abc1e905 100644
--- a/src/common/rendering/vulkan/shaders/vk_shader.h
+++ b/src/common/rendering/vulkan/shaders/vk_shader.h
@@ -154,8 +154,8 @@ static_assert(sizeof(VkShaderKey) == 24, "sizeof(VkShaderKey) is not its expecte
 class VkShaderProgram
 {
 public:
-	std::unique_ptr<VulkanShader> vert;
-	std::unique_ptr<VulkanShader> frag;
+	std::vector<uint32_t> vert;
+	std::vector<uint32_t> frag;
 
 	UniformStructHolder Uniforms;
 };
@@ -177,13 +177,13 @@ public:
 	void AddVkPPShader(VkPPShader* shader);
 	void RemoveVkPPShader(VkPPShader* shader);
 
-	VulkanShader* GetZMinMaxVertexShader() { return ZMinMax.vert.get(); }
-	VulkanShader* GetZMinMaxFragmentShader(int index) { return ZMinMax.frag[index].get(); }
-	VulkanShader* GetLightTilesShader() { return LightTiles.get(); }
+	const std::vector<uint32_t>& GetZMinMaxVertexShader() const { return ZMinMax.vert; }
+	const std::vector<uint32_t>& GetZMinMaxFragmentShader(int index) const { return ZMinMax.frag[index]; }
+	const std::vector<uint32_t>& GetLightTilesShader() const { return LightTiles; }
 
 private:
-	std::unique_ptr<VulkanShader> LoadVertShader(FString shadername, const char *vert_lump, const char *vert_lump_custom, const char *defines, const VkShaderKey& key, const UserShaderDesc *shader, bool isUberShader);
-	std::unique_ptr<VulkanShader> LoadFragShader(FString shadername, const char *frag_lump, const char *material_lump, const char* mateffect_lump, const char *light_lump_shared, const char *lightmodel_lump, const char *defines, const VkShaderKey& key, const UserShaderDesc *shader, bool isUberShader);
+	std::vector<uint32_t> LoadVertShader(FString shadername, const char *vert_lump, const char *vert_lump_custom, const char *defines, const VkShaderKey& key, const UserShaderDesc *shader, bool isUberShader);
+	std::vector<uint32_t> LoadFragShader(FString shadername, const char *frag_lump, const char *material_lump, const char* mateffect_lump, const char *light_lump_shared, const char *lightmodel_lump, const char *defines, const VkShaderKey& key, const UserShaderDesc *shader, bool isUberShader);
 
 	FString GetVersionBlock();
 	FString LoadPublicShaderLump(const char *lumpname);
@@ -201,9 +201,9 @@ private:
 
 	struct
 	{
-		std::unique_ptr<VulkanShader> vert;
-		std::unique_ptr<VulkanShader> frag[3];
+		std::vector<uint32_t> vert;
+		std::vector<uint32_t> frag[3];
 	} ZMinMax;
 
-	std::unique_ptr<VulkanShader> LightTiles;
+	std::vector<uint32_t> LightTiles;
 };
diff --git a/src/common/rendering/vulkan/vk_levelmesh.cpp b/src/common/rendering/vulkan/vk_levelmesh.cpp
index b6012f981..d1fce2bfa 100644
--- a/src/common/rendering/vulkan/vk_levelmesh.cpp
+++ b/src/common/rendering/vulkan/vk_levelmesh.cpp
@@ -504,8 +504,8 @@ void VkLevelMesh::RaytraceScene(const VkRenderPassKey& renderPassKey, VulkanComm
 		builder.RenderPass(fb->GetRenderPassManager()->GetRenderPass(renderPassKey)->GetRenderPass(0));
 		builder.Layout(Viewer.PipelineLayout.get());
 		builder.Topology(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP);
-		builder.AddVertexShader(Viewer.VertexShader.get());
-		builder.AddFragmentShader(Viewer.FragmentShader.get());
+		builder.AddVertexShader(Viewer.VertexShader);
+		builder.AddFragmentShader(Viewer.FragmentShader);
 		builder.AddDynamicState(VK_DYNAMIC_STATE_VIEWPORT);
 		builder.AddDynamicState(VK_DYNAMIC_STATE_SCISSOR);
 		builder.RasterizationSamples((VkSampleCountFlagBits)renderPassKey.Samples);
@@ -604,23 +604,17 @@ void VkLevelMesh::CreateViewerObjects()
 		versionBlock += "#define USE_RAYQUERY\r\n";
 	}
 
-	Viewer.VertexShader = ShaderBuilder()
-		.Code(CachedGLSLCompiler()
-			.Type(ShaderType::Vertex)
-			.AddSource("versionblock", versionBlock)
-			.AddSource("vert_viewer.glsl", LoadPrivateShaderLump("shaders/lightmap/vert_viewer.glsl").GetChars())
-			.Compile(fb))
-		.DebugName("Viewer.VertexShader")
-		.Create("vertex", fb->GetDevice());
+	Viewer.VertexShader = CachedGLSLCompiler()
+		.Type(ShaderType::Vertex)
+		.AddSource("versionblock", versionBlock)
+		.AddSource("vert_viewer.glsl", LoadPrivateShaderLump("shaders/lightmap/vert_viewer.glsl").GetChars())
+		.Compile(fb);
 
-	Viewer.FragmentShader = ShaderBuilder()
-		.Code(CachedGLSLCompiler()
-			.Type(ShaderType::Fragment)
-			.AddSource("versionblock", versionBlock)
-			.AddSource("frag_viewer.glsl", LoadPrivateShaderLump("shaders/lightmap/frag_viewer.glsl").GetChars())
-			.Compile(fb))
-		.DebugName("Viewer.FragmentShader")
-		.Create("vertex", fb->GetDevice());
+	Viewer.FragmentShader = CachedGLSLCompiler()
+		.Type(ShaderType::Fragment)
+		.AddSource("versionblock", versionBlock)
+		.AddSource("frag_viewer.glsl", LoadPrivateShaderLump("shaders/lightmap/frag_viewer.glsl").GetChars())
+		.Compile(fb);
 
 	Viewer.PipelineLayout = PipelineLayoutBuilder()
 		.AddSetLayout(Viewer.DescriptorSetLayout.get())
diff --git a/src/common/rendering/vulkan/vk_levelmesh.h b/src/common/rendering/vulkan/vk_levelmesh.h
index bf3d865f6..7b362e322 100644
--- a/src/common/rendering/vulkan/vk_levelmesh.h
+++ b/src/common/rendering/vulkan/vk_levelmesh.h
@@ -160,8 +160,8 @@ private:
 		std::unique_ptr<VulkanDescriptorSetLayout> DescriptorSetLayout;
 		std::unique_ptr<VulkanDescriptorPool> DescriptorPool;
 		std::unique_ptr<VulkanDescriptorSet> DescriptorSet;
-		std::unique_ptr<VulkanShader> VertexShader;
-		std::unique_ptr<VulkanShader> FragmentShader;
+		std::vector<uint32_t> VertexShader;
+		std::vector<uint32_t> FragmentShader;
 		//std::unique_ptr<VulkanRenderPass> RenderPass;
 		std::unique_ptr<VulkanPipelineLayout> PipelineLayout;
 		std::map<VkRenderPassKey, std::unique_ptr<VulkanPipeline>> Pipeline;
diff --git a/src/common/rendering/vulkan/vk_lightmapper.cpp b/src/common/rendering/vulkan/vk_lightmapper.cpp
index faf14a489..eff1c1dcf 100644
--- a/src/common/rendering/vulkan/vk_lightmapper.cpp
+++ b/src/common/rendering/vulkan/vk_lightmapper.cpp
@@ -502,32 +502,23 @@ void VkLightmapper::CreateShaders()
 		traceprefix += "#define USE_RAYQUERY\r\n";
 	}
 
-	shaders.vertRaytrace = ShaderBuilder()
-		.Code(CachedGLSLCompiler()
-			.Type(ShaderType::Vertex)
-			.AddSource("VersionBlock", prefix)
-			.AddSource("vert_raytrace.glsl", LoadPrivateShaderLump("shaders/lightmap/vert_raytrace.glsl").GetChars())
-			.Compile(fb))
-		.DebugName("VkLightmapper.VertRaytrace")
-		.Create("VkLightmapper.VertRaytrace", fb->GetDevice());
+	shaders.vertRaytrace = CachedGLSLCompiler()
+		.Type(ShaderType::Vertex)
+		.AddSource("VersionBlock", prefix)
+		.AddSource("vert_raytrace.glsl", LoadPrivateShaderLump("shaders/lightmap/vert_raytrace.glsl").GetChars())
+		.Compile(fb);
 
-	shaders.vertScreenquad = ShaderBuilder()
-		.Code(CachedGLSLCompiler()
-			.Type(ShaderType::Vertex)
-			.AddSource("VersionBlock", prefix)
-			.AddSource("vert_screenquad.glsl", LoadPrivateShaderLump("shaders/lightmap/vert_screenquad.glsl").GetChars())
-			.Compile(fb))
-		.DebugName("VkLightmapper.VertScreenquad")
-		.Create("VkLightmapper.VertScreenquad", fb->GetDevice());
+	shaders.vertScreenquad = CachedGLSLCompiler()
+		.Type(ShaderType::Vertex)
+		.AddSource("VersionBlock", prefix)
+		.AddSource("vert_screenquad.glsl", LoadPrivateShaderLump("shaders/lightmap/vert_screenquad.glsl").GetChars())
+		.Compile(fb);
 
-	shaders.vertCopy = ShaderBuilder()
-		.Code(CachedGLSLCompiler()
-			.Type(ShaderType::Vertex)
-			.AddSource("VersionBlock", prefix)
-			.AddSource("vert_copy.glsl", LoadPrivateShaderLump("shaders/lightmap/vert_copy.glsl").GetChars())
-			.Compile(fb))
-		.DebugName("VkLightmapper.VertCopy")
-		.Create("VkLightmapper.VertCopy", fb->GetDevice());
+	shaders.vertCopy = CachedGLSLCompiler()
+		.Type(ShaderType::Vertex)
+		.AddSource("VersionBlock", prefix)
+		.AddSource("vert_copy.glsl", LoadPrivateShaderLump("shaders/lightmap/vert_copy.glsl").GetChars())
+		.Compile(fb);
 
 	for (int i = 0; i < 16; i++)
 	{
@@ -541,51 +532,36 @@ void VkLightmapper::CreateShaders()
 		if (i & 8)
 			defines += "#define USE_BOUNCE\n";
 
-		shaders.fragRaytrace[i] = ShaderBuilder()
-			.Code(CachedGLSLCompiler()
-				.Type(ShaderType::Fragment)
-				.AddSource("VersionBlock", defines)
-				.AddSource("frag_raytrace.glsl", LoadPrivateShaderLump("shaders/lightmap/frag_raytrace.glsl").GetChars())
-				.Compile(fb))
-			.DebugName("VkLightmapper.FragRaytrace")
-			.Create("VkLightmapper.FragRaytrace", fb->GetDevice());
+		shaders.fragRaytrace[i] = CachedGLSLCompiler()
+			.Type(ShaderType::Fragment)
+			.AddSource("VersionBlock", defines)
+			.AddSource("frag_raytrace.glsl", LoadPrivateShaderLump("shaders/lightmap/frag_raytrace.glsl").GetChars())
+			.Compile(fb);
 	}
 
-	shaders.fragResolve = ShaderBuilder()
-		.Code(CachedGLSLCompiler()
-			.Type(ShaderType::Fragment)
-			.AddSource("VersionBlock", prefix)
-			.AddSource("frag_resolve.glsl", LoadPrivateShaderLump("shaders/lightmap/frag_resolve.glsl").GetChars())
-			.Compile(fb))
-		.DebugName("VkLightmapper.FragResolve")
-		.Create("VkLightmapper.FragResolve", fb->GetDevice());
+	shaders.fragResolve = CachedGLSLCompiler()
+		.Type(ShaderType::Fragment)
+		.AddSource("VersionBlock", prefix)
+		.AddSource("frag_resolve.glsl", LoadPrivateShaderLump("shaders/lightmap/frag_resolve.glsl").GetChars())
+		.Compile(fb);
 
-	shaders.fragBlur[0] = ShaderBuilder()
-		.Code(CachedGLSLCompiler()
-			.Type(ShaderType::Fragment)
-			.AddSource("VersionBlock", prefix + "#define BLUR_HORIZONTAL\r\n")
-			.AddSource("frag_blur.glsl", LoadPrivateShaderLump("shaders/lightmap/frag_blur.glsl").GetChars())
-			.Compile(fb))
-		.DebugName("VkLightmapper.FragBlur")
-		.Create("VkLightmapper.FragBlur", fb->GetDevice());
+	shaders.fragBlur[0] = CachedGLSLCompiler()
+		.Type(ShaderType::Fragment)
+		.AddSource("VersionBlock", prefix + "#define BLUR_HORIZONTAL\r\n")
+		.AddSource("frag_blur.glsl", LoadPrivateShaderLump("shaders/lightmap/frag_blur.glsl").GetChars())
+		.Compile(fb);
 
-	shaders.fragBlur[1] = ShaderBuilder()
-		.Code(CachedGLSLCompiler()
-			.Type(ShaderType::Fragment)
-			.AddSource("VersionBlock", prefix + "#define BLUR_VERTICAL\r\n")
-			.AddSource("frag_blur.glsl", LoadPrivateShaderLump("shaders/lightmap/frag_blur.glsl").GetChars())
-			.Compile(fb))
-		.DebugName("VkLightmapper.FragBlur")
-		.Create("VkLightmapper.FragBlur", fb->GetDevice());
+	shaders.fragBlur[1] = CachedGLSLCompiler()
+		.Type(ShaderType::Fragment)
+		.AddSource("VersionBlock", prefix + "#define BLUR_VERTICAL\r\n")
+		.AddSource("frag_blur.glsl", LoadPrivateShaderLump("shaders/lightmap/frag_blur.glsl").GetChars())
+		.Compile(fb);
 
-	shaders.fragCopy = ShaderBuilder()
-		.Code(CachedGLSLCompiler()
-			.Type(ShaderType::Fragment)
-			.AddSource("VersionBlock", prefix)
-			.AddSource("frag_copy.glsl", LoadPrivateShaderLump("shaders/lightmap/frag_copy.glsl").GetChars())
-			.Compile(fb))
-		.DebugName("VkLightmapper.FragCopy")
-		.Create("VkLightmapper.FragCopy", fb->GetDevice());
+	shaders.fragCopy = CachedGLSLCompiler()
+		.Type(ShaderType::Fragment)
+		.AddSource("VersionBlock", prefix)
+		.AddSource("frag_copy.glsl", LoadPrivateShaderLump("shaders/lightmap/frag_copy.glsl").GetChars())
+		.Compile(fb);
 }
 
 int VkLightmapper::GetRaytracePipelineIndex()
@@ -680,8 +656,8 @@ void VkLightmapper::CreateRaytracePipeline()
 		raytrace.pipeline[i] = GraphicsPipelineBuilder()
 			.Layout(raytrace.pipelineLayout.get())
 			.RenderPass(raytrace.renderPass.get())
-			.AddVertexShader(shaders.vertRaytrace.get())
-			.AddFragmentShader(shaders.fragRaytrace[i].get())
+			.AddVertexShader(shaders.vertRaytrace)
+			.AddFragmentShader(shaders.fragRaytrace[i])
 			.AddVertexBufferBinding(0, sizeof(FFlatVertex))
 			.AddVertexAttribute(0, 0, VK_FORMAT_R32G32B32A32_SFLOAT, 0)
 			.Topology(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST)
@@ -788,8 +764,8 @@ void VkLightmapper::CreateResolvePipeline()
 	resolve.pipeline = GraphicsPipelineBuilder()
 		.Layout(resolve.pipelineLayout.get())
 		.RenderPass(resolve.renderPass.get())
-		.AddVertexShader(shaders.vertScreenquad.get())
-		.AddFragmentShader(shaders.fragResolve.get())
+		.AddVertexShader(shaders.vertScreenquad)
+		.AddFragmentShader(shaders.fragResolve)
 		.Topology(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST)
 		.AddDynamicState(VK_DYNAMIC_STATE_VIEWPORT)
 		.Viewport(0.0f, 0.0f, 0.0f, 0.0f)
@@ -843,8 +819,8 @@ void VkLightmapper::CreateBlurPipeline()
 		blur.pipeline[i] = GraphicsPipelineBuilder()
 			.Layout(blur.pipelineLayout.get())
 			.RenderPass(blur.renderPass.get())
-			.AddVertexShader(shaders.vertScreenquad.get())
-			.AddFragmentShader(shaders.fragBlur[i].get())
+			.AddVertexShader(shaders.vertScreenquad)
+			.AddFragmentShader(shaders.fragBlur[i])
 			.Topology(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST)
 			.AddDynamicState(VK_DYNAMIC_STATE_VIEWPORT)
 			.Viewport(0.0f, 0.0f, 0.0f, 0.0f)
@@ -902,8 +878,8 @@ void VkLightmapper::CreateCopyPipeline()
 	copy.pipeline = GraphicsPipelineBuilder()
 		.Layout(copy.pipelineLayout.get())
 		.RenderPass(copy.renderPass.get())
-		.AddVertexShader(shaders.vertCopy.get())
-		.AddFragmentShader(shaders.fragCopy.get())
+		.AddVertexShader(shaders.vertCopy)
+		.AddFragmentShader(shaders.fragCopy)
 		.Topology(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP)
 		.AddDynamicState(VK_DYNAMIC_STATE_VIEWPORT)
 		.Viewport(0.0f, 0.0f, 0.0f, 0.0f)
diff --git a/src/common/rendering/vulkan/vk_lightmapper.h b/src/common/rendering/vulkan/vk_lightmapper.h
index 8060b7398..01fea04ef 100644
--- a/src/common/rendering/vulkan/vk_lightmapper.h
+++ b/src/common/rendering/vulkan/vk_lightmapper.h
@@ -177,13 +177,13 @@ private:
 
 	struct
 	{
-		std::unique_ptr<VulkanShader> vertRaytrace;
-		std::unique_ptr<VulkanShader> vertScreenquad;
-		std::unique_ptr<VulkanShader> vertCopy;
-		std::unique_ptr<VulkanShader> fragRaytrace[16];
-		std::unique_ptr<VulkanShader> fragResolve;
-		std::unique_ptr<VulkanShader> fragBlur[2];
-		std::unique_ptr<VulkanShader> fragCopy;
+		std::vector<uint32_t> vertRaytrace;
+		std::vector<uint32_t> vertScreenquad;
+		std::vector<uint32_t> vertCopy;
+		std::vector<uint32_t> fragRaytrace[16];
+		std::vector<uint32_t> fragResolve;
+		std::vector<uint32_t> fragBlur[2];
+		std::vector<uint32_t> fragCopy;
 	} shaders;
 
 	struct
diff --git a/src/common/rendering/vulkan/vk_lightprober.cpp b/src/common/rendering/vulkan/vk_lightprober.cpp
index b142ba1af..e9a2be50a 100644
--- a/src/common/rendering/vulkan/vk_lightprober.cpp
+++ b/src/common/rendering/vulkan/vk_lightprober.cpp
@@ -23,8 +23,6 @@ VkLightprober::~VkLightprober()
 
 void VkLightprober::CreateBrdfLutResources()
 {
-	brdfLut.shader = CompileShader("comp_brdf_convolute.glsl", "shaders/lightprobe/comp_brdf_convolute.glsl", "VkLightprober.BrdfLut");
-
 	brdfLut.descriptorSetLayout = DescriptorSetLayoutBuilder()
 		.AddBinding(0, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1, VK_SHADER_STAGE_COMPUTE_BIT)
 		.Create(fb->GetDevice());
@@ -34,7 +32,7 @@ void VkLightprober::CreateBrdfLutResources()
 		.Create(fb->GetDevice());
 
 	brdfLut.pipeline = ComputePipelineBuilder()
-		.ComputeShader(brdfLut.shader.get())
+		.ComputeShader(CompileShader("shaders/lightprobe/comp_brdf_convolute.glsl"))
 		.Layout(brdfLut.pipelineLayout.get())
 		.Create(fb->GetDevice());
 
@@ -209,8 +207,6 @@ void VkLightprober::RenderEnvironmentMap(std::function<void(IntRect&, int)> rend
 
 void VkLightprober::CreateIrradianceMap()
 {
-	irradianceMap.shader = CompileShader("comp_irradiance_convolute.glsl", "shaders/lightprobe/comp_irradiance_convolute.glsl", "VkLightprober.IrradianceMap");
-
 	irradianceMap.descriptorSetLayout = DescriptorSetLayoutBuilder()
 		.AddBinding(0, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1, VK_SHADER_STAGE_COMPUTE_BIT)
 		.AddBinding(1, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, VK_SHADER_STAGE_COMPUTE_BIT)
@@ -227,7 +223,7 @@ void VkLightprober::CreateIrradianceMap()
 		.Create(fb->GetDevice());
 
 	irradianceMap.pipeline = ComputePipelineBuilder()
-		.ComputeShader(irradianceMap.shader.get())
+		.ComputeShader(CompileShader("shaders/lightprobe/comp_irradiance_convolute.glsl"))
 		.Layout(irradianceMap.pipelineLayout.get())
 		.Create(fb->GetDevice());
 
@@ -356,8 +352,6 @@ bool VkLightprober::GenerateIrradianceMap(TArrayView<uint16_t>& databuffer)
 
 void VkLightprober::CreatePrefilterMap()
 {
-	prefilterMap.shader = CompileShader("comp_prefilter_convolute.glsl", "shaders/lightprobe/comp_prefilter_convolute.glsl", "VkLightprober.PrefilterMap");
-
 	prefilterMap.descriptorSetLayout = DescriptorSetLayoutBuilder()
 		.AddBinding(0, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1, VK_SHADER_STAGE_COMPUTE_BIT)
 		.AddBinding(1, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, VK_SHADER_STAGE_COMPUTE_BIT)
@@ -369,7 +363,7 @@ void VkLightprober::CreatePrefilterMap()
 		.Create(fb->GetDevice());
 
 	prefilterMap.pipeline = ComputePipelineBuilder()
-		.ComputeShader(prefilterMap.shader.get())
+		.ComputeShader(CompileShader("shaders/lightprobe/comp_prefilter_convolute.glsl"))
 		.Layout(prefilterMap.pipelineLayout.get())
 		.Create(fb->GetDevice());
 
@@ -509,7 +503,7 @@ bool VkLightprober::GeneratePrefilterMap(TArrayView<uint16_t>& databuffer)
 	return true;
 }
 
-std::unique_ptr<VulkanShader> VkLightprober::CompileShader(const std::string& name, const std::string& filename, const char* debugName)
+std::vector<uint32_t> VkLightprober::CompileShader(const std::string& filename)
 {
 	std::string prefix = "#version 460\r\n";
 	prefix += "#extension GL_GOOGLE_include_directive : enable\n";
@@ -518,16 +512,13 @@ std::unique_ptr<VulkanShader> VkLightprober::CompileShader(const std::string& na
 	auto onIncludeLocal = [](std::string headerName, std::string includerName, size_t depth) { return OnInclude(headerName.c_str(), includerName.c_str(), depth, false); };
 	auto onIncludeSystem = [](std::string headerName, std::string includerName, size_t depth) { return OnInclude(headerName.c_str(), includerName.c_str(), depth, true); };
 
-	return ShaderBuilder()
-		.Code(GLSLCompiler()
-			.Type(ShaderType::Compute)
-			.AddSource("VersionBlock", prefix)
-			.AddSource(name, LoadPrivateShaderLump(filename.c_str()).GetChars())
-			.OnIncludeLocal(onIncludeLocal)
-			.OnIncludeSystem(onIncludeSystem)
-			.Compile(fb->GetDevice()))
-		.DebugName(debugName)
-		.Create(debugName, fb->GetDevice());
+	return GLSLCompiler()
+		.Type(ShaderType::Compute)
+		.AddSource("VersionBlock", prefix)
+		.AddSource(filename, LoadPrivateShaderLump(filename.c_str()).GetChars())
+		.OnIncludeLocal(onIncludeLocal)
+		.OnIncludeSystem(onIncludeSystem)
+		.Compile(fb->GetDevice());
 }
 
 FString VkLightprober::LoadPrivateShaderLump(const char* lumpname)
diff --git a/src/common/rendering/vulkan/vk_lightprober.h b/src/common/rendering/vulkan/vk_lightprober.h
index 69c3e74b5..eb3abbdb4 100644
--- a/src/common/rendering/vulkan/vk_lightprober.h
+++ b/src/common/rendering/vulkan/vk_lightprober.h
@@ -45,7 +45,7 @@ private:
 	void CreatePrefilterMap();
 	void GenerateBrdfLut();
 
-	std::unique_ptr<VulkanShader> CompileShader(const std::string& name, const std::string& filename, const char* debugName);
+	std::vector<uint32_t> CompileShader(const std::string& filename);
 
 	static FString LoadPrivateShaderLump(const char* lumpname);
 	static FString LoadPublicShaderLump(const char* lumpname);
@@ -53,7 +53,6 @@ private:
 
 	struct
 	{
-		std::unique_ptr<VulkanShader> shader;
 		std::unique_ptr<VulkanDescriptorSetLayout> descriptorSetLayout;
 		std::unique_ptr<VulkanDescriptorPool> descriptorPool;
 		std::unique_ptr<VulkanDescriptorSet> descriptorSet;
@@ -78,7 +77,6 @@ private:
 
 	struct
 	{
-		std::unique_ptr<VulkanShader> shader;
 		std::unique_ptr<VulkanDescriptorSetLayout> descriptorSetLayout;
 		std::unique_ptr<VulkanDescriptorPool> descriptorPool;
 		std::unique_ptr<VulkanDescriptorSet> descriptorSets[6];
@@ -96,7 +94,6 @@ private:
 			maxlevels = 5,
 			levelsSize = DFrameBuffer::prefilterMapLevelsSize
 		};
-		std::unique_ptr<VulkanShader> shader;
 		std::unique_ptr<VulkanDescriptorSetLayout> descriptorSetLayout;
 		std::unique_ptr<VulkanDescriptorPool> descriptorPool;
 		std::unique_ptr<VulkanDescriptorSet> descriptorSets[6 * maxlevels];