diff --git a/CHANGELOG.md b/CHANGELOG.md
index 72ca220e0..d955f9f6f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -9,6 +9,7 @@ TombEngine releases are located in this repository (alongside with Tomb Editor):
 * Significantly improved renderer performance.
 * Improved engine performance around bridges.
 * Improved engine performance if weather or bubble effects are active.
+* Improved engine start-up time.
 * Fixed silent crashes if loaded level is corrupted or in incorrect format.
 * Fixed occasional crashes if there are static meshes placed within room border walls.
 * Fixed climbable pushables clipping Lara under the bridges when pulled.
diff --git a/TombEngine/Renderer/Renderer.h b/TombEngine/Renderer/Renderer.h
index 47a1d44a4..0734448ad 100644
--- a/TombEngine/Renderer/Renderer.h
+++ b/TombEngine/Renderer/Renderer.h
@@ -65,6 +65,7 @@
 #include "Renderer/Structures/RendererRoomAmbientMap.h"
 #include "Renderer/Structures/RendererObject.h"
 #include "Renderer/Structures/RendererStar.h"
+#include "Structures/RendererShader.h"
 
 enum GAME_OBJECT_ID : short;
 enum class SphereSpaceType;
@@ -124,43 +125,31 @@ namespace TEN::Renderer
 
 		// Shaders
 
-		ComPtr<ID3D11VertexShader> _vsRooms;
-		ComPtr<ID3D11VertexShader> _vsRoomsAnimatedTextures;
-		ComPtr<ID3D11PixelShader> _psRooms;
-		ComPtr<ID3D11PixelShader> _psRoomsTransparent;
-		ComPtr<ID3D11VertexShader> _vsItems;
-		ComPtr<ID3D11PixelShader> _psItems;
-		ComPtr<ID3D11VertexShader> _vsStatics;
-		ComPtr<ID3D11PixelShader> _psStatics;
-		ComPtr<ID3D11VertexShader> _vsSky;
-		ComPtr<ID3D11PixelShader> _psSky;
-		ComPtr<ID3D11VertexShader> _vsSprites;
-		ComPtr<ID3D11PixelShader> _psSprites;
-		ComPtr<ID3D11VertexShader> _vsInstancedSprites;
-		ComPtr<ID3D11PixelShader> _psInstancedSprites;
-		ComPtr<ID3D11VertexShader> _vsInstancedStaticMeshes;
-		ComPtr<ID3D11PixelShader> _psInstancedStaticMeshes;
-		ComPtr<ID3D11VertexShader> _vsSolid;
-		ComPtr<ID3D11PixelShader> _psSolid;
-		ComPtr<ID3D11VertexShader> _vsInventory;
-		ComPtr<ID3D11PixelShader> _psInventory;
-		ComPtr<ID3D11VertexShader> _vsFullScreenQuad;
-		ComPtr<ID3D11PixelShader> _psFullScreenQuad;
-		ComPtr<ID3D11VertexShader> _vsShadowMap;
-		ComPtr<ID3D11PixelShader> _psShadowMap;
-		ComPtr<ID3D11VertexShader> _vsHUD;
-		ComPtr<ID3D11PixelShader> _psHUDColor;
-		ComPtr<ID3D11PixelShader> _psHUDTexture;
-		ComPtr<ID3D11PixelShader> _psHUDBarColor;
-		ComPtr<ID3D11VertexShader> _vsGBufferRooms;
-		ComPtr<ID3D11VertexShader> _vsGBufferRoomsAnimated;
-		ComPtr<ID3D11VertexShader> _vsGBufferItems;
-		ComPtr<ID3D11VertexShader> _vsGBufferStatics;
-		ComPtr<ID3D11VertexShader> _vsGBufferInstancedStatics;
-		ComPtr<ID3D11PixelShader> _psGBuffer;
-		ComPtr<ID3D11VertexShader> _vsRoomAmbient;
-		ComPtr<ID3D11VertexShader> _vsRoomAmbientSky;
-		ComPtr<ID3D11PixelShader> _psRoomAmbient;
+		RendererShader _sRooms;
+		RendererShader _sRoomsAnimated;
+		RendererShader _sRoomsTransparent;
+		RendererShader _sRoomAmbient;
+		RendererShader _sRoomAmbientSky;
+		RendererShader _sItems;
+		RendererShader _sStatics;
+		RendererShader _sInstancedStatics;
+		RendererShader _sSprites;
+		RendererShader _sInstancedSprites;
+		RendererShader _sSky;
+		RendererShader _sSolid;
+		RendererShader _sInventory;
+		RendererShader _sFullScreenQuad;
+		RendererShader _sShadowMap;
+		RendererShader _sHUD;
+		RendererShader _sHUDColor;
+		RendererShader _sHUDTexture;
+		RendererShader _sHUDBarColor;
+		RendererShader _sGBuffer;
+		RendererShader _sGBufferRooms;
+		RendererShader _sGBufferRoomsAnimated;
+		RendererShader _sGBufferItems;
+		RendererShader _sGBufferStatics;
+		RendererShader _sGBufferInstancedStatics;
 
 		// Constant buffers
 
@@ -352,17 +341,13 @@ namespace TEN::Renderer
 		RenderTarget2D _SMAAEdgesRenderTarget;
 		RenderTarget2D _SMAABlendRenderTarget;
 
-		ComPtr<ID3D11VertexShader> _SMAAEdgeDetectionVS;
-		ComPtr<ID3D11PixelShader> _SMAALumaEdgeDetectionPS;
-		ComPtr<ID3D11PixelShader> _SMAAColorEdgeDetectionPS;
-		ComPtr<ID3D11PixelShader> _SMAADepthEdgeDetectionPS;
-		ComPtr<ID3D11VertexShader> _SMAABlendingWeightCalculationVS;
-		ComPtr<ID3D11PixelShader> _SMAABlendingWeightCalculationPS;
-		ComPtr<ID3D11VertexShader> _SMAANeighborhoodBlendingVS;
-		ComPtr<ID3D11PixelShader> _SMAANeighborhoodBlendingPS;
-
-		ComPtr<ID3D11VertexShader> _vsFXAA;
-		ComPtr<ID3D11PixelShader> _psFXAA;
+		RendererShader _sSMAAEdgeDetection;
+		RendererShader _sSMAALumaEdgeDetection;
+		RendererShader _sSMAAColorEdgeDetection;
+		RendererShader _sSMAADepthEdgeDetection;
+		RendererShader _sSMAABlendingWeightCalculation;
+		RendererShader _sSMAANeighborhoodBlending;
+		RendererShader _sFXAA;
 
 		// Post-process
 
@@ -372,27 +357,27 @@ namespace TEN::Renderer
 
 		VertexBuffer<PostProcessVertex> _fullscreenTriangleVertexBuffer;
 		ComPtr<ID3D11InputLayout> _fullscreenTriangleInputLayout = nullptr;
-		ComPtr<ID3D11VertexShader> _vsPostProcess;
-		ComPtr<ID3D11PixelShader> _psPostProcessCopy;
-		ComPtr<ID3D11PixelShader> _psPostProcessMonochrome;
-		ComPtr<ID3D11PixelShader> _psPostProcessNegative;
-		ComPtr<ID3D11PixelShader> _psPostProcessExclusion;
-		ComPtr<ID3D11PixelShader> _psPostProcessFinalPass;
-		ComPtr<ID3D11PixelShader> _psPostProcessLensFlare;
+		RendererShader _sPostProcess;
+		RendererShader _sPostProcessMonochrome;
+		RendererShader _sPostProcessNegative;
+		RendererShader _sPostProcessExclusion;
+		RendererShader _sPostProcessFinalPass;
+		RendererShader _sPostProcessLensFlare;
 
 		bool _doingFullscreenPass = false;
 
 		// SSAO
 
-		ComPtr<ID3D11VertexShader> _vsSSAO;
-		ComPtr<ID3D11PixelShader> _psSSAO;
-		ComPtr<ID3D11PixelShader> _psSSAOBlur;
 		Texture2D _SSAONoiseTexture;
 		RenderTarget2D _SSAORenderTarget;
 		RenderTarget2D _SSAOBlurredRenderTarget;
 		std::vector<Vector4> _SSAOKernel;
 
+		RendererShader _sSSAO;
+		RendererShader _sSSAOBlur;
+
 		// New ambient light techinque
+
 		RenderTarget2D _roomAmbientMapFront;
 		RenderTarget2D _roomAmbientMapBack;
 
@@ -411,11 +396,13 @@ namespace TEN::Renderer
 		// High framerate.
 
 		float _interpolationFactor = 0.0f;
-
 		bool _graphicsSettingsChanged = false;
 
 		// Private functions
 
+		RendererShader CompileOrLoadShader(const std::string& fileName, const std::string& funcName, ShaderType type, const D3D_SHADER_MACRO* defines = nullptr);
+		void BindShader(const RendererShader& shader);
+
 		void ApplySMAA(RenderTarget2D* renderTarget, RenderView& view);
 		void ApplyFXAA(RenderTarget2D* renderTarget, RenderView& view);
 		void BindTexture(TextureRegister registerType, TextureBase* texture, SamplerStateRegister samplerType);
diff --git a/TombEngine/Renderer/RendererAntialiasing.cpp b/TombEngine/Renderer/RendererAntialiasing.cpp
index 165a14494..b78fd9b1b 100644
--- a/TombEngine/Renderer/RendererAntialiasing.cpp
+++ b/TombEngine/Renderer/RendererAntialiasing.cpp
@@ -14,7 +14,7 @@ namespace TEN::Renderer
 		ResetScissor();
 
 		// Common vertex shader to all fullscreen effects
-		_context->VSSetShader(_vsPostProcess.Get(), nullptr, 0);
+		BindShader(_sPostProcess);
 
 		// We draw a fullscreen triangle
 		_context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
@@ -30,7 +30,6 @@ namespace TEN::Renderer
 		_context->ClearRenderTargetView(_SMAASceneRenderTarget.RenderTargetView.Get(), clearColor);
 		_context->OMSetRenderTargets(1, _SMAASceneRenderTarget.RenderTargetView.GetAddressOf(), nullptr);
 		
-		_context->PSSetShader(_psPostProcessCopy.Get(), nullptr, 0);
 		BindRenderTargetAsTexture(TextureRegister::ColorMap, renderTarget, SamplerStateRegister::PointWrap);
 		DrawTriangles(3, 0);
 
@@ -41,8 +40,8 @@ namespace TEN::Renderer
 		SetCullMode(CullMode::CounterClockwise);
 		_context->OMSetRenderTargets(1, _SMAAEdgesRenderTarget.RenderTargetView.GetAddressOf(), nullptr);
 
-		_context->VSSetShader(_SMAAEdgeDetectionVS.Get(), nullptr, 0);
-		_context->PSSetShader(_SMAAColorEdgeDetectionPS.Get(), nullptr, 0);
+		BindShader(_sSMAAEdgeDetection);
+		BindShader(_sSMAAColorEdgeDetection);
 		 
 		_stSMAABuffer.BlendFactor = 1.0f;
 		_cbSMAABuffer.UpdateData(_stSMAABuffer, _context.Get());
@@ -60,8 +59,7 @@ namespace TEN::Renderer
 		// 2) Blend weights calculation.
 		_context->OMSetRenderTargets(1, _SMAABlendRenderTarget.RenderTargetView.GetAddressOf(), nullptr);
 
-		_context->VSSetShader(_SMAABlendingWeightCalculationVS.Get(), nullptr, 0);
-		_context->PSSetShader(_SMAABlendingWeightCalculationPS.Get(), nullptr, 0);
+		BindShader(_sSMAABlendingWeightCalculation);
 
 		_stSMAABuffer.SubsampleIndices = Vector4::Zero;
 		_cbSMAABuffer.UpdateData(_stSMAABuffer, _context.Get());
@@ -78,8 +76,7 @@ namespace TEN::Renderer
 		// 3) Neighborhood blending.
 		_context->OMSetRenderTargets(1, renderTarget->RenderTargetView.GetAddressOf(), nullptr);
 
-		_context->VSSetShader(_SMAANeighborhoodBlendingVS.Get(), nullptr, 0);
-		_context->PSSetShader(_SMAANeighborhoodBlendingPS.Get(), nullptr, 0);
+		BindShader(_sSMAANeighborhoodBlending);
 
 		BindRenderTargetAsTexture(static_cast<TextureRegister>(0), &_SMAASceneRenderTarget, SamplerStateRegister::LinearClamp);
 		BindRenderTargetAsTexture(static_cast<TextureRegister>(1), &_SMAASceneSRGBRenderTarget, SamplerStateRegister::LinearClamp);
@@ -103,7 +100,7 @@ namespace TEN::Renderer
 		ResetScissor();
 
 		// Common vertex shader to all fullscreen effects
-		_context->VSSetShader(_vsPostProcess.Get(), nullptr, 0);
+		BindShader(_sPostProcess);
 
 		// We draw a fullscreen triangle
 		_context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
@@ -119,7 +116,6 @@ namespace TEN::Renderer
 		_context->ClearRenderTargetView(_tempRenderTarget.RenderTargetView.Get(), clearColor);
 		_context->OMSetRenderTargets(1, _tempRenderTarget.RenderTargetView.GetAddressOf(), nullptr);
 
-		_context->PSSetShader(_psPostProcessCopy.Get(), nullptr, 0);
 		BindRenderTargetAsTexture(TextureRegister::ColorMap, renderTarget, SamplerStateRegister::PointWrap);
 		DrawTriangles(3, 0);
 
@@ -127,7 +123,7 @@ namespace TEN::Renderer
 		_context->ClearRenderTargetView(renderTarget->RenderTargetView.Get(), Colors::Black);
 		_context->OMSetRenderTargets(1, renderTarget->RenderTargetView.GetAddressOf(), nullptr);
 
-		_context->PSSetShader(_psFXAA.Get(), nullptr, 0);
+		BindShader(_sFXAA);
 
 		_stPostProcessBuffer.ViewportWidth = _screenWidth;
 		_stPostProcessBuffer.ViewportHeight = _screenHeight;
diff --git a/TombEngine/Renderer/RendererDraw.cpp b/TombEngine/Renderer/RendererDraw.cpp
index 9edec0a51..55b536b4d 100644
--- a/TombEngine/Renderer/RendererDraw.cpp
+++ b/TombEngine/Renderer/RendererDraw.cpp
@@ -167,8 +167,7 @@ namespace TEN::Renderer
 			UINT offset = 0;
 
 			// Set shaders
-			_context->VSSetShader(_vsShadowMap.Get(), nullptr, 0);
-			_context->PSSetShader(_psShadowMap.Get(), nullptr, 0);
+			BindShader(_sShadowMap);
 
 			_context->IASetVertexBuffers(0, 1, _moveablesVertexBuffer.Buffer.GetAddressOf(), &stride, &offset);
 			_context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
@@ -285,8 +284,7 @@ namespace TEN::Renderer
 		{
 			auto& moveableObject = *_moveableObjects[objectID];
 
-			_context->VSSetShader(_vsInstancedStaticMeshes.Get(), nullptr, 0);
-			_context->PSSetShader(_psInstancedStaticMeshes.Get(), nullptr, 0);
+			BindShader(_sInstancedStatics);
 
 			unsigned int stride = sizeof(Vertex);
 			unsigned int offset = 0;
@@ -363,8 +361,7 @@ namespace TEN::Renderer
 		SetDepthState(DepthState::Read);
 		SetCullMode(CullMode::None);
 
-		_context->VSSetShader(_vsSolid.Get(), nullptr, 0);
-		_context->PSSetShader(_psSolid.Get(), nullptr, 0);
+		BindShader(_sSolid);
 		auto worldMatrix = Matrix::CreateOrthographicOffCenter(0, _screenWidth, _screenHeight, 0, _viewport.MinDepth, _viewport.MaxDepth);
 
 		_context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_LINELIST);
@@ -534,13 +531,12 @@ namespace TEN::Renderer
 			{
 				if (rendererPass == RendererPass::GBuffer)
 				{
-					_context->VSSetShader(_vsGBufferStatics.Get(), nullptr, 0);
-					_context->PSSetShader(_psGBuffer.Get(), nullptr, 0);
+					BindShader(_sGBuffer);
+					BindShader(_sGBufferStatics);
 				}
 				else
 				{
-					_context->VSSetShader(_vsStatics.Get(), nullptr, 0);
-					_context->PSSetShader(_psStatics.Get(), nullptr, 0);
+					BindShader(_sStatics);
 				}
 
 				UINT stride = sizeof(Vertex);
@@ -660,13 +656,12 @@ namespace TEN::Renderer
 			{
 				if (rendererPass == RendererPass::GBuffer)
 				{
-					_context->VSSetShader(_vsGBufferStatics.Get(), nullptr, 0);
-					_context->PSSetShader(_psGBuffer.Get(), nullptr, 0);
+					BindShader(_sGBuffer);
+					BindShader(_sGBufferStatics);
 				}
 				else
 				{
-					_context->VSSetShader(_vsStatics.Get(), nullptr, 0);
-					_context->PSSetShader(_psStatics.Get(), nullptr, 0);
+					BindShader(_sStatics);
 				}
 
 				unsigned int stride = sizeof(Vertex);
@@ -797,13 +792,12 @@ namespace TEN::Renderer
 				{
 					if (rendererPass == RendererPass::GBuffer)
 					{
-						_context->VSSetShader(_vsGBufferInstancedStatics.Get(), nullptr, 0);
-						_context->PSSetShader(_psGBuffer.Get(), nullptr, 0);
+						BindShader(_sGBuffer);
+						BindShader(_sGBufferInstancedStatics);
 					}
 					else
 					{
-						_context->VSSetShader(_vsInstancedStaticMeshes.Get(), nullptr, 0);
-						_context->PSSetShader(_psInstancedStaticMeshes.Get(), nullptr, 0);
+						BindShader(_sInstancedStatics);
 					}
 
 					unsigned int stride = sizeof(Vertex);
@@ -925,13 +919,12 @@ namespace TEN::Renderer
 				{
 					if (rendererPass == RendererPass::GBuffer)
 					{
-						_context->VSSetShader(_vsGBufferInstancedStatics.Get(), nullptr, 0);
-						_context->PSSetShader(_psGBuffer.Get(), nullptr, 0);
+						BindShader(_sGBuffer);
+						BindShader(_sGBufferInstancedStatics);
 					}
 					else
 					{
-						_context->VSSetShader(_vsInstancedStaticMeshes.Get(), nullptr, 0);
-						_context->PSSetShader(_psInstancedStaticMeshes.Get(), nullptr, 0);
+						BindShader(_sInstancedStatics);
 					}
 
 					unsigned int stride = sizeof(Vertex);
@@ -1033,13 +1026,12 @@ namespace TEN::Renderer
 			{
 				if (rendererPass == RendererPass::GBuffer)
 				{
-					_context->VSSetShader(_vsGBufferStatics.Get(), nullptr, 0);
-					_context->PSSetShader(_psGBuffer.Get(), nullptr, 0);
+					BindShader(_sGBuffer);
+					BindShader(_sGBufferStatics);
 				}
 				else
 				{
-					_context->VSSetShader(_vsStatics.Get(), nullptr, 0);
-					_context->PSSetShader(_psStatics.Get(), nullptr, 0);
+					BindShader(_sStatics);
 				}
 
 				unsigned int stride = sizeof(Vertex);
@@ -1097,8 +1089,7 @@ namespace TEN::Renderer
 		SetBlendMode(BlendMode::Additive);
 		SetCullMode(CullMode::None);
 
-		_context->VSSetShader(_vsSolid.Get(), nullptr, 0);
-		_context->PSSetShader(_psSolid.Get(), nullptr, 0);
+		BindShader(_sSolid);
 
 		_context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_LINELIST);
 
@@ -1131,8 +1122,7 @@ namespace TEN::Renderer
 		SetBlendMode(BlendMode::Additive);
 		SetCullMode(CullMode::None);
 
-		_context->VSSetShader(_vsSolid.Get(), nullptr, 0);
-		_context->PSSetShader(_psSolid.Get(), nullptr, 0);
+		BindShader(_sSolid);
 
 		_context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
 		_context->IASetInputLayout(_inputLayout.Get());
@@ -1936,7 +1926,7 @@ namespace TEN::Renderer
 		SetBlendMode(BlendMode::Opaque);
 		SetCullMode(CullMode::CounterClockwise);
 
-		_context->PSSetShader(_psRoomAmbient.Get(), nullptr, 0);
+		BindShader(_sRoomAmbient);
 
 		// Bind and clear render target
 		_context->ClearRenderTargetView(renderTarget->RenderTargetView.Get(), Colors::Black);
@@ -1986,7 +1976,7 @@ namespace TEN::Renderer
 
 		if (levelPtr->Horizon)
 		{
-			_context->VSSetShader(_vsRoomAmbientSky.Get(), nullptr, 0);
+			BindShader(_sRoomAmbientSky);
 
 			if (Lara.Control.Look.OpticRange != 0)
 				AlterFOV(ANGLE(DEFAULT_FOV) - Lara.Control.Look.OpticRange, false);
@@ -2068,7 +2058,7 @@ namespace TEN::Renderer
 			_context->ClearDepthStencilView(renderTarget->DepthStencilView.Get(), D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL, 1.0f, 0);
 		}
 
-		_context->VSSetShader(_vsRoomAmbient.Get(), nullptr, 0);
+		BindShader(_sRoomAmbient);
 
 		// Draw rooms
 		UINT stride = sizeof(Vertex);
@@ -2274,13 +2264,12 @@ namespace TEN::Renderer
 		// Set shaders.
 		if (rendererPass == RendererPass::GBuffer)
 		{
-			_context->VSSetShader(_vsGBufferItems.Get(), nullptr, 0);
-			_context->PSSetShader(_psGBuffer.Get(), nullptr, 0);
+			BindShader(_sGBuffer);
+			BindShader(_sGBufferItems);
 		}
 		else
 		{
-			_context->VSSetShader(_vsItems.Get(), nullptr, 0);
-			_context->PSSetShader(_psItems.Get(), nullptr, 0);
+			BindShader(_sItems);
 		}
 
 		BindRenderTargetAsTexture(TextureRegister::SSAO, &_SSAOBlurredRenderTarget, SamplerStateRegister::PointWrap);
@@ -2417,13 +2406,12 @@ namespace TEN::Renderer
 #ifdef DISABLE_INSTANCING
 			if (rendererPass == RendererPass::GBuffer)
 			{
-				_context->VSSetShader(_vsGBufferStatics.Get(), NULL, 0);
-				_context->PSSetShader(_psGBuffer.Get(), NULL, 0);
+				BindShader(_sGBuffer);
+				BindShader(_sGBufferStatics);
 			}
 			else
 			{
-				_context->VSSetShader(_vsStatics.Get(), NULL, 0);
-				_context->PSSetShader(_psStatics.Get(), NULL, 0);
+				BindShader(_sStatics);
 			}
 
 			// Bind vertex and index buffer
@@ -2499,13 +2487,12 @@ namespace TEN::Renderer
 #else
 			if (rendererPass == RendererPass::GBuffer)
 			{
-				_context->VSSetShader(_vsGBufferInstancedStatics.Get(), NULL, 0);
-				_context->PSSetShader(_psGBuffer.Get(), NULL, 0);
+				BindShader(_sGBuffer);
+				BindShader(_sGBufferInstancedStatics);
 			}
 			else
 			{
-				_context->VSSetShader(_vsInstancedStaticMeshes.Get(), NULL, 0);
-				_context->PSSetShader(_psInstancedStaticMeshes.Get(), NULL, 0);
+				BindShader(_sInstancedStatics);
 			}
 
 			// Bind vertex and index buffer
@@ -2695,11 +2682,11 @@ namespace TEN::Renderer
 		{
 			if (rendererPass == RendererPass::GBuffer)
 			{
-				_context->PSSetShader(_psGBuffer.Get(), nullptr, 0);
+				BindShader(_sGBuffer);
 			}
 			else
 			{
-				_context->PSSetShader(_psRooms.Get(), nullptr, 0);
+				BindShader(_sRooms);
 			}
 
 			UINT stride = sizeof(Vertex);
@@ -2763,11 +2750,11 @@ namespace TEN::Renderer
 				{
 					if (rendererPass != RendererPass::GBuffer)
 					{
-						_context->VSSetShader((animated == 0) ? _vsRooms.Get() : _vsRoomsAnimatedTextures.Get(), nullptr, 0);
+						if (animated == 0) BindShader(_sRooms); else BindShader(_sRoomsAnimated);
 					}
 					else
 					{
-						_context->VSSetShader((animated == 0) ? _vsGBufferRooms.Get() : _vsGBufferRoomsAnimated.Get(), nullptr, 0);
+						if (animated == 0) BindShader(_sGBufferRooms); else BindShader(_sGBufferRoomsAnimated);
 					}
 
 					for (const auto& bucket : room.Buckets)
@@ -2866,9 +2853,7 @@ namespace TEN::Renderer
 		// Draw sky.
 		auto rotation = Matrix::CreateRotationX(PI);
 
-		_context->VSSetShader(_vsSky.Get(), nullptr, 0);
-		_context->PSSetShader(_psSky.Get(), nullptr, 0);
-
+		BindShader(_sSky);
 		BindTexture(TextureRegister::ColorMap, &_skyTexture, SamplerStateRegister::AnisotropicClamp);
 
 		_context->IASetVertexBuffers(0, 1, _skyVertexBuffer.Buffer.GetAddressOf(), &stride, &offset);
@@ -2909,8 +2894,7 @@ namespace TEN::Renderer
 
 			_context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
 
-			_context->VSSetShader(_vsInstancedSprites.Get(), nullptr, 0);
-			_context->PSSetShader(_psInstancedSprites.Get(), nullptr, 0);
+			BindShader(_sInstancedSprites);
 
 			// Set up vertex buffer and parameters.
 			UINT stride = sizeof(Vertex);
@@ -3049,8 +3033,7 @@ namespace TEN::Renderer
 			_context->IASetVertexBuffers(0, 1, _moveablesVertexBuffer.Buffer.GetAddressOf(), &stride, &offset);
 			_context->IASetIndexBuffer(_moveablesIndexBuffer.Buffer.Get(), DXGI_FORMAT_R32_UINT, 0);
 
-			_context->VSSetShader(_vsSky.Get(), nullptr, 0);
-			_context->PSSetShader(_psSky.Get(), nullptr, 0);
+			BindShader(_sSky);
 
 			auto& moveableObj = *_moveableObjects[ID_HORIZON];
 
@@ -3094,8 +3077,7 @@ namespace TEN::Renderer
 
 			_context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
 
-			_context->VSSetShader(_vsInstancedSprites.Get(), nullptr, 0);
-			_context->PSSetShader(_psInstancedSprites.Get(), nullptr, 0);
+			BindShader(_sInstancedSprites);
 
 			// Set up vertex buffer and parameters.
 			unsigned int stride = sizeof(Vertex);
@@ -3522,7 +3504,7 @@ namespace TEN::Renderer
 
 		ROOM_INFO* nativeRoom = &g_Level.Rooms[objectInfo->Room->RoomNumber];
 
-		_context->PSSetShader(_psRooms.Get(), nullptr, 0);
+		BindShader(_sRooms);
 
 		UINT stride = sizeof(Vertex);
 		UINT offset = 0;
@@ -3538,14 +3520,8 @@ namespace TEN::Renderer
 
 		SetScissor(objectInfo->Room->ClipBounds);
 
-		if (objectInfo->Bucket->Animated == 0)
-		{
-			_context->VSSetShader(_vsRooms.Get(), nullptr, 0);
-		}
-		else
-		{
-			_context->VSSetShader(_vsRoomsAnimatedTextures.Get(), nullptr, 0);
-		}
+		if (objectInfo->Bucket->Animated != 0)
+			BindShader(_sRoomsAnimated);
 
 		SetBlendMode(objectInfo->Bucket->BlendMode);
 		SetAlphaTest(AlphaTestMode::None, ALPHA_TEST_THRESHOLD);
@@ -3611,8 +3587,7 @@ namespace TEN::Renderer
 		SetBlendMode(objectInfo->Bucket->BlendMode);
 		SetAlphaTest(AlphaTestMode::None, ALPHA_TEST_THRESHOLD);
 
-		_context->VSSetShader(_vsItems.Get(), nullptr, 0);
-		_context->PSSetShader(_psItems.Get(), nullptr, 0);
+		BindShader(_sItems);
 
 		// Bind main item properties.
 		Matrix world = objectInfo->Item->InterpolatedWorld;
@@ -3652,8 +3627,7 @@ namespace TEN::Renderer
 		_context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
 		_context->IASetInputLayout(_inputLayout.Get());
 
-		_context->VSSetShader(_vsStatics.Get(), nullptr, 0);
-		_context->PSSetShader(_psStatics.Get(), nullptr, 0);
+		BindShader(_sStatics);
 
 		Matrix world = objectInfo->Static->World;
 		_stStatic.World = world;
@@ -3691,8 +3665,7 @@ namespace TEN::Renderer
 		_context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
 		_context->IASetInputLayout(_inputLayout.Get());
 
-		_context->VSSetShader(_vsStatics.Get(), nullptr, 0);
-		_context->PSSetShader(_psStatics.Get(), nullptr, 0);
+		BindShader(_sStatics);
 
 		Matrix world = objectInfo->World;
 		_stStatic.World = world;
@@ -3731,10 +3704,10 @@ namespace TEN::Renderer
 		SetDepthState(DepthState::Write);
 
 		// Common vertex shader to all full screen effects
-		_context->VSSetShader(_vsPostProcess.Get(), nullptr, 0);
+		BindShader(_sPostProcess);
 
 		// SSAO pixel shader
-		_context->PSSetShader(_psSSAO.Get(), nullptr, 0);
+		BindShader(_sSSAO);
 
 		_context->ClearRenderTargetView(_SSAORenderTarget.RenderTargetView.Get(), Colors::White);
 		_context->OMSetRenderTargets(1, _SSAORenderTarget.RenderTargetView.GetAddressOf(), nullptr);
@@ -3778,7 +3751,7 @@ namespace TEN::Renderer
 		DrawTriangles(3, 0);
 
 		// Blur step
-		_context->PSSetShader(_psSSAOBlur.Get(), nullptr, 0);
+		BindShader(_sSSAOBlur);
 
 		_context->ClearRenderTargetView(_SSAOBlurredRenderTarget.RenderTargetView.Get(), Colors::Black);
 		_context->OMSetRenderTargets(1, _SSAOBlurredRenderTarget.RenderTargetView.GetAddressOf(), nullptr);
diff --git a/TombEngine/Renderer/RendererDraw2D.cpp b/TombEngine/Renderer/RendererDraw2D.cpp
index 93194e04e..698b9dea9 100644
--- a/TombEngine/Renderer/RendererDraw2D.cpp
+++ b/TombEngine/Renderer/RendererDraw2D.cpp
@@ -132,8 +132,8 @@ namespace TEN::Renderer
 		_context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
 		_context->IASetIndexBuffer(bar.IndexBufferBorder.Buffer.Get(), DXGI_FORMAT_R32_UINT, 0);
 		
-		_context->VSSetShader(_vsHUD.Get(), nullptr, 0);
-		_context->PSSetShader(_psHUDTexture.Get(), nullptr, 0);
+		BindShader(_sHUD);
+		BindShader(_sHUDTexture);
 
 		SetBlendMode(BlendMode::Opaque);
 		SetDepthState(DepthState::None);
@@ -161,8 +161,8 @@ namespace TEN::Renderer
 		_context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
 		_context->IASetIndexBuffer(bar.InnerIndexBuffer.Buffer.Get(), DXGI_FORMAT_R32_UINT, 0);
 		
-		_context->VSSetShader(_vsHUD.Get(), nullptr, 0);
-		_context->PSSetShader(_psHUDBarColor.Get(), nullptr, 0);
+		BindShader(_sHUD);
+		BindShader(_sHUDBarColor);
 
 		_stHUDBar.Percent = percent;
 		_stHUDBar.Poisoned = isPoisoned;
@@ -195,8 +195,8 @@ namespace TEN::Renderer
 		_context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
 		_context->IASetIndexBuffer(g_LoadingBar->IndexBufferBorder.Buffer.Get(), DXGI_FORMAT_R32_UINT, 0);
 	
-		_context->VSSetShader(_vsHUD.Get(), NULL, 0);
-		_context->PSSetShader(_psHUDTexture.Get(), NULL, 0);
+		BindShader(_sHUD);
+		BindShader(_sHUDTexture);
 
 		SetBlendMode(BlendMode::Opaque);
 		SetDepthState(DepthState::None);
@@ -220,8 +220,8 @@ namespace TEN::Renderer
 		_context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
 		_context->IASetIndexBuffer(g_LoadingBar->InnerIndexBuffer.Buffer.Get(), DXGI_FORMAT_R32_UINT, 0);
 	
-		_context->VSSetShader(_vsHUD.Get(), nullptr, 0);
-		_context->PSSetShader(_psHUDBarColor.Get(), nullptr, 0);
+		BindShader(_sHUD);
+		BindShader(_sHUDBarColor);
 		
 		_stHUDBar.Percent = percentage / 100.0f;
 		_stHUDBar.Poisoned = false;
@@ -305,8 +305,7 @@ namespace TEN::Renderer
 			vertices[3].UV.y = 1.0f;
 			vertices[3].Color = Vector4(1.0f, 0.0f, 0.0f, 1.0f);
 
-			_context->VSSetShader(_vsFullScreenQuad.Get(), nullptr, 0);
-			_context->PSSetShader(_psFullScreenQuad.Get(), nullptr, 0);
+			BindShader(_sFullScreenQuad);
 
 			_context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
 			_context->IASetInputLayout(_inputLayout.Get());
@@ -342,8 +341,7 @@ namespace TEN::Renderer
 		if (renderView.DisplaySpritesToDraw.empty())
 			return;
 
-		_context->VSSetShader(_vsFullScreenQuad.Get(), nullptr, 0);
-		_context->PSSetShader(_psFullScreenQuad.Get(), nullptr, 0);
+		BindShader(_sFullScreenQuad);
 
 		_context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
 		_context->IASetInputLayout(_inputLayout.Get());
@@ -465,8 +463,7 @@ namespace TEN::Renderer
 		vertices[3].UV.y = uvEnd.y;
 		vertices[3].Color = colorVec4;
 
-		_context->VSSetShader(_vsFullScreenQuad.Get(), nullptr, 0);
-		_context->PSSetShader(_psFullScreenQuad.Get(), nullptr, 0);
+		BindShader(_sFullScreenQuad);
 
 		_context->PSSetShaderResources(0, 1, &texture);
 
@@ -543,8 +540,7 @@ namespace TEN::Renderer
 		vertices[3].UV.y = uvEnd.y;
 		vertices[3].Color = Vector4(color.x, color.y, color.z, 1.0f);
 
-		_context->VSSetShader(_vsFullScreenQuad.Get(), nullptr, 0);
-		_context->PSSetShader(_psFullScreenQuad.Get(), nullptr, 0);
+		BindShader(_sFullScreenQuad);
 
 		_context->PSSetShaderResources(0, 1, &texture);
 		auto* sampler = _renderStates->AnisotropicClamp();
diff --git a/TombEngine/Renderer/RendererDrawEffect.cpp b/TombEngine/Renderer/RendererDrawEffect.cpp
index 33ac5d6e4..eed4aecb9 100644
--- a/TombEngine/Renderer/RendererDrawEffect.cpp
+++ b/TombEngine/Renderer/RendererDrawEffect.cpp
@@ -1022,8 +1022,7 @@ namespace TEN::Renderer
 		if (!settings.MuzzleFlash)
 			return false;
 
-		_context->VSSetShader(_vsStatics.Get(), nullptr, 0);
-		_context->PSSetShader(_psStatics.Get(), nullptr, 0);
+		BindShader(_sStatics);
 
 		unsigned int stride = sizeof(Vertex);
 		unsigned int offset = 0;
@@ -1144,8 +1143,7 @@ namespace TEN::Renderer
 
 	void Renderer::DrawBaddyGunflashes(RenderView& view)
 	{
-		_context->VSSetShader(_vsStatics.Get(), nullptr, 0);
-		_context->PSSetShader(_psStatics.Get(), nullptr, 0);
+		BindShader(_sStatics);
 
 		unsigned int stride = sizeof(Vertex);
 		unsigned int offset = 0;
@@ -1371,8 +1369,7 @@ namespace TEN::Renderer
 
 	void Renderer::DrawEffects(RenderView& view, RendererPass rendererPass)
 	{
-		_context->VSSetShader(_vsStatics.Get(), nullptr, 0);
-		_context->PSSetShader(_psStatics.Get(), nullptr, 0);
+		BindShader(_sStatics);
 
 		unsigned int stride = sizeof(Vertex);
 		unsigned int offset = 0;
@@ -1413,8 +1410,7 @@ namespace TEN::Renderer
 
 		if (activeDebrisExist)
 		{
-			_context->VSSetShader(_vsStatics.Get(), nullptr, 0);
-			_context->PSSetShader(_psStatics.Get(), nullptr, 0);
+			BindShader(_sStatics);
 
 			SetCullMode(CullMode::None);
 
diff --git a/TombEngine/Renderer/RendererDrawMenu.cpp b/TombEngine/Renderer/RendererDrawMenu.cpp
index 6d9dd8641..168ff42ff 100644
--- a/TombEngine/Renderer/RendererDrawMenu.cpp
+++ b/TombEngine/Renderer/RendererDrawMenu.cpp
@@ -816,8 +816,7 @@ namespace TEN::Renderer
 		_context->IASetIndexBuffer(_moveablesIndexBuffer.Buffer.Get(), DXGI_FORMAT_R32_UINT, 0);
 
 		// Set shaders.
-		_context->VSSetShader(_vsInventory.Get(), nullptr, 0);
-		_context->PSSetShader(_psInventory.Get(), nullptr, 0);
+		BindShader(_sInventory);
 
 		// Set matrices.
 		CCameraMatrixBuffer hudCamera;
@@ -889,7 +888,7 @@ namespace TEN::Renderer
 		if (!texture.Texture)
 			return;
 
-		int timeout = 20;
+		int timeout = 10;
 		float currentFade = FADE_FACTOR;
 
 		while (timeout || currentFade > 0.0f)
@@ -1010,8 +1009,7 @@ namespace TEN::Renderer
 		_context->IASetIndexBuffer(_moveablesIndexBuffer.Buffer.Get(), DXGI_FORMAT_R32_UINT, 0);
 
 		// Set shaders
-		_context->VSSetShader(_vsInventory.Get(), nullptr, 0);
-		_context->PSSetShader(_psInventory.Get(), nullptr, 0);
+		BindShader(_sInventory);
 
 		if (CurrentLevel == 0)
 		{
diff --git a/TombEngine/Renderer/RendererInit.cpp b/TombEngine/Renderer/RendererInit.cpp
index 08d9b11a9..31b1a8155 100644
--- a/TombEngine/Renderer/RendererInit.cpp
+++ b/TombEngine/Renderer/RendererInit.cpp
@@ -2,18 +2,23 @@
 #include <string>
 #include <memory>
 #include <filesystem>
+#include <random>
+#include <d3dcompiler.h>
+
 #include "Renderer/Renderer.h"
+#include "Renderer/RendererUtils.h"
+#include "Renderer/SMAA/AreaTex.h"
+#include "Renderer/SMAA/SearchTex.h"
 #include "Scripting/Include/Flow/ScriptInterfaceFlowHandler.h"
 #include "Specific/configuration.h"
 #include "Specific/memory/Vector.h"
 #include "Specific/trutils.h"
 #include "Specific/winmain.h"
-#include "Renderer/SMAA/AreaTex.h"
-#include "Renderer/SMAA/SearchTex.h"
-#include <random>
 
 extern GameConfiguration g_Configuration;
 
+using namespace TEN::Renderer::Utils;
+
 static std::wstring GetAssetPath(const wchar_t* fileName)
 {
 	return TEN::Utils::ToWString(g_GameFlow->GetGameDir()) + fileName;
@@ -35,12 +40,9 @@ namespace TEN::Renderer
 		_renderStates = std::make_unique<CommonStates>(_device.Get());
 
 		// Load shaders
-		ComPtr<ID3D10Blob> blob;
 		const D3D_SHADER_MACRO roomDefinesAnimated[] = { "ANIMATED", "", nullptr, nullptr };
 		const D3D_SHADER_MACRO roomDefinesShadowMap[] = { "SHADOW_MAP", "", nullptr, nullptr };
 
-		_vsRooms = Utils::compileVertexShader(_device.Get(), GetAssetPath(L"Shaders\\Rooms.fx"), "VS", "vs_5_0", nullptr, blob);
-
 		// Initialize input layout using first vertex shader.
 		D3D11_INPUT_ELEMENT_DESC inputLayoutItems[] =
 		{
@@ -57,50 +59,41 @@ namespace TEN::Renderer
 			{ "DRAWINDEX", 0, DXGI_FORMAT_R32_UINT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
 			{ "HASH", 0, DXGI_FORMAT_R32_SINT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 }
 		};
-		Utils::throwIfFailed(_device->CreateInputLayout(inputLayoutItems, 12, blob->GetBufferPointer(), blob->GetBufferSize(), &_inputLayout));
 
-		_vsRoomsAnimatedTextures = Utils::compileVertexShader(_device.Get(), GetAssetPath(L"Shaders\\Rooms.fx"), "VS", "vs_5_0", &roomDefinesAnimated[0], blob);
-		_psRooms = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\Rooms.fx"), "PS", "ps_5_0", nullptr, blob);
-		_vsItems = Utils::compileVertexShader(_device.Get(), GetAssetPath(L"Shaders\\Items.fx"), "VS", "vs_5_0", nullptr, blob);
-		_psItems = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\Items.fx"), "PS", "ps_5_0", nullptr, blob);
-		_vsStatics = Utils::compileVertexShader(_device.Get(), GetAssetPath(L"Shaders\\Statics.fx"), "VS", "vs_5_0", nullptr, blob);
-		_psStatics = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\Statics.fx"), "PS", "ps_5_0", nullptr, blob);
-		_vsSky = Utils::compileVertexShader(_device.Get(), GetAssetPath(L"Shaders\\Sky.fx"), "VS", "vs_5_0", nullptr, blob);
-		_psSky = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\Sky.fx"), "PS", "ps_5_0", nullptr, blob);
-		_vsSprites = Utils::compileVertexShader(_device.Get(), GetAssetPath(L"Shaders\\Sprites.fx"), "VS", "vs_5_0", nullptr, blob);
-		_psSprites = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\Sprites.fx"), "PS", "ps_5_0", nullptr, blob);
-		_vsSolid = Utils::compileVertexShader(_device.Get(), GetAssetPath(L"Shaders\\Solid.fx"), "VS", "vs_5_0", nullptr, blob);
-		_psSolid = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\Solid.fx"), "PS", "ps_5_0", nullptr, blob);
-		_vsInventory = Utils::compileVertexShader(_device.Get(), GetAssetPath(L"Shaders\\Inventory.fx"), "VS", "vs_5_0", nullptr, blob);
-		_psInventory = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\Inventory.fx"), "PS", "ps_5_0", nullptr, blob);
-		_vsFullScreenQuad = Utils::compileVertexShader(_device.Get(), GetAssetPath(L"Shaders\\FullScreenQuad.fx"), "VS", "vs_5_0", nullptr, blob);
-		_psFullScreenQuad = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\FullScreenQuad.fx"), "PS", "ps_5_0", nullptr, blob);
-		_vsShadowMap = Utils::compileVertexShader(_device.Get(), GetAssetPath(L"Shaders\\ShadowMap.fx"), "VS", "vs_5_0", nullptr, blob);
-		_psShadowMap = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\ShadowMap.fx"), "PS", "ps_5_0", nullptr, blob);
-		_vsHUD = Utils::compileVertexShader(_device.Get(), GetAssetPath(L"Shaders\\HUD.hlsl"), "VS", "vs_5_0", nullptr, blob);
-		_psHUDColor = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\HUD.hlsl"), "PSColoredHUD", "ps_5_0", nullptr, blob);
-		_psHUDTexture = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\HUD.hlsl"), "PSTexturedHUD", "ps_5_0", nullptr, blob);
-		_psHUDBarColor = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\HUD.hlsl"), "PSTexturedHUDBar", "ps_5_0", nullptr, blob);
-		_vsInstancedStaticMeshes = Utils::compileVertexShader(_device.Get(), GetAssetPath(L"Shaders\\InstancedStatics.fx"), "VS", "vs_5_0", nullptr, blob);
-		_psInstancedStaticMeshes = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\InstancedStatics.fx"), "PS", "ps_5_0", nullptr, blob);
-		_vsInstancedSprites = Utils::compileVertexShader(_device.Get(), GetAssetPath(L"Shaders\\InstancedSprites.fx"), "VS", "vs_5_0", nullptr, blob);
-		_psInstancedSprites = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\InstancedSprites.fx"), "PS", "ps_5_0", nullptr, blob);
-		_vsGBufferRooms = Utils::compileVertexShader(_device.Get(), GetAssetPath(L"Shaders\\GBuffer.fx"), "VSRooms", "vs_5_0", nullptr, blob);
-		_vsGBufferRoomsAnimated = Utils::compileVertexShader(_device.Get(), GetAssetPath(L"Shaders\\GBuffer.fx"), "VSRooms", "vs_5_0", &roomDefinesAnimated[0], blob);
-		_vsGBufferItems = Utils::compileVertexShader(_device.Get(), GetAssetPath(L"Shaders\\GBuffer.fx"), "VSItems", "vs_5_0", nullptr, blob);
-		_vsGBufferStatics = Utils::compileVertexShader(_device.Get(), GetAssetPath(L"Shaders\\GBuffer.fx"), "VSStatics", "vs_5_0", nullptr, blob);
-		_vsGBufferInstancedStatics = Utils::compileVertexShader(_device.Get(), GetAssetPath(L"Shaders\\GBuffer.fx"), "VSInstancedStatics", "vs_5_0", nullptr, blob);
-		_psGBuffer = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\GBuffer.fx"), "PS", "ps_5_0", nullptr, blob);
-		_vsRoomAmbient = Utils::compileVertexShader(_device.Get(), GetAssetPath(L"Shaders\\RoomAmbient.fx"), "VS", "vs_5_0", nullptr, blob);
-		_vsRoomAmbientSky = Utils::compileVertexShader(_device.Get(), GetAssetPath(L"Shaders\\RoomAmbient.fx"), "VSSky", "vs_5_0", nullptr, blob);
-		_psRoomAmbient = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\RoomAmbient.fx"), "PS", "ps_5_0", nullptr, blob);
-		_vsFXAA = Utils::compileVertexShader(_device.Get(), GetAssetPath(L"Shaders\\FXAA.fx"), "VS", "vs_5_0", nullptr, blob);
-		_psFXAA = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\FXAA.fx"), "PS", "ps_5_0", nullptr, blob);
-		_psSSAO = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\SSAO.fx"), "PS", "ps_5_0", nullptr, blob);
-		_psSSAOBlur = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\SSAO.fx"), "PSBlur", "ps_5_0", nullptr, blob);
+		_sRooms = CompileOrLoadShader("Rooms", "", ShaderType::PixelAndVertex);
+		Utils::throwIfFailed(_device->CreateInputLayout(inputLayoutItems, 12, _sRooms.Vertex.Blob->GetBufferPointer(), _sRooms.Vertex.Blob->GetBufferSize(), &_inputLayout));
+
+		_sRoomsAnimated = CompileOrLoadShader("Rooms", "", ShaderType::Vertex, &roomDefinesAnimated[0]);
+		_sItems = CompileOrLoadShader("Items", "", ShaderType::PixelAndVertex);
+		_sStatics = CompileOrLoadShader("Statics", "", ShaderType::PixelAndVertex);
+		_sSky = CompileOrLoadShader("Sky", "", ShaderType::PixelAndVertex);
+		_sSprites = CompileOrLoadShader("Sprites", "", ShaderType::PixelAndVertex);
+		_sSolid = CompileOrLoadShader("Solid", "", ShaderType::PixelAndVertex);
+		_sInventory = CompileOrLoadShader("Inventory", "", ShaderType::PixelAndVertex);
+		_sFullScreenQuad = CompileOrLoadShader("FullScreenQuad", "", ShaderType::PixelAndVertex);
+		_sShadowMap = CompileOrLoadShader("ShadowMap", "", ShaderType::PixelAndVertex, &roomDefinesShadowMap[0]);
+		_sHUD = CompileOrLoadShader("HUD", "", ShaderType::Vertex);
+		_sHUDColor = CompileOrLoadShader("HUD", "ColoredHUD", ShaderType::Pixel);
+		_sHUDTexture = CompileOrLoadShader("HUD", "TexturedHUD", ShaderType::Pixel);
+		_sHUDBarColor = CompileOrLoadShader("HUD", "TexturedHUDBar", ShaderType::Pixel);
+		_sInstancedStatics = CompileOrLoadShader("InstancedStatics", "", ShaderType::PixelAndVertex);
+		_sInstancedSprites = CompileOrLoadShader("InstancedSprites", "", ShaderType::PixelAndVertex);
+
+		_sGBuffer = CompileOrLoadShader("GBuffer", "", ShaderType::Pixel);
+		_sGBufferRooms = CompileOrLoadShader("GBuffer", "Rooms", ShaderType::Vertex);
+		_sGBufferRoomsAnimated = CompileOrLoadShader("GBuffer", "Rooms", ShaderType::Vertex, &roomDefinesAnimated[0]);
+		_sGBufferItems = CompileOrLoadShader("GBuffer", "Items", ShaderType::Vertex);
+		_sGBufferStatics = CompileOrLoadShader("GBuffer", "Statics", ShaderType::Vertex);
+		_sGBufferInstancedStatics = CompileOrLoadShader("GBuffer", "InstancedStatics", ShaderType::Vertex);
+
+		_sRoomAmbient = CompileOrLoadShader("RoomAmbient", "", ShaderType::PixelAndVertex);
+		_sRoomAmbientSky = CompileOrLoadShader("RoomAmbient", "Sky", ShaderType::Vertex);
+		_sFXAA = CompileOrLoadShader("FXAA", "", ShaderType::Pixel);
+		_sSSAO = CompileOrLoadShader("SSAO", "", ShaderType::Pixel);
+		_sSSAOBlur = CompileOrLoadShader("SSAO", "Blur", ShaderType::Pixel);
 
 		const D3D_SHADER_MACRO transparentDefines[] = { "TRANSPARENT", "", nullptr, nullptr };
-		_psRoomsTransparent = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\Rooms.fx"), "PS", "ps_5_0", &transparentDefines[0], blob);
+		_sRoomsTransparent = CompileOrLoadShader("Rooms", "", ShaderType::Pixel, &transparentDefines[0]);
 
 		// Initialize constant buffers
 		_cbCameraMatrices = CreateConstantBuffer<CCameraMatrixBuffer>();
@@ -292,9 +285,7 @@ namespace TEN::Renderer
 
 		_fullscreenTriangleVertexBuffer = VertexBuffer<PostProcessVertex>(_device.Get(), 3, &vertices[0]);
 
-		ComPtr<ID3D10Blob> blob;
-
-		_vsPostProcess = Utils::compileVertexShader(_device.Get(), GetAssetPath(L"Shaders\\PostProcess.fx"), "VS", "vs_5_0", nullptr, blob);
+		_sPostProcess = CompileOrLoadShader("PostProcess", "", ShaderType::PixelAndVertex);
 
 		D3D11_INPUT_ELEMENT_DESC postProcessInputLayoutItems[] =
 		{
@@ -302,14 +293,15 @@ namespace TEN::Renderer
 			{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
 			{ "COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 }
 		};
-		Utils::throwIfFailed(_device->CreateInputLayout(postProcessInputLayoutItems, 3, blob->GetBufferPointer(), blob->GetBufferSize(), &_fullscreenTriangleInputLayout));
-		        
-		_psPostProcessCopy = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\PostProcess.fx"), "PSCopy", "ps_5_0", nullptr, blob);
-		_psPostProcessMonochrome = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\PostProcess.fx"), "PSMonochrome", "ps_5_0", nullptr, blob);
-		_psPostProcessNegative = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\PostProcess.fx"), "PSNegative", "ps_5_0", nullptr, blob);
-		_psPostProcessExclusion = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\PostProcess.fx"), "PSExclusion", "ps_5_0", nullptr, blob);
-		_psPostProcessFinalPass = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\PostProcess.fx"), "PSFinalPass", "ps_5_0", nullptr, blob);
-		_psPostProcessLensFlare = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\PostProcess.fx"), "PSLensFlare", "ps_5_0", nullptr, blob);
+
+		Utils::throwIfFailed(_device->CreateInputLayout(postProcessInputLayoutItems, 3, 
+							 _sPostProcess.Vertex.Blob->GetBufferPointer(), _sPostProcess.Vertex.Blob->GetBufferSize(), &_fullscreenTriangleInputLayout));
+
+		_sPostProcessMonochrome = CompileOrLoadShader("PostProcess", "Monochrome", ShaderType::Pixel);
+		_sPostProcessNegative   = CompileOrLoadShader("PostProcess", "Negative",   ShaderType::Pixel);
+		_sPostProcessExclusion  = CompileOrLoadShader("PostProcess", "Exclusion",  ShaderType::Pixel);
+		_sPostProcessFinalPass  = CompileOrLoadShader("PostProcess", "FinalPass",  ShaderType::Pixel);
+		_sPostProcessLensFlare  = CompileOrLoadShader("PostProcess", "LensFlare",  ShaderType::Pixel);
 	}
 
 	void Renderer::CreateSSAONoiseTexture()
@@ -597,16 +589,12 @@ namespace TEN::Renderer
 		auto null = D3D10_SHADER_MACRO{ nullptr, nullptr };
 		defines.push_back(null);
 
-		auto blob = ComPtr<ID3D10Blob>{};
-		_SMAALumaEdgeDetectionPS = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\SMAA.fx"), "DX11_SMAALumaEdgeDetectionPS", "ps_5_0", defines.data(), blob);
-		_SMAAColorEdgeDetectionPS = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\SMAA.fx"), "DX11_SMAAColorEdgeDetectionPS", "ps_5_0", defines.data(), blob);
-		_SMAADepthEdgeDetectionPS = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\SMAA.fx"), "DX11_SMAADepthEdgeDetectionPS", "ps_5_0", defines.data(), blob);
-		_SMAABlendingWeightCalculationPS = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\SMAA.fx"), "DX11_SMAABlendingWeightCalculationPS", "ps_5_0", defines.data(), blob);
-		_SMAANeighborhoodBlendingPS = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\SMAA.fx"), "DX11_SMAANeighborhoodBlendingPS", "ps_5_0", defines.data(), blob);
-		_SMAAEdgeDetectionVS = Utils::compileVertexShader(_device.Get(), GetAssetPath(L"Shaders\\SMAA.fx"), "DX11_SMAAEdgeDetectionVS", "vs_5_0", defines.data(), blob);
-		_SMAABlendingWeightCalculationVS = Utils::compileVertexShader(_device.Get(), GetAssetPath(L"Shaders\\SMAA.fx"), "DX11_SMAABlendingWeightCalculationVS", "vs_5_0", defines.data(), blob);
-		_SMAANeighborhoodBlendingVS = Utils::compileVertexShader(_device.Get(), GetAssetPath(L"Shaders\\SMAA.fx"), "DX11_SMAANeighborhoodBlendingVS", "vs_5_0", defines.data(), blob);
-
+		_sSMAALumaEdgeDetection = CompileOrLoadShader("SMAA", "LumaEdgeDetection", ShaderType::Pixel, defines.data());
+		_sSMAAColorEdgeDetection = CompileOrLoadShader("SMAA", "ColorEdgeDetection", ShaderType::Pixel, defines.data());
+		_sSMAADepthEdgeDetection = CompileOrLoadShader("SMAA", "DepthEdgeDetection", ShaderType::Pixel, defines.data());
+		_sSMAABlendingWeightCalculation = CompileOrLoadShader("SMAA", "BlendingWeightCalculation", ShaderType::PixelAndVertex, defines.data());
+		_sSMAANeighborhoodBlending = CompileOrLoadShader("SMAA", "NeighborhoodBlending", ShaderType::PixelAndVertex, defines.data());
+		_sSMAAEdgeDetection = CompileOrLoadShader("SMAA", "EdgeDetection", ShaderType::Vertex, defines.data());
 	}
 
 	void Renderer::InitializeCommonTextures()
@@ -688,4 +676,152 @@ namespace TEN::Renderer
 
 		UpdateWindow(WindowsHandle);
 	}
+
+	void Renderer::BindShader(const RendererShader& shader)
+	{
+		if (shader.Vertex.Shader != nullptr)  _context->VSSetShader(shader.Vertex.Shader.Get(), nullptr, 0);
+		if (shader.Pixel.Shader != nullptr)   _context->PSSetShader(shader.Pixel.Shader.Get(), nullptr, 0);
+		if (shader.Compute.Shader != nullptr) _context->CSSetShader(shader.Compute.Shader.Get(), nullptr, 0);
+	}
+
+	RendererShader Renderer::CompileOrLoadShader(const std::string& fileName, const std::string& funcName, ShaderType type, const D3D_SHADER_MACRO* defines)
+	{
+		RendererShader result = {};
+
+		// We need to increment the counter to avoid overwriting compiled shaders with the same source file name.
+		static int compileCounter = 0;
+
+		// Define paths for native (uncompiled) shaders and compiled shaders.
+		std::wstring shaderPath = GetAssetPath(L"Shaders\\");
+		std::wstring compiledShaderPath = shaderPath + L"Bin\\";
+		std::wstring wideFileName = TEN::Utils::ToWString(fileName);
+
+		// Ensure the /Bin subdirectory exists.
+		std::filesystem::create_directories(compiledShaderPath);
+
+		// Helper function to load or compile a shader.
+		auto loadOrCompileShader = [this, type, defines, shaderPath, compiledShaderPath]
+		(const std::wstring& baseFileName, const std::string& shaderType, const std::string& functionName, const char* model, ComPtr<ID3D10Blob>& bytecode)
+		{
+			// Construct the full paths using GetAssetPath.
+			auto prefix = ((compileCounter < 10) ? L"0" : L"") + std::to_wstring(compileCounter) + L"_";
+			auto csoFileName = compiledShaderPath + prefix + baseFileName + L"." + std::wstring(shaderType.begin(), shaderType.end()) + L".cso";
+			auto srcFileName = shaderPath + baseFileName;
+
+			// Try both .hlsl and .fx extensions for the source shader.
+			auto srcFileNameWithExtension = srcFileName + L".hlsl";
+			if (!std::filesystem::exists(srcFileNameWithExtension))
+			{
+				srcFileNameWithExtension = srcFileName + L".fx";
+				if (!std::filesystem::exists(srcFileNameWithExtension))
+				{
+					TENLog("Shader source file not found: " + TEN::Utils::ToString(srcFileNameWithExtension), LogLevel::Error);
+					throw std::runtime_error("Shader source file not found");
+				}
+			}
+
+			// Check modification dates of the source and compiled files.
+			bool shouldRecompile = false;
+			if (std::filesystem::exists(csoFileName))
+			{
+				auto csoTime = std::filesystem::last_write_time(csoFileName);
+				auto srcTime = std::filesystem::last_write_time(srcFileNameWithExtension);
+				shouldRecompile = srcTime > csoTime; // Recompile if the source is newer.
+			}
+
+			// Load compiled shader if it exists and is up to date.
+			if (!shouldRecompile)
+			{
+				std::ifstream csoFile(csoFileName, std::ios::binary);
+
+				if (csoFile.is_open())
+				{
+					// Load compiled shader.
+					csoFile.seekg(0, std::ios::end);
+					size_t fileSize = csoFile.tellg();
+					csoFile.seekg(0, std::ios::beg);
+
+					std::vector<char> buffer(fileSize);
+					csoFile.read(buffer.data(), fileSize);
+					csoFile.close();
+
+					D3DCreateBlob(fileSize, &bytecode);
+					memcpy(bytecode->GetBufferPointer(), buffer.data(), fileSize);
+
+					return;
+				}
+			}
+
+			// Set up compilation flags according to the build configuration.
+			unsigned int flags = D3DCOMPILE_ENABLE_STRICTNESS | D3DCOMPILE_PACK_MATRIX_ROW_MAJOR;
+
+			if constexpr (DebugBuild)
+				flags |= D3DCOMPILE_DEBUG | D3DCOMPILE_SKIP_OPTIMIZATION;
+			else
+				flags |= D3DCOMPILE_OPTIMIZATION_LEVEL3 | D3DCOMPILE_IEEE_STRICTNESS;
+
+			auto trimmedFileName = std::filesystem::path(srcFileNameWithExtension).filename().string();
+			TENLog("Compiling shader: " + trimmedFileName, LogLevel::Info);
+
+			// Compile shader.
+			ComPtr<ID3D10Blob> errors;
+			HRESULT res = D3DCompileFromFile(srcFileNameWithExtension.c_str(), defines, D3D_COMPILE_STANDARD_FILE_INCLUDE,
+				(shaderType + functionName).c_str(), model, flags, 0, bytecode.GetAddressOf(), errors.GetAddressOf());
+
+			if (FAILED(res))
+			{
+				if (errors)
+				{
+					auto error = std::string(static_cast<const char*>(errors->GetBufferPointer()));
+					TENLog(error, LogLevel::Error);
+					throw std::runtime_error(error);
+				}
+				else
+				{
+					TENLog("Error while compiling shader: " + trimmedFileName, LogLevel::Error);
+					throwIfFailed(res);
+				}
+			}
+
+			// Save compiled shader to .cso file.
+			std::ofstream outCsoFile(csoFileName, std::ios::binary);
+			if (outCsoFile.is_open())
+			{
+				outCsoFile.write(reinterpret_cast<const char*>(bytecode->GetBufferPointer()), bytecode->GetBufferSize());
+				outCsoFile.close();
+			}
+		};
+
+		// Load or compile and create pixel shader.
+		if (type == ShaderType::Pixel || type == ShaderType::PixelAndVertex)
+		{
+			loadOrCompileShader(wideFileName, "PS", funcName, "ps_5_0", result.Pixel.Blob);
+			throwIfFailed(_device->CreatePixelShader(result.Pixel.Blob->GetBufferPointer(), result.Pixel.Blob->GetBufferSize(),
+				nullptr, result.Pixel.Shader.GetAddressOf()
+			));
+		}
+
+		// Load or compile and create vertex shader.
+		if (type == ShaderType::Vertex || type == ShaderType::PixelAndVertex)
+		{
+			loadOrCompileShader(wideFileName, "VS", funcName, "vs_5_0", result.Vertex.Blob);
+			throwIfFailed(_device->CreateVertexShader(result.Vertex.Blob->GetBufferPointer(), result.Vertex.Blob->GetBufferSize(),
+				nullptr, result.Vertex.Shader.GetAddressOf()
+			));
+		}
+
+		// Load or compile and create compute shader.
+		if (type == ShaderType::Compute)
+		{
+			loadOrCompileShader(wideFileName, "CS", funcName, "cs_5_0", result.Compute.Blob);
+			throwIfFailed(_device->CreateComputeShader(result.Compute.Blob->GetBufferPointer(), result.Compute.Blob->GetBufferSize(),
+				nullptr, result.Compute.Shader.GetAddressOf()
+			));
+		}
+
+		// Increment the compile counter.
+		compileCounter++;
+
+		return result;
+	}
 }
\ No newline at end of file
diff --git a/TombEngine/Renderer/RendererPostProcess.cpp b/TombEngine/Renderer/RendererPostProcess.cpp
index b253b38df..2abdceec2 100644
--- a/TombEngine/Renderer/RendererPostProcess.cpp
+++ b/TombEngine/Renderer/RendererPostProcess.cpp
@@ -42,7 +42,7 @@ namespace TEN::Renderer
 		_cbPostProcessBuffer.UpdateData(_stPostProcessBuffer, _context.Get());
 
 		// Common vertex shader to all fullscreen effects.
-		_context->VSSetShader(_vsPostProcess.Get(), nullptr, 0);
+		BindShader(_sPostProcess);
 
 		// Draw fullscreen triangle.
 		_context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
@@ -58,7 +58,6 @@ namespace TEN::Renderer
 		_context->ClearRenderTargetView(_postProcessRenderTarget[0].RenderTargetView.Get(), clearColor);
 		_context->OMSetRenderTargets(1, _postProcessRenderTarget[0].RenderTargetView.GetAddressOf(), nullptr);
 
-		_context->PSSetShader(_psPostProcessCopy.Get(), nullptr, 0);
 		BindRenderTargetAsTexture(TextureRegister::ColorMap, &_renderTarget, SamplerStateRegister::PointWrap);
 		DrawTriangles(3, 0);
 
@@ -66,44 +65,13 @@ namespace TEN::Renderer
 		int currentRenderTarget = 0;
 		int destRenderTarget = 1;
 
-		// Apply color scheme.
-		if (_postProcessMode != PostProcessMode::None && _postProcessStrength > EPSILON)
-		{
-			_context->ClearRenderTargetView(_postProcessRenderTarget[destRenderTarget].RenderTargetView.Get(), clearColor);
-			_context->OMSetRenderTargets(1, _postProcessRenderTarget[destRenderTarget].RenderTargetView.GetAddressOf(), nullptr);
-
-			switch (_postProcessMode)
-			{
-			case PostProcessMode::Monochrome:
-				_context->PSSetShader(_psPostProcessMonochrome.Get(), nullptr, 0);
-				break;
-
-			case PostProcessMode::Negative:
-				_context->PSSetShader(_psPostProcessNegative.Get(), nullptr, 0);
-				break;
-
-			case PostProcessMode::Exclusion:
-				_context->PSSetShader(_psPostProcessExclusion.Get(), nullptr, 0);
-				break;
-
-			default:
-				return;
-			}
-
-			BindRenderTargetAsTexture(TextureRegister::ColorMap, &_postProcessRenderTarget[currentRenderTarget], SamplerStateRegister::PointWrap);
-			DrawTriangles(3, 0);
-
-			destRenderTarget = (destRenderTarget == 1) ? 0 : 1;
-			currentRenderTarget = (currentRenderTarget == 1) ? 0 : 1;
-		}
-
 		// Lens flares.
 		if (!view.LensFlaresToDraw.empty())
 		{
 			_context->ClearRenderTargetView(_postProcessRenderTarget[destRenderTarget].RenderTargetView.Get(), clearColor);
 			_context->OMSetRenderTargets(1, _postProcessRenderTarget[destRenderTarget].RenderTargetView.GetAddressOf(), nullptr);
 
-			_context->PSSetShader(_psPostProcessLensFlare.Get(), nullptr, 0);
+			BindShader(_sPostProcessLensFlare);
 
 			for (int i = 0; i < view.LensFlaresToDraw.size(); i++)
 			{
@@ -120,8 +88,39 @@ namespace TEN::Renderer
 			currentRenderTarget = (currentRenderTarget == 1) ? 0 : 1;
 		}
 
+		// Apply color scheme.
+		if (_postProcessMode != PostProcessMode::None && _postProcessStrength > EPSILON)
+		{
+			_context->ClearRenderTargetView(_postProcessRenderTarget[destRenderTarget].RenderTargetView.Get(), clearColor);
+			_context->OMSetRenderTargets(1, _postProcessRenderTarget[destRenderTarget].RenderTargetView.GetAddressOf(), nullptr);
+
+			switch (_postProcessMode)
+			{
+			case PostProcessMode::Monochrome:
+				BindShader(_sPostProcessMonochrome);
+				break;
+
+			case PostProcessMode::Negative:
+				BindShader(_sPostProcessNegative);
+				break;
+
+			case PostProcessMode::Exclusion:
+				BindShader(_sPostProcessExclusion);
+				break;
+
+			default:
+				return;
+			}
+
+			BindRenderTargetAsTexture(TextureRegister::ColorMap, &_postProcessRenderTarget[currentRenderTarget], SamplerStateRegister::PointWrap);
+			DrawTriangles(3, 0);
+
+			destRenderTarget = (destRenderTarget == 1) ? 0 : 1;
+			currentRenderTarget = (currentRenderTarget == 1) ? 0 : 1;
+		}
+
 		// Do final pass.
-		_context->PSSetShader(_psPostProcessFinalPass.Get(), nullptr, 0);
+		BindShader(_sPostProcessFinalPass);
 
 		_context->ClearRenderTargetView(renderTarget->RenderTargetView.Get(), Colors::Black);
 		_context->OMSetRenderTargets(1, renderTarget->RenderTargetView.GetAddressOf(), nullptr);
@@ -173,7 +172,7 @@ namespace TEN::Renderer
 		ResetScissor();
 
 		// Common vertex shader to all fullscreen effects
-		_context->VSSetShader(_vsPostProcess.Get(), nullptr, 0);
+		BindShader(_sPostProcess);
 
 		// We draw a fullscreen triangle
 		_context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
@@ -188,7 +187,6 @@ namespace TEN::Renderer
 		_context->ClearRenderTargetView(dest->RenderTargetView.Get(), clearColor);
 		_context->OMSetRenderTargets(1, dest->RenderTargetView.GetAddressOf(), nullptr);
 
-		_context->PSSetShader(_psPostProcessCopy.Get(), nullptr, 0);
 		BindRenderTargetAsTexture(TextureRegister::ColorMap, source, SamplerStateRegister::PointWrap);
 		DrawTriangles(3, 0);
 	}
diff --git a/TombEngine/Renderer/RendererSprites.cpp b/TombEngine/Renderer/RendererSprites.cpp
index 983f4a8cc..a4cc72c7c 100644
--- a/TombEngine/Renderer/RendererSprites.cpp
+++ b/TombEngine/Renderer/RendererSprites.cpp
@@ -279,8 +279,7 @@ namespace TEN::Renderer
 				SetDepthState(DepthState::Read);
 				SetCullMode(CullMode::None);
 
-				_context->VSSetShader(_vsInstancedSprites.Get(), nullptr, 0);
-				_context->PSSetShader(_psInstancedSprites.Get(), nullptr, 0);
+				BindShader(_sInstancedSprites);
 
 				// Set up vertex buffer and parameters.
 				unsigned int stride = sizeof(Vertex);
@@ -341,8 +340,7 @@ namespace TEN::Renderer
 				SetDepthState(DepthState::Read);
 				SetCullMode(CullMode::None);
 
-				_context->VSSetShader(_vsSprites.Get(), nullptr, 0);
-				_context->PSSetShader(_psSprites.Get(), nullptr, 0);
+				BindShader(_sSprites);
 
 				wasGPUSet = true;
 			}
@@ -413,8 +411,7 @@ namespace TEN::Renderer
 			SetBlendMode(object->Sprite->BlendMode);
 			SetAlphaTest(AlphaTestMode::GreatherThan, ALPHA_TEST_THRESHOLD);
 
-			_context->VSSetShader(_vsInstancedSprites.Get(), nullptr, 0);
-			_context->PSSetShader(_psInstancedSprites.Get(), nullptr, 0);
+			BindShader(_sInstancedSprites);
 
 			// Set up vertex buffer and parameters.
 			UINT stride = sizeof(Vertex);
@@ -459,8 +456,7 @@ namespace TEN::Renderer
 			SetBlendMode(object->Sprite->BlendMode);
 			SetAlphaTest(AlphaTestMode::GreatherThan, ALPHA_TEST_THRESHOLD);
 
-			_context->VSSetShader(_vsSprites.Get(), nullptr, 0);
-			_context->PSSetShader(_psSprites.Get(), nullptr, 0);
+			BindShader(_sSprites);
 
 			_stSprite.IsSoftParticle = object->Sprite->SoftParticle ? 1 : 0;
 			_stSprite.RenderType = (int)object->Sprite->renderType;
@@ -505,8 +501,7 @@ namespace TEN::Renderer
 		UINT stride = sizeof(Vertex);
 		UINT offset = 0;
 
-		_context->VSSetShader(_vsSprites.Get(), nullptr, 0);
-		_context->PSSetShader(_psSprites.Get(), nullptr, 0);
+		BindShader(_sSprites);
 
 		_sortedPolygonsVertexBuffer.Update(_context.Get(), _sortedPolygonsVertices.data(), 0, (int)_sortedPolygonsVertices.size());
 
diff --git a/TombEngine/Renderer/RendererUtils.cpp b/TombEngine/Renderer/RendererUtils.cpp
index b6601bbe2..ae6b6a030 100644
--- a/TombEngine/Renderer/RendererUtils.cpp
+++ b/TombEngine/Renderer/RendererUtils.cpp
@@ -1,20 +1,18 @@
 #include "framework.h"
+
 #include <codecvt>
 #include <d3dcompiler.h>
 #include <locale>
 #include <iostream>
 #include <winerror.h>
 #include <wrl/client.h>
+
 #include "Renderer/Renderer.h"
 #include "Specific/trutils.h"
+#include "Structures/RendererShader.h"
 
 namespace TEN::Renderer::Utils
 {
-	using std::wstring;
-	using std::string;
-	using Microsoft::WRL::ComPtr;
-	using std::vector;
-
 	void throwIfFailed(const HRESULT& res) 
 	{
 		if (FAILED(res))
@@ -44,119 +42,4 @@ namespace TEN::Renderer::Utils
 			throw std::runtime_error("An error occured!");
 		}
 	}
-
-	ComPtr<ID3D11VertexShader> compileVertexShader(ID3D11Device* device, const std::wstring& fileName, const std::string& function, const std::string& model, const D3D_SHADER_MACRO * defines, ComPtr<ID3D10Blob>& bytecode) 
-	{
-		ComPtr<ID3D10Blob> errors;
-		HRESULT res = (D3DCompileFromFile(fileName.c_str(), defines, D3D_COMPILE_STANDARD_FILE_INCLUDE, function.c_str(), model.c_str(), GetShaderFlags(), 0, bytecode.GetAddressOf(),errors.GetAddressOf()));
-		if (FAILED(res))
-		{
-			ID3D10Blob* errorObj = errors.Get();
-			if (errorObj != nullptr)
-			{
-				auto error = std::string((char*)errorObj->GetBufferPointer());
-				TENLog(error, LogLevel::Error);
-				throw std::runtime_error(error);
-			} 
-			else
-			{
-				TENLog("Error while compiling VS shader: " + TEN::Utils::ToString(fileName.c_str()), LogLevel::Error);
-				throwIfFailed(res);
-			}
-		}
-
-		ComPtr<ID3D11VertexShader> shader;
-		throwIfFailed(device->CreateVertexShader(bytecode->GetBufferPointer(), bytecode->GetBufferSize(), nullptr, shader.GetAddressOf()));
-		
-		if constexpr (DebugBuild)
-		{
-			char buffer[100];
-			unsigned int size = (unsigned int)std::wcstombs(buffer, fileName.c_str(), 100);
-			shader->SetPrivateData(WKPDID_D3DDebugObjectName, size, buffer);
-		}
-
-		return shader;
-	}
-
-	ComPtr<ID3D11PixelShader> compilePixelShader(ID3D11Device* device, const wstring& fileName, const string& function, const string& model, const D3D_SHADER_MACRO* defines, ComPtr<ID3D10Blob>& bytecode)
-	{
-		ComPtr<ID3D10Blob> errors;
-		HRESULT res = (D3DCompileFromFile(fileName.c_str(), defines, D3D_COMPILE_STANDARD_FILE_INCLUDE, function.c_str(), model.c_str(), GetShaderFlags(), 0, bytecode.GetAddressOf(), errors.GetAddressOf()));
-		if (FAILED(res))
-		{
-			ID3D10Blob* errorObj = errors.Get();
-			if (errorObj != nullptr)
-			{
-				auto error = std::string((char*)errorObj->GetBufferPointer());
-				TENLog(error, LogLevel::Error);
-				throw std::runtime_error(error);
-			}
-			else
-			{
-				TENLog("Error while compiling PS shader: " + TEN::Utils::ToString(fileName.c_str()), LogLevel::Error);
-				throwIfFailed(res);
-			}
-		}
-
-		ComPtr<ID3D11PixelShader> shader;
-		throwIfFailed(device->CreatePixelShader(bytecode->GetBufferPointer(), bytecode->GetBufferSize(), nullptr, shader.GetAddressOf()));
-
-		if constexpr (DebugBuild)
-		{
-			char buffer[100];
-			unsigned int size = (unsigned int)std::wcstombs(buffer, fileName.c_str(), 100);
-			shader->SetPrivateData(WKPDID_D3DDebugObjectName, size, buffer);
-		}
-
-		return shader;
-	}
-
-	ComPtr<ID3D11ComputeShader> compileComputeShader(ID3D11Device* device, const wstring& fileName, const string& function, const string& model, const D3D_SHADER_MACRO* defines, ComPtr<ID3D10Blob>& bytecode)
-	{
-		auto errors = ComPtr<ID3D10Blob>{};
-		auto res = D3DCompileFromFile(fileName.c_str(), defines, D3D_COMPILE_STANDARD_FILE_INCLUDE, function.c_str(), model.c_str(), GetShaderFlags(), 0, bytecode.GetAddressOf(), errors.GetAddressOf());
-		if (FAILED(res))
-		{
-			auto* errorObj = errors.Get();
-			if (errorObj != nullptr)
-			{
-				auto error = std::string((char*)errorObj->GetBufferPointer());
-				TENLog(error, LogLevel::Error);
-				throw std::runtime_error(error);
-			}
-			else
-			{
-				TENLog("Error while compiling CS shader: " + TEN::Utils::ToString(fileName.c_str()), LogLevel::Error);
-				throwIfFailed(res);
-			}
-		}
-
-		auto shader = ComPtr<ID3D11ComputeShader>{};
-		throwIfFailed(device->CreateComputeShader(bytecode->GetBufferPointer(), bytecode->GetBufferSize(), nullptr, shader.GetAddressOf()));
-
-		if constexpr (DebugBuild)
-		{
-			char buffer[100];
-			unsigned int size = (unsigned int)std::wcstombs(buffer, fileName.c_str(), 100);
-			shader->SetPrivateData(WKPDID_D3DDebugObjectName, size, buffer);
-		}
-
-		return shader;
-	}
-	
-	constexpr unsigned int Utils::GetShaderFlags()
-	{
-		unsigned int flags = D3DCOMPILE_ENABLE_STRICTNESS | D3DCOMPILE_PACK_MATRIX_ROW_MAJOR;
-
-		if constexpr (DebugBuild)
-		{
-			flags |= D3DCOMPILE_DEBUG | D3DCOMPILE_SKIP_OPTIMIZATION;
-		}
-		else
-		{
-			flags |= D3DCOMPILE_OPTIMIZATION_LEVEL3 | D3DCOMPILE_IEEE_STRICTNESS;
-		}
-		
-		return flags;
-	}
 }
diff --git a/TombEngine/Renderer/RendererUtils.h b/TombEngine/Renderer/RendererUtils.h
index 2efd92ba2..8fc12b203 100644
--- a/TombEngine/Renderer/RendererUtils.h
+++ b/TombEngine/Renderer/RendererUtils.h
@@ -9,9 +9,4 @@ namespace TEN::Renderer::Utils
 	void throwIfFailed(const HRESULT& res);
 	void throwIfFailed(const HRESULT& res, const std::string& info);
 	void throwIfFailed(const HRESULT& res, const std::wstring& info);
-
-	[[nodiscard]] Microsoft::WRL::ComPtr<ID3D11VertexShader> compileVertexShader(ID3D11Device* device, const std::wstring& fileName, const std::string& function, const std::string& model, const D3D_SHADER_MACRO* defines, Microsoft::WRL::ComPtr<ID3D10Blob>& bytecode);
-	constexpr [[nodiscard]] unsigned int GetShaderFlags();
-	[[nodiscard]] Microsoft::WRL::ComPtr<ID3D11PixelShader> compilePixelShader(ID3D11Device* device, const std::wstring& fileName, const std::string& function, const std::string& model, const D3D_SHADER_MACRO* defines, Microsoft::WRL::ComPtr<ID3D10Blob>& bytecode);
-	[[nodiscard]] Microsoft::WRL::ComPtr<ID3D11ComputeShader> compileComputeShader(ID3D11Device* device, const std::wstring& fileName, const std::string& function, const std::string& model, const D3D_SHADER_MACRO* defines, Microsoft::WRL::ComPtr<ID3D10Blob>& bytecode);
 }
diff --git a/TombEngine/Renderer/Structures/RendererShader.h b/TombEngine/Renderer/Structures/RendererShader.h
new file mode 100644
index 000000000..af6b8b08a
--- /dev/null
+++ b/TombEngine/Renderer/Structures/RendererShader.h
@@ -0,0 +1,42 @@
+#pragma once
+#include <wrl/client.h>
+#include <d3d11.h>
+#include <utility>
+
+using Microsoft::WRL::ComPtr;
+
+namespace TEN::Renderer::Structures
+{
+	enum class ShaderType
+	{
+		Pixel,
+		Vertex,
+		PixelAndVertex,
+		Compute
+	};
+
+	struct RendererPixelShaderAndBlob
+	{
+		ComPtr<ID3D11PixelShader> Shader = nullptr;
+		ComPtr<ID3D10Blob> Blob;
+	};
+
+	struct RendererVertexShaderAndBlob
+	{
+		ComPtr<ID3D11VertexShader> Shader = nullptr;
+		ComPtr<ID3D10Blob> Blob;
+	};
+
+	struct RendererComputeShaderAndBlob
+	{
+		ComPtr<ID3D11ComputeShader> Shader = nullptr;
+		ComPtr<ID3D10Blob> Blob;
+	};
+
+	struct RendererShader
+	{
+		RendererPixelShaderAndBlob   Pixel;
+		RendererVertexShaderAndBlob  Vertex;
+		RendererComputeShaderAndBlob Compute;
+	};
+}
\ No newline at end of file
diff --git a/TombEngine/Shaders/HUD.hlsl b/TombEngine/Shaders/HUD.fx
similarity index 100%
rename from TombEngine/Shaders/HUD.hlsl
rename to TombEngine/Shaders/HUD.fx
diff --git a/TombEngine/Shaders/PostProcess.fx b/TombEngine/Shaders/PostProcess.fx
index fc66398a7..79c3ebef2 100644
--- a/TombEngine/Shaders/PostProcess.fx
+++ b/TombEngine/Shaders/PostProcess.fx
@@ -32,7 +32,7 @@ PixelShaderInput VS(VertexShaderInput input)
     return output;
 }
 
-float4 PSCopy(PixelShaderInput input) : SV_Target
+float4 PS(PixelShaderInput input) : SV_Target
 {
     return ColorTexture.Sample(ColorSampler, input.UV);
 }
diff --git a/TombEngine/Shaders/SMAA.fx b/TombEngine/Shaders/SMAA.fx
index 63b1c42e3..ff4af2432 100644
--- a/TombEngine/Shaders/SMAA.fx
+++ b/TombEngine/Shaders/SMAA.fx
@@ -139,7 +139,7 @@ Texture2D searchTex : register(t8);
 /**
  * Function wrappers
  */
-void DX11_SMAAEdgeDetectionVS(float3 position : POSITION,
+void VSEdgeDetection(float3 position : POSITION,
     out float4 svPosition : SV_POSITION,
     inout float2 texcoord : TEXCOORD0,
     out float4 offset[3] : TEXCOORD1) {
@@ -147,7 +147,7 @@ void DX11_SMAAEdgeDetectionVS(float3 position : POSITION,
     SMAAEdgeDetectionVS(texcoord, offset);
 }
 
-void DX11_SMAABlendingWeightCalculationVS(float3 position : POSITION,
+void VSBlendingWeightCalculation(float3 position : POSITION,
     out float4 svPosition : SV_POSITION,
     inout float2 texcoord : TEXCOORD0,
     out float2 pixcoord : TEXCOORD1,
@@ -156,7 +156,7 @@ void DX11_SMAABlendingWeightCalculationVS(float3 position : POSITION,
     SMAABlendingWeightCalculationVS(texcoord, pixcoord, offset);
 }
 
-void DX11_SMAANeighborhoodBlendingVS(float3 position : POSITION,
+void VSNeighborhoodBlending(float3 position : POSITION,
     out float4 svPosition : SV_POSITION,
     inout float2 texcoord : TEXCOORD0,
     out float4 offset : TEXCOORD1) {
@@ -164,19 +164,19 @@ void DX11_SMAANeighborhoodBlendingVS(float3 position : POSITION,
     SMAANeighborhoodBlendingVS(texcoord, offset);
 }
 
-void DX11_SMAAResolveVS(float3 position : POSITION,
+void VSResolve(float3 position : POSITION,
     out float4 svPosition : SV_POSITION,
     inout float2 texcoord : TEXCOORD0) {
     svPosition = float4(position, 1.0f);
 }
 
-void DX11_SMAASeparateVS(float3 position : POSITION,
+void VSSeparate(float3 position : POSITION,
     out float4 svPosition : SV_POSITION,
     inout float2 texcoord : TEXCOORD0) {
     svPosition = float4(position, 1.0f);
 }
 
-float2 DX11_SMAALumaEdgeDetectionPS(float4 position : SV_POSITION,
+float2 PSLumaEdgeDetection(float4 position : SV_POSITION,
     float2 texcoord : TEXCOORD0,
     float4 offset[3] : TEXCOORD1) : SV_TARGET{
 #if SMAA_PREDICATION
@@ -186,7 +186,7 @@ return SMAALumaEdgeDetectionPS(texcoord, offset, colorTexGamma);
 #endif
 }
 
-float2 DX11_SMAAColorEdgeDetectionPS(float4 position : SV_POSITION,
+float2 PSColorEdgeDetection(float4 position : SV_POSITION,
     float2 texcoord : TEXCOORD0,
     float4 offset[3] : TEXCOORD1) : SV_TARGET{
 #if SMAA_PREDICATION
@@ -196,20 +196,20 @@ return SMAAColorEdgeDetectionPS(texcoord, offset, colorTexGamma);
 #endif
 }
 
-float2 DX11_SMAADepthEdgeDetectionPS(float4 position : SV_POSITION,
+float2 PSDepthEdgeDetection(float4 position : SV_POSITION,
     float2 texcoord : TEXCOORD0,
     float4 offset[3] : TEXCOORD1) : SV_TARGET{
 return SMAADepthEdgeDetectionPS(texcoord, offset, depthTex);
 }
 
-float4 DX11_SMAABlendingWeightCalculationPS(float4 position : SV_POSITION,
+float4 PSBlendingWeightCalculation(float4 position : SV_POSITION,
     float2 texcoord : TEXCOORD0,
     float2 pixcoord : TEXCOORD1,
     float4 offset[3] : TEXCOORD2) : SV_TARGET{
 return SMAABlendingWeightCalculationPS(texcoord, pixcoord, offset, edgesTex, areaTex, searchTex, subsampleIndices);
 }
 
-float4 DX11_SMAANeighborhoodBlendingPS(float4 position : SV_POSITION,
+float4 PSNeighborhoodBlending(float4 position : SV_POSITION,
     float2 texcoord : TEXCOORD0,
     float4 offset : TEXCOORD1) : SV_TARGET{
 #if SMAA_REPROJECTION
@@ -219,7 +219,7 @@ return SMAANeighborhoodBlendingPS(texcoord, offset, colorTex, blendTex);
 #endif
 }
 
-float4 DX11_SMAAResolvePS(float4 position : SV_POSITION,
+float4 PSResolve(float4 position : SV_POSITION,
     float2 texcoord : TEXCOORD0) : SV_TARGET{
 #if SMAA_REPROJECTION
 return SMAAResolvePS(texcoord, colorTex, colorTexPrev, velocityTex);
@@ -228,7 +228,7 @@ return SMAAResolvePS(texcoord, colorTex, colorTexPrev);
 #endif
 }
 
-void DX11_SMAASeparatePS(float4 position : SV_POSITION,
+void PSSeparate(float4 position : SV_POSITION,
     float2 texcoord : TEXCOORD0,
     out float4 target0 : SV_TARGET0,
     out float4 target1 : SV_TARGET1) {
@@ -240,9 +240,9 @@ void DX11_SMAASeparatePS(float4 position : SV_POSITION,
  */
 technique10 LumaEdgeDetection {
     pass LumaEdgeDetection {
-        SetVertexShader(CompileShader(vs_4_0, DX11_SMAAEdgeDetectionVS()));
+        SetVertexShader(CompileShader(vs_4_0, VSEdgeDetection()));
         SetGeometryShader(NULL);
-        SetPixelShader(CompileShader(PS_VERSION, DX11_SMAALumaEdgeDetectionPS()));
+        SetPixelShader(CompileShader(PS_VERSION, PSLumaEdgeDetection()));
 
         SetDepthStencilState(DisableDepthReplaceStencil, 1);
         SetBlendState(NoBlending, float4(0.0f, 0.0f, 0.0f, 0.0f), 0xFFFFFFFF);
@@ -251,9 +251,9 @@ technique10 LumaEdgeDetection {
 
 technique10 ColorEdgeDetection {
     pass ColorEdgeDetection {
-        SetVertexShader(CompileShader(vs_4_0, DX11_SMAAEdgeDetectionVS()));
+        SetVertexShader(CompileShader(vs_4_0, VSEdgeDetection()));
         SetGeometryShader(NULL);
-        SetPixelShader(CompileShader(PS_VERSION, DX11_SMAAColorEdgeDetectionPS()));
+        SetPixelShader(CompileShader(PS_VERSION, PSColorEdgeDetection()));
 
         SetDepthStencilState(DisableDepthReplaceStencil, 1);
         SetBlendState(NoBlending, float4(0.0f, 0.0f, 0.0f, 0.0f), 0xFFFFFFFF);
@@ -262,9 +262,9 @@ technique10 ColorEdgeDetection {
 
 technique10 DepthEdgeDetection {
     pass DepthEdgeDetection {
-        SetVertexShader(CompileShader(vs_4_0, DX11_SMAAEdgeDetectionVS()));
+        SetVertexShader(CompileShader(vs_4_0, VSEdgeDetection()));
         SetGeometryShader(NULL);
-        SetPixelShader(CompileShader(PS_VERSION, DX11_SMAADepthEdgeDetectionPS()));
+        SetPixelShader(CompileShader(PS_VERSION, PSDepthEdgeDetection()));
 
         SetDepthStencilState(DisableDepthReplaceStencil, 1);
         SetBlendState(NoBlending, float4(0.0f, 0.0f, 0.0f, 0.0f), 0xFFFFFFFF);
@@ -276,9 +276,9 @@ technique10 DepthEdgeDetection {
  */
 technique10 BlendingWeightCalculation {
     pass BlendingWeightCalculation {
-        SetVertexShader(CompileShader(vs_4_0, DX11_SMAABlendingWeightCalculationVS()));
+        SetVertexShader(CompileShader(vs_4_0, VSBlendingWeightCalculation()));
         SetGeometryShader(NULL);
-        SetPixelShader(CompileShader(PS_VERSION, DX11_SMAABlendingWeightCalculationPS()));
+        SetPixelShader(CompileShader(PS_VERSION, PSBlendingWeightCalculation()));
 
         SetDepthStencilState(DisableDepthUseStencil, 1);
         SetBlendState(NoBlending, float4(0.0f, 0.0f, 0.0f, 0.0f), 0xFFFFFFFF);
@@ -290,9 +290,9 @@ technique10 BlendingWeightCalculation {
  */
 technique10 NeighborhoodBlending {
     pass NeighborhoodBlending {
-        SetVertexShader(CompileShader(vs_4_0, DX11_SMAANeighborhoodBlendingVS()));
+        SetVertexShader(CompileShader(vs_4_0, VSNeighborhoodBlending()));
         SetGeometryShader(NULL);
-        SetPixelShader(CompileShader(PS_VERSION, DX11_SMAANeighborhoodBlendingPS()));
+        SetPixelShader(CompileShader(PS_VERSION, PSNeighborhoodBlending()));
 
         SetDepthStencilState(DisableDepthStencil, 0);
         SetBlendState(Blend, float4(blendFactor, blendFactor, blendFactor, blendFactor), 0xFFFFFFFF);
@@ -305,9 +305,9 @@ technique10 NeighborhoodBlending {
  */
 technique10 Resolve {
     pass Resolve {
-        SetVertexShader(CompileShader(vs_4_0, DX11_SMAAResolveVS()));
+        SetVertexShader(CompileShader(vs_4_0, VSResolve()));
         SetGeometryShader(NULL);
-        SetPixelShader(CompileShader(PS_VERSION, DX11_SMAAResolvePS()));
+        SetPixelShader(CompileShader(PS_VERSION, PSResolve()));
 
         SetDepthStencilState(DisableDepthStencil, 0);
         SetBlendState(NoBlending, float4(0.0f, 0.0f, 0.0f, 0.0f), 0xFFFFFFFF);
@@ -319,9 +319,9 @@ technique10 Resolve {
  */
 technique10 Separate {
     pass Separate {
-        SetVertexShader(CompileShader(vs_4_0, DX11_SMAASeparateVS()));
+        SetVertexShader(CompileShader(vs_4_0, VSSeparate()));
         SetGeometryShader(NULL);
-        SetPixelShader(CompileShader(PS_VERSION, DX11_SMAASeparatePS()));
+        SetPixelShader(CompileShader(PS_VERSION, PSSeparate()));
 
         SetDepthStencilState(DisableDepthStencil, 0);
         SetBlendState(NoBlending, float4(0.0f, 0.0f, 0.0f, 0.0f), 0xFFFFFFFF);
diff --git a/TombEngine/TombEngine.vcxproj b/TombEngine/TombEngine.vcxproj
index bfa6c4403..26cebdd14 100644
--- a/TombEngine/TombEngine.vcxproj
+++ b/TombEngine/TombEngine.vcxproj
@@ -88,7 +88,7 @@
     <IntDir>$(Configuration)\</IntDir>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <LinkIncremental>true</LinkIncremental>
+    <LinkIncremental>false</LinkIncremental>
     <OutDir>$(SolutionDir)Build\$(Configuration)\Bin\x86\</OutDir>
     <ExecutablePath>$(ExecutablePath);$(DXSDK_DIR)Utilities\bin\x86</ExecutablePath>
     <IncludePath>$(SolutionDir)Libs;$(SolutionDir)Libs\lua;$(SolutionDir)Libs\sol;$(SolutionDir)Libs\zlib;$(SolutionDir)Libs\spdlog;$(SolutionDir)Libs\ois;$(SolutionDir)Libs\bass;$(SolutionDir)Libs\srtparser;$(IncludePath)</IncludePath>
@@ -100,7 +100,7 @@
     <IncludePath>$(SolutionDir)Libs;$(SolutionDir)Libs\lua;$(SolutionDir)Libs\sol;$(SolutionDir)Libs\zlib;$(SolutionDir)Libs\spdlog;$(SolutionDir)Libs\ois;$(SolutionDir)Libs\bass;$(SolutionDir)Libs\srtparser;$(IncludePath)</IncludePath>
     <LibraryPath>$(LibraryPath);$(DXSDK_DIR)Lib\x64;$(SolutionDir)Libs\spdlog\x64;$(SolutionDir)Libs\lua\x64;$(SolutionDir)Libs\zlib\x64;$(SolutionDir)Libs\bass\x64;$(SolutionDir)Libs\ois\x64</LibraryPath>
     <TargetExt>.exe</TargetExt>
-    <LinkIncremental>true</LinkIncremental>
+    <LinkIncremental>false</LinkIncremental>
     <OutDir>$(SolutionDir)Build\$(Configuration)\Bin\x64\</OutDir>
     <IntDir>$(Configuration)\</IntDir>
     <TargetName>$(ProjectName)</TargetName>
@@ -321,7 +321,7 @@ if not exist "%ScriptsDir%\Strings.lua" xcopy /Y "$(SolutionDir)Scripts\Strings.
       <ImageHasSafeExceptionHandlers>false</ImageHasSafeExceptionHandlers>
       <LargeAddressAware>true</LargeAddressAware>
       <TargetMachine>MachineX86</TargetMachine>
-      <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
+      <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
     </Link>
     <PostBuildEvent>
       <Command>del "$(TargetDir)*.pdb" /q
@@ -400,7 +400,7 @@ if not exist "%ScriptsDir%\Strings.lua" xcopy /Y "$(SolutionDir)Scripts\Strings.
       <AdditionalDependencies>comctl32.lib;lua53.lib;bass.lib;bassmix.lib;bass_fx.lib;D3DCompiler.lib;dxgi.lib;dxguid.lib;d3d11.lib;version.lib;zlib.lib;spdlog.lib;OIS.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <ImageHasSafeExceptionHandlers>false</ImageHasSafeExceptionHandlers>
       <LargeAddressAware>true</LargeAddressAware>
-      <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
+      <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
     </Link>
     <PostBuildEvent>
       <Command>del "$(TargetDir)*.pdb" /q
@@ -854,6 +854,7 @@ if not exist "%ScriptsDir%\Strings.lua" xcopy /Y "$(SolutionDir)Scripts\Strings.
     <ClInclude Include="Renderer\Structures\RendererRoom.h" />
     <ClInclude Include="Renderer\Structures\RendererRoomAmbientMap.h" />
     <ClInclude Include="Renderer\Structures\RendererRoomNode.h" />
+    <ClInclude Include="Renderer\Structures\RendererShader.h" />
     <ClInclude Include="Renderer\Structures\RendererSortableObject.h" />
     <ClInclude Include="Renderer\Structures\RendererSprite.h" />
     <ClInclude Include="Renderer\Structures\RendererSprite2D.h" />