diff --git a/CMakeLists.txt b/CMakeLists.txt
index d47b5b6bf..93eec4dec 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -9,15 +9,21 @@ if (${CMAKE_SOURCE_DIR} STREQUAL ${CMAKE_BINARY_DIR})
     )
 endif()
 
+project(WickedEngine)
+
+include(CheckIPOSupported)
+check_ipo_supported(RESULT ipo_supported)
+
 set(WICKED_ROOT_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 
 option(WICKED_DYNAMIC_LIBRARY "Build WickedEngine as a dynamic library" OFF)
 option(WICKED_PIC "Build WickedEngine as position-independent code" WICKED_DYNAMIC_LIBRARY)
 option(USE_LIBCXX "Link WickedEngine to llvm libc++ library - only available with the Clang compiler" OFF)
-
 option(WICKED_EDITOR "Build WickedEngine editor" ON)
 option(WICKED_TESTS "Build WickedEngine tests" ON)
 option(WICKED_IMGUI_EXAMPLE "Build WickedEngine imgui example" ON)
+option(WICKED_USE_IPO "Enable IPO/LTO in non-debug builds" ${ipo_supported})
+
 if (CMAKE_HOST_WIN32)
     set(symlink_default OFF)
 else()
@@ -25,6 +31,10 @@ else()
 endif()
 option(WICKED_USE_SYMLINKS "Prefer symlinking over copying directories" ${symlink_default})
 
+# check that IPO is supported when turned on
+if(WICKED_USE_IPO)
+    check_ipo_supported()
+endif()
 
 if(WICKED_USE_SYMLINKS)
     # check for symlink support (on windows it requires admin or developer mode)
@@ -62,7 +72,7 @@ set(CMAKE_POSITION_INDEPENDENT_CODE WICKED_PIC)
 # Use solution folders to organize projects
 set_property(GLOBAL PROPERTY USE_FOLDERS ON)
 
-project(WickedEngine)
+
 
 if (WIN32)
     set(PLATFORM "Windows")
@@ -71,7 +81,7 @@ if (WIN32)
 elseif(UNIX)
     set(PLATFORM "SDL2")
     add_compile_definitions(SDL2=1)
-    
+
     # Common compiler options and warning level for CLANG and GCC:
     add_compile_options(
         -Wall
diff --git a/Editor/CMakeLists.txt b/Editor/CMakeLists.txt
index 475f54f3a..4b5261024 100644
--- a/Editor/CMakeLists.txt
+++ b/Editor/CMakeLists.txt
@@ -10,34 +10,41 @@ list(APPEND SOURCE_FILES main_${PLATFORM}.cpp)
 
 
 if (WIN32)
-	list (APPEND SOURCE_FILES
-		Editor.rc
-	)
+    list (APPEND SOURCE_FILES
+        Editor.rc
+    )
 
-	add_executable(Editor WIN32 ${SOURCE_FILES})
+    add_executable(Editor WIN32 ${SOURCE_FILES})
 
-	target_link_libraries(Editor PUBLIC
-		WickedEngine_Windows
-	)
+    target_link_libraries(Editor PUBLIC
+        WickedEngine_Windows
+    )
 
-	set_property(TARGET Editor PROPERTY VS_DEBUGGER_WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")
-	set(LIB_DXCOMPILER "dxcompiler.dll")
+    set_property(TARGET Editor PROPERTY VS_DEBUGGER_WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")
+    set(LIB_DXCOMPILER "dxcompiler.dll")
 else ()
-	add_executable(Editor ${SOURCE_FILES})
+    add_executable(Editor ${SOURCE_FILES})
 
-	target_link_libraries(Editor PUBLIC
-		WickedEngine
-	)
-	set(LIB_DXCOMPILER "libdxcompiler.so")
+    target_link_libraries(Editor PUBLIC
+        WickedEngine
+    )
+    set(LIB_DXCOMPILER "libdxcompiler.so")
 
-	# needed for proper names in crash stacktrace
-	set_target_properties(Editor
-		PROPERTIES
-		ENABLE_EXPORTS ON
-	)
+    # needed for proper names in crash stacktrace
+    set_target_properties(Editor
+        PROPERTIES
+        ENABLE_EXPORTS ON
+    )
 
 endif ()
 
+if(WICKED_USE_IPO)
+    set_target_properties(Editor PROPERTIES
+        INTERPROCEDURAL_OPTIMIZATION ON
+        INTERPROCEDURAL_OPTIMIZATION_DEBUG OFF
+    )
+endif()
+
 target_precompile_headers(Editor PRIVATE "stdafx.h")
 
 # Needed for terrain system
@@ -45,11 +52,11 @@ add_dependencies(Editor Content)
 
 # Copy content to build folder:
 add_custom_command(
-	TARGET Editor POST_BUILD
-	# Copy shader compiler library in the source folder
-	COMMAND ${CMAKE_COMMAND} -E copy_if_different ${WICKED_ROOT_DIR}/WickedEngine/${LIB_DXCOMPILER} ${CMAKE_CURRENT_BINARY_DIR}
-	#COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_CURRENT_SOURCE_DIR}/languages ${CMAKE_CURRENT_BINARY_DIR}/languages
-	COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_CURRENT_SOURCE_DIR}/fonts ${CMAKE_CURRENT_BINARY_DIR}/fonts
+    TARGET Editor POST_BUILD
+    # Copy shader compiler library in the source folder
+    COMMAND ${CMAKE_COMMAND} -E copy_if_different ${WICKED_ROOT_DIR}/WickedEngine/${LIB_DXCOMPILER} ${CMAKE_CURRENT_BINARY_DIR}
+    #COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_CURRENT_SOURCE_DIR}/languages ${CMAKE_CURRENT_BINARY_DIR}/languages
+    COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_CURRENT_SOURCE_DIR}/fonts ${CMAKE_CURRENT_BINARY_DIR}/fonts
 )
 
 include(GNUInstallDirs)
@@ -60,13 +67,13 @@ install(TARGETS Editor RUNTIME DESTINATION ${EDITOR_INSTALL_FOLDER})
 
 # install editor assets
 install(DIRECTORY
-		#"${CMAKE_CURRENT_SOURCE_DIR}/languages"
-		"${CMAKE_CURRENT_SOURCE_DIR}/fonts"
-		DESTINATION ${EDITOR_INSTALL_FOLDER})
+        #"${CMAKE_CURRENT_SOURCE_DIR}/languages"
+        "${CMAKE_CURRENT_SOURCE_DIR}/fonts"
+        DESTINATION ${EDITOR_INSTALL_FOLDER})
 # optional .ini .ico .lua
 install(FILES
-		${CMAKE_CURRENT_SOURCE_DIR}/config.ini
-		${CMAKE_CURRENT_SOURCE_DIR}/wicked.ico
-		${CMAKE_CURRENT_SOURCE_DIR}/startup.lua
-		DESTINATION ${EDITOR_INSTALL_FOLDER})
+        ${CMAKE_CURRENT_SOURCE_DIR}/config.ini
+        ${CMAKE_CURRENT_SOURCE_DIR}/wicked.ico
+        ${CMAKE_CURRENT_SOURCE_DIR}/startup.lua
+        DESTINATION ${EDITOR_INSTALL_FOLDER})
 
diff --git a/Samples/Example_ImGui/CMakeLists.txt b/Samples/Example_ImGui/CMakeLists.txt
index af22342ff..af742f672 100644
--- a/Samples/Example_ImGui/CMakeLists.txt
+++ b/Samples/Example_ImGui/CMakeLists.txt
@@ -75,6 +75,13 @@ else()
 	set(LIB_DXCOMPILER "libdxcompiler.so")
 endif ()
 
+if(WICKED_USE_IPO)
+set_target_properties(Example_ImGui PROPERTIES
+    INTERPROCEDURAL_OPTIMIZATION ON
+    INTERPROCEDURAL_OPTIMIZATION_DEBUG OFF
+)
+endif()
+
 if (MSVC)
 	set_property(TARGET Example_ImGui PROPERTY VS_DEBUGGER_WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")
 endif ()
diff --git a/Samples/Example_ImGui_Docking/CMakeLists.txt b/Samples/Example_ImGui_Docking/CMakeLists.txt
index 5ca2e5711..a8526ad99 100644
--- a/Samples/Example_ImGui_Docking/CMakeLists.txt
+++ b/Samples/Example_ImGui_Docking/CMakeLists.txt
@@ -81,6 +81,13 @@ else()
 	set(LIB_DXCOMPILER "libdxcompiler.so")
 endif ()
 
+if(WICKED_USE_IPO)
+set_target_properties(Example_ImGui_Docking PROPERTIES
+    INTERPROCEDURAL_OPTIMIZATION ON
+    INTERPROCEDURAL_OPTIMIZATION_DEBUG OFF
+)
+endif()
+
 target_precompile_headers(Example_ImGui_Docking PRIVATE stdafx.h)
 
 if (MSVC)
diff --git a/Samples/Template_Linux/CMakeLists.txt b/Samples/Template_Linux/CMakeLists.txt
index 55f7772bc..b828a6ffb 100644
--- a/Samples/Template_Linux/CMakeLists.txt
+++ b/Samples/Template_Linux/CMakeLists.txt
@@ -27,6 +27,13 @@ target_link_libraries(Template_Linux PUBLIC
     $<$<BOOL:${INSTALLED_ENGINE}>:WickedEngine::WickedEngine>
 )
 
+if(WICKED_USE_IPO)
+set_target_properties(Template_Linux PROPERTIES
+    INTERPROCEDURAL_OPTIMIZATION ON
+    INTERPROCEDURAL_OPTIMIZATION_DEBUG OFF
+)
+endif()
+
 if (${INSTALLED_ENGINE})
     get_property(LIBDXCOMPILER_PATH
         TARGET WickedEngine::dxcompiler
diff --git a/Samples/Template_Windows/CMakeLists.txt b/Samples/Template_Windows/CMakeLists.txt
index 1bcc1d2e9..b02c36cec 100644
--- a/Samples/Template_Windows/CMakeLists.txt
+++ b/Samples/Template_Windows/CMakeLists.txt
@@ -21,6 +21,13 @@ set_target_properties(${PROJECT_NAME} PROPERTIES
 WIN32_EXECUTABLE YES
 )
 
+if(WICKED_USE_IPO)
+set_target_properties(${PROJEC_NAME} PROPERTIES
+    INTERPROCEDURAL_OPTIMIZATION ON
+    INTERPROCEDURAL_OPTIMIZATION_DEBUG OFF
+)
+endif()
+
 set(PLATFORM "Windows")
 add_compile_definitions(WIN32 _WINDOWS)
 
diff --git a/Samples/Tests/CMakeLists.txt b/Samples/Tests/CMakeLists.txt
index c4dd69ab1..8d01d3944 100644
--- a/Samples/Tests/CMakeLists.txt
+++ b/Samples/Tests/CMakeLists.txt
@@ -32,8 +32,16 @@ else()
 	set(LIB_DXCOMPILER "libdxcompiler.so")
 endif ()
 
+if(WICKED_USE_IPO)
+set_target_properties(Tests PROPERTIES
+    INTERPROCEDURAL_OPTIMIZATION ON
+    INTERPROCEDURAL_OPTIMIZATION_DEBUG OFF
+)
+endif()
+
 target_precompile_headers(Tests PRIVATE stdafx.h)
 
+
 if (MSVC)
 	set_property(TARGET Tests PROPERTY VS_DEBUGGER_WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")
 endif ()
diff --git a/WickedEngine/CMakeLists.txt b/WickedEngine/CMakeLists.txt
index 1eebcf34e..bdd13aae2 100644
--- a/WickedEngine/CMakeLists.txt
+++ b/WickedEngine/CMakeLists.txt
@@ -20,45 +20,45 @@ option(USE_F16C "Enable F16C" ON)
 option(USE_FMADD "Enable FMADD" ON)
 
 if (WICKED_DYNAMIC_LIBRARY)
-	set(WICKED_LIBRARY_TYPE SHARED)
-	message(STATUS "Building WickedEngine as a shared library")
+    set(WICKED_LIBRARY_TYPE SHARED)
+    message(STATUS "Building WickedEngine as a shared library")
 else()
-	set(WICKED_LIBRARY_TYPE STATIC)
-	message(STATUS "Building WickedEngine as a static library")
+    set(WICKED_LIBRARY_TYPE STATIC)
+    message(STATUS "Building WickedEngine as a static library")
 endif()
 
 if (WIN32)
-	# TODO: Choose whether to use SDL2 on windows as well
-	set(TARGET_NAME WickedEngine_Windows)
+    # TODO: Choose whether to use SDL2 on windows as well
+    set(TARGET_NAME WickedEngine_Windows)
 else ()
-	set(TARGET_NAME WickedEngine_Linux)
-	find_package(SDL2 REQUIRED)
-	find_package(OpenImageDenoise "${MIN_OpenImageDenoise_VERSION}" QUIET)
-	find_package(Threads REQUIRED)
-	if(NOT ${OpenImageDenoise_FOUND})
-		message("OpenImageDenoise>=${MIN_OpenImageDenoise_VERSION} not found, it will be disabled.")
-	else()
-		message("OpenImageDenoise ${OpenImageDenoise_VERSION} Found.")
-	endif()
+    set(TARGET_NAME WickedEngine_Linux)
+    find_package(SDL2 REQUIRED)
+    find_package(OpenImageDenoise "${MIN_OpenImageDenoise_VERSION}" QUIET)
+    find_package(Threads REQUIRED)
+    if(NOT ${OpenImageDenoise_FOUND})
+        message("OpenImageDenoise>=${MIN_OpenImageDenoise_VERSION} not found, it will be disabled.")
+    else()
+        message("OpenImageDenoise ${OpenImageDenoise_VERSION} Found.")
+    endif()
 
-	if(NOT TARGET SDL2::SDL2)
-		# using old SDL2 cmake, lets create a SDL2 target ourselves
-		find_library(SDL2_LIBRARY_FILE_LOCATION SDL2 REQUIRED)
+    if(NOT TARGET SDL2::SDL2)
+        # using old SDL2 cmake, lets create a SDL2 target ourselves
+        find_library(SDL2_LIBRARY_FILE_LOCATION SDL2 REQUIRED)
 
-		add_library(SDL2::SDL2 SHARED IMPORTED)
-		set_target_properties(SDL2::SDL2 PROPERTIES
-			INTERFACE_INCLUDE_DIRECTORIES ${SDL2_INCLUDE_DIRS}
-			INTERFACE_LINK_LIBRARIES ${SDL2_LIBRARIES}
-			IMPORTED_LOCATION ${SDL2_LIBRARY_FILE_LOCATION}
-		)
+        add_library(SDL2::SDL2 SHARED IMPORTED)
+        set_target_properties(SDL2::SDL2 PROPERTIES
+            INTERFACE_INCLUDE_DIRECTORIES ${SDL2_INCLUDE_DIRS}
+            INTERFACE_LINK_LIBRARIES ${SDL2_LIBRARIES}
+            IMPORTED_LOCATION ${SDL2_LIBRARY_FILE_LOCATION}
+        )
 
-		unset(SDL2_LIBRARY_FILE_LOCATION)
-	endif()
+        unset(SDL2_LIBRARY_FILE_LOCATION)
+    endif()
 
-	# minimum sdl version is 2.0.14 for controller LED support
-	if((${SDL_VERSION_MAJOR} GREATER_EQUAL 2) AND (${SDL2_VERSION_MINOR} GREATER_EQUAL 0) AND (${SDL2_VERSION_PATCH} GREATER_EQUAL 14))
-		add_compile_definitions(SDL2_FEATURE_CONTROLLER_LED=1)
-	endif()
+    # minimum sdl version is 2.0.14 for controller LED support
+    if((${SDL_VERSION_MAJOR} GREATER_EQUAL 2) AND (${SDL2_VERSION_MINOR} GREATER_EQUAL 0) AND (${SDL2_VERSION_PATCH} GREATER_EQUAL 14))
+        add_compile_definitions(SDL2_FEATURE_CONTROLLER_LED=1)
+    endif()
 endif()
 
 add_subdirectory(LUA)
@@ -72,7 +72,7 @@ if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
 endif()
 
 set_target_properties(Jolt PROPERTIES
-	POSITION_INDEPENDENT_CODE ${WICKED_PIC}
+    POSITION_INDEPENDENT_CODE ${WICKED_PIC}
 )
 add_compile_definitions(Jolt JPH_DEBUG_RENDERER)
 
@@ -84,83 +84,83 @@ file(GLOB SOURCE_FILES CONFIGURE_DEPENDS *.cpp)
 list(REMOVE_ITEM SOURCE_FILES ${CMAKE_CURRENT_SOURCE_DIR}/offlineshadercompiler.cpp)
 
 add_library(${TARGET_NAME} ${WICKED_LIBRARY_TYPE}
-	${SOURCE_FILES}
-	${HEADER_FILES}
+    ${SOURCE_FILES}
+    ${HEADER_FILES}
 )
 
 target_precompile_headers(${TARGET_NAME} PRIVATE WickedEngine.h)
 
 add_library(WickedEngine ALIAS ${TARGET_NAME})
 set_target_properties(${TARGET_NAME} PROPERTIES
-	PUBLIC_HEADER "${HEADER_FILES}"
-	POSITION_INDEPENDENT_CODE ${WICKED_PIC}
+    PUBLIC_HEADER "${HEADER_FILES}"
+    POSITION_INDEPENDENT_CODE ${WICKED_PIC}
 )
 
 target_include_directories(${TARGET_NAME} SYSTEM PUBLIC
-	$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
-	$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/WickedEngine>
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
+    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/WickedEngine>
 )
 
 set(WICKEDENGINE_STATIC_LIBRARIES
-	Jolt
-	LUA
-	Utility
+    Jolt
+    LUA
+    Utility
 )
 
 if (USE_AVX512 OR USE_AVX2)
-	target_compile_definitions(${TARGET_NAME} PUBLIC _XM_AVX2_INTRINSICS_)
+    target_compile_definitions(${TARGET_NAME} PUBLIC _XM_AVX2_INTRINSICS_)
 endif()
 if (USE_AVX)
-	target_compile_definitions(${TARGET_NAME} PUBLIC _XM_AVX_INTRINSICS_)
+    target_compile_definitions(${TARGET_NAME} PUBLIC _XM_AVX_INTRINSICS_)
 endif()
 if (USE_SSE4_1 OR USE_SSE4_2)
-	target_compile_definitions(${TARGET_NAME} PUBLIC _XM_SSE4_INTRINSICS_)
+    target_compile_definitions(${TARGET_NAME} PUBLIC _XM_SSE4_INTRINSICS_)
 endif()
 if (USE_F16C)
-	target_compile_definitions(${TARGET_NAME} PUBLIC _XM_F16C_INTRINSICS_)
+    target_compile_definitions(${TARGET_NAME} PUBLIC _XM_F16C_INTRINSICS_)
 endif()
 if (USE_FMADD)
-	target_compile_definitions(${TARGET_NAME} PUBLIC _XM_FMA3_INTRINSICS_)
+    target_compile_definitions(${TARGET_NAME} PUBLIC _XM_FMA3_INTRINSICS_)
 endif()
 
 if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
-	if ("${CMAKE_VS_PLATFORM_NAME}" STREQUAL "x86" OR "${CMAKE_VS_PLATFORM_NAME}" STREQUAL "x64")
-		if (USE_AVX512)
-			target_compile_options(${TARGET_NAME} PUBLIC /arch:AVX512)
-		elseif (USE_AVX2)
-			target_compile_options(${TARGET_NAME} PUBLIC /arch:AVX2)
-		elseif (USE_AVX)
-			target_compile_options(${TARGET_NAME} PUBLIC /arch:AVX)
-		endif()
-	endif()
+    if ("${CMAKE_VS_PLATFORM_NAME}" STREQUAL "x86" OR "${CMAKE_VS_PLATFORM_NAME}" STREQUAL "x64")
+        if (USE_AVX512)
+            target_compile_options(${TARGET_NAME} PUBLIC /arch:AVX512)
+        elseif (USE_AVX2)
+            target_compile_options(${TARGET_NAME} PUBLIC /arch:AVX2)
+        elseif (USE_AVX)
+            target_compile_options(${TARGET_NAME} PUBLIC /arch:AVX)
+        endif()
+    endif()
 elseif ("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "x86_64" OR "${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "AMD64" OR "${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "x86" OR "${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "i386")
-	if (USE_AVX512)
-		target_compile_options(${TARGET_NAME} PUBLIC -mavx512f -mavx512vl -mavx512dq -mavx2 -mbmi -mpopcnt -mlzcnt -mf16c)
-	elseif (USE_AVX2)
-		target_compile_options(${TARGET_NAME} PUBLIC -mavx2 -mbmi -mpopcnt -mlzcnt -mf16c)
-	elseif (USE_AVX)
-		target_compile_options(${TARGET_NAME} PUBLIC -mavx -mpopcnt)
-	elseif (USE_SSE4_2)
-		target_compile_options(${TARGET_NAME} PUBLIC -msse4.2 -mpopcnt)
-	elseif (USE_SSE4_1)
-		target_compile_options(${TARGET_NAME} PUBLIC -msse4.1)
-	else()
-		target_compile_options(${TARGET_NAME} PUBLIC -msse2)
-	endif()
-	if (USE_LZCNT)
-		target_compile_options(${TARGET_NAME} PUBLIC -mlzcnt)
-	endif()
-	if (USE_TZCNT)
-		target_compile_options(${TARGET_NAME} PUBLIC -mbmi)
-	endif()
-	if (USE_F16C)
-		target_compile_options(${TARGET_NAME} PUBLIC -mf16c)
-	endif()
-	if (USE_FMADD)
-		target_compile_options(${TARGET_NAME} PUBLIC -mfma)
-	endif()
+    if (USE_AVX512)
+        target_compile_options(${TARGET_NAME} PUBLIC -mavx512f -mavx512vl -mavx512dq -mavx2 -mbmi -mpopcnt -mlzcnt -mf16c)
+    elseif (USE_AVX2)
+        target_compile_options(${TARGET_NAME} PUBLIC -mavx2 -mbmi -mpopcnt -mlzcnt -mf16c)
+    elseif (USE_AVX)
+        target_compile_options(${TARGET_NAME} PUBLIC -mavx -mpopcnt)
+    elseif (USE_SSE4_2)
+        target_compile_options(${TARGET_NAME} PUBLIC -msse4.2 -mpopcnt)
+    elseif (USE_SSE4_1)
+        target_compile_options(${TARGET_NAME} PUBLIC -msse4.1)
+    else()
+        target_compile_options(${TARGET_NAME} PUBLIC -msse2)
+    endif()
+    if (USE_LZCNT)
+        target_compile_options(${TARGET_NAME} PUBLIC -mlzcnt)
+    endif()
+    if (USE_TZCNT)
+        target_compile_options(${TARGET_NAME} PUBLIC -mbmi)
+    endif()
+    if (USE_F16C)
+        target_compile_options(${TARGET_NAME} PUBLIC -mf16c)
+    endif()
+    if (USE_FMADD)
+        target_compile_options(${TARGET_NAME} PUBLIC -mfma)
+    endif()
 
-	target_compile_options(${TARGET_NAME} PUBLIC -mfpmath=sse)
+    target_compile_options(${TARGET_NAME} PUBLIC -mfpmath=sse)
 endif()
 
 target_compile_definitions(${TARGET_NAME} PUBLIC WICKED_CMAKE_BUILD)
@@ -181,83 +181,91 @@ if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/wiShaderDump.h)
 endif()
 
 if (WIN32)
-	target_compile_definitions(${TARGET_NAME} PUBLIC
-		UNICODE _UNICODE
-	)
+    target_compile_definitions(${TARGET_NAME} PUBLIC
+        UNICODE _UNICODE
+    )
 
-	if (MSVC)
-		add_compile_options(
-			/W3
-			/MP
-			/bigobj
-		)
-	endif()
+    if (MSVC)
+        add_compile_options(
+            /W3
+            /MP
+            /bigobj
+        )
+    endif()
 
-	set(LIBDXCOMPILER "dxcompiler.dll")
+    set(LIBDXCOMPILER "dxcompiler.dll")
 else ()
-	# `ska::flat_hash_map` has issues on linux because of the hash function being identity
-	# in same cases. Use `robin_hood::unordered_flat_map` instead
-	target_compile_definitions(${TARGET_NAME} PUBLIC WI_UNORDERED_MAP_TYPE=2)
+    # `ska::flat_hash_map` has issues on linux because of the hash function being identity
+    # in same cases. Use `robin_hood::unordered_flat_map` instead
+    target_compile_definitions(${TARGET_NAME} PUBLIC WI_UNORDERED_MAP_TYPE=2)
 
-	target_link_libraries(${TARGET_NAME} PUBLIC
-		Threads::Threads
-		SDL2::SDL2
-		$<$<BOOL:${OpenImageDenoise_FOUND}>:OpenImageDenoise> # links OpenImageDenoise only if it's found
-	)
+    target_link_libraries(${TARGET_NAME} PUBLIC
+        Threads::Threads
+        SDL2::SDL2
+        $<$<BOOL:${OpenImageDenoise_FOUND}>:OpenImageDenoise> # links OpenImageDenoise only if it's found
+    )
 
-	set_target_properties(FAudio PROPERTIES
-		POSITION_INDEPENDENT_CODE ${WICKED_PIC}
-		UNITY_BUILD NO
-	)
-	set(WICKEDENGINE_STATIC_LIBRARIES ${WICKEDENGINE_STATIC_LIBRARIES} FAudio)
+    set_target_properties(FAudio PROPERTIES
+        POSITION_INDEPENDENT_CODE ${WICKED_PIC}
+        UNITY_BUILD NO
+    )
+    set(WICKEDENGINE_STATIC_LIBRARIES ${WICKEDENGINE_STATIC_LIBRARIES} FAudio)
 
-	target_link_libraries(${TARGET_NAME} PRIVATE dl)
+    target_link_libraries(${TARGET_NAME} PRIVATE dl)
 
-	set(LIBDXCOMPILER "libdxcompiler.so")
+    set(LIBDXCOMPILER "libdxcompiler.so")
 endif()
 
 target_link_libraries(${TARGET_NAME} PUBLIC ${WICKEDENGINE_STATIC_LIBRARIES})
 
 if (PLATFORM MATCHES "SDL2")
-	target_compile_definitions(${TARGET_NAME} PUBLIC SDL2=1)
+    target_compile_definitions(${TARGET_NAME} PUBLIC SDL2=1)
 endif()
 
 add_library(dxcompiler SHARED IMPORTED)
 set_property(TARGET dxcompiler PROPERTY
-		IMPORTED_LOCATION ${WICKED_ROOT_DIR}/WickedEngine/${LIBDXCOMPILER} )
+        IMPORTED_LOCATION ${WICKED_ROOT_DIR}/WickedEngine/${LIBDXCOMPILER} )
 
 # Copy the shader library next to the executable
 add_custom_command(
-	TARGET ${TARGET_NAME} POST_BUILD
-	COMMAND ${CMAKE_COMMAND} -E copy_if_different ${WICKED_ROOT_DIR}/WickedEngine/${LIBDXCOMPILER} ${CMAKE_CURRENT_BINARY_DIR}
-	COMMAND ${CMAKE_COMMAND} -E ${COPY_OR_SYMLINK_DIR_CMD} ${WICKED_ROOT_DIR}/WickedEngine/shaders ${CMAKE_CURRENT_BINARY_DIR}/shaders
+    TARGET ${TARGET_NAME} POST_BUILD
+    COMMAND ${CMAKE_COMMAND} -E copy_if_different ${WICKED_ROOT_DIR}/WickedEngine/${LIBDXCOMPILER} ${CMAKE_CURRENT_BINARY_DIR}
+    COMMAND ${CMAKE_COMMAND} -E ${COPY_OR_SYMLINK_DIR_CMD} ${WICKED_ROOT_DIR}/WickedEngine/shaders ${CMAKE_CURRENT_BINARY_DIR}/shaders
 )
 
 set_property(SOURCE
-	wiAudio.cpp
-	wiOcean.cpp
-	wiPrimitive_BindLUA.cpp
-	wiPhysics_Jolt.cpp
-	wiGraphicsDevice_Vulkan.cpp
-	wiGraphicsDevice_DX12.cpp
+    wiAudio.cpp
+    wiOcean.cpp
+    wiPrimitive_BindLUA.cpp
+    wiPhysics_Jolt.cpp
+    wiGraphicsDevice_Vulkan.cpp
+    wiGraphicsDevice_DX12.cpp
 
-	PROPERTY SKIP_UNITY_BUILD_INCLUSION TRUE
+    PROPERTY SKIP_UNITY_BUILD_INCLUSION TRUE
 )
 set_property(TARGET LUA PROPERTY UNITY_BUILD NO)
 
 # OFFLINE SHADER COMPILER
 add_executable(offlineshadercompiler
-		offlineshadercompiler.cpp
+        offlineshadercompiler.cpp
 )
 
+if(WICKED_USE_IPO)
+set_target_properties(${WICKEDENGINE_STATIC_LIBRARIES} ${TARGET_NAME} offlineshadercompiler PROPERTIES
+    INTERPROCEDURAL_OPTIMIZATION ON
+    INTERPROCEDURAL_OPTIMIZATION_DEBUG OFF
+)
+endif()
+
+
 target_link_libraries(offlineshadercompiler
-		PUBLIC ${TARGET_NAME})
+        PUBLIC ${TARGET_NAME})
 
 install(TARGETS offlineshadercompiler
-		RUNTIME DESTINATION "${CMAKE_INSTALL_LIBDIR}/WickedEngine")
+        RUNTIME DESTINATION "${CMAKE_INSTALL_LIBDIR}/WickedEngine")
 
 install(DIRECTORY "${WICKED_ROOT_DIR}/Content"
-		DESTINATION "${CMAKE_INSTALL_LIBDIR}/WickedEngine")
+        DESTINATION "${CMAKE_INSTALL_LIBDIR}/WickedEngine")
 
 #### LOCAL FOLDER INSTALLATION
 # Create importable target here
@@ -267,47 +275,47 @@ set_target_properties("${TARGET_NAME}" PROPERTIES EXPORT_NAME "${TARGET_NAME}")
 
 
 install(TARGETS "${TARGET_NAME}" ${WICKEDENGINE_STATIC_LIBRARIES}
-		EXPORT Engine-Targets
-		LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
-		ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}/WickedEngine"
-		PUBLIC_HEADER DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/WickedEngine")
+        EXPORT Engine-Targets
+        LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+        ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}/WickedEngine"
+        PUBLIC_HEADER DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/WickedEngine")
 
 install(FILES ${LIBDXCOMPILER}
-		DESTINATION "${CMAKE_INSTALL_LIBDIR}/WickedEngine")
+        DESTINATION "${CMAKE_INSTALL_LIBDIR}/WickedEngine")
 
 export(EXPORT Engine-Targets
-		FILE "${CMAKE_BINARY_DIR}/cmake/WickedEngineTargets.cmake"
-		NAMESPACE WickedEngine::
-		)
+        FILE "${CMAKE_BINARY_DIR}/cmake/WickedEngineTargets.cmake"
+        NAMESPACE WickedEngine::
+        )
 
 install(EXPORT Engine-Targets
-		FILE WickedEngineTargets.cmake
-		NAMESPACE WickedEngine::
-		DESTINATION ${INSTALL_CONFIGDIR})
+        FILE WickedEngineTargets.cmake
+        NAMESPACE WickedEngine::
+        DESTINATION ${INSTALL_CONFIGDIR})
 
 set(_CONFIG_INSTALL_DIR_INCLUDE "${WICKED_ROOT_DIR}")
 set(_CONFIG_INSTALL_DIR_LIB "${WICKED_ROOT_DIR}")
 configure_package_config_file(
-		${CMAKE_CURRENT_SOURCE_DIR}/WickedEngineConfig.cmake.in
-		${CMAKE_BINARY_DIR}/cmake/WickedEngineConfig.cmake
-		INSTALL_DESTINATION ${INSTALL_LOCAL_CONFIGDIR}
+        ${CMAKE_CURRENT_SOURCE_DIR}/WickedEngineConfig.cmake.in
+        ${CMAKE_BINARY_DIR}/cmake/WickedEngineConfig.cmake
+        INSTALL_DESTINATION ${INSTALL_LOCAL_CONFIGDIR}
 )
 set(_CONFIG_INSTALL_DIR_INCLUDE "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_INCLUDEDIR}")
 set(_CONFIG_INSTALL_DIR_LIB "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}")
 configure_package_config_file(
-		${CMAKE_CURRENT_SOURCE_DIR}/WickedEngineConfig.cmake.in
-		${CMAKE_BINARY_DIR}/cmake/install/WickedEngineConfig.cmake
-		INSTALL_DESTINATION ${INSTALL_CONFIGDIR}
+        ${CMAKE_CURRENT_SOURCE_DIR}/WickedEngineConfig.cmake.in
+        ${CMAKE_BINARY_DIR}/cmake/install/WickedEngineConfig.cmake
+        INSTALL_DESTINATION ${INSTALL_CONFIGDIR}
 )
 
 install(FILES ${CMAKE_BINARY_DIR}/cmake/install/WickedEngineConfig.cmake
-		DESTINATION ${INSTALL_CONFIGDIR}
+        DESTINATION ${INSTALL_CONFIGDIR}
 )
 
 # Shaders
 install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/shaders
-		DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/WickedEngine"
-		PATTERN "spirv" EXCLUDE
-		PATTERN "hlsl6" EXCLUDE
-		PATTERN "*.vcxitems*" EXCLUDE
-		)
+        DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/WickedEngine"
+        PATTERN "spirv" EXCLUDE
+        PATTERN "hlsl6" EXCLUDE
+        PATTERN "*.vcxitems*" EXCLUDE
+        )