diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index fd6d6011..78c14524 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -37,6 +37,11 @@ jobs:
       - name: Checkout Repo
         uses: actions/checkout@v4
 
+      - name: Setup Node.js
+        uses: actions/setup-node@v6
+        with:
+          node-version: 24
+
       - name: Setup cmake
         uses: jwlawson/actions-setup-cmake@v2
         with:
diff --git a/CMake/Common.cmake b/CMake/Common.cmake
index e8bd3dac..70614f2f 100644
--- a/CMake/Common.cmake
+++ b/CMake/Common.cmake
@@ -1,5 +1,6 @@
-option(BUILD_EDITOR "Build Explosion editor" ON)
-option(CI "Build in CI" OFF)
+include(ExternalProject)
+include(GenerateExportHeader)
+
 option(USE_UNITY_BUILD "Use unity build" ON)
 option(EXPORT_COMPILE_COMMANDS "Whether to export all compile commands" OFF)
 
@@ -7,28 +8,12 @@ set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_UNITY_BUILD ${USE_UNITY_BUILD})
 set(CMAKE_EXPORT_COMPILE_COMMANDS ${EXPORT_COMPILE_COMMANDS})
 
-get_cmake_property(GENERATOR_IS_MULTI_CONFIG GENERATOR_IS_MULTI_CONFIG)
-if (${GENERATOR_IS_MULTI_CONFIG})
-    set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/Dist/$<CONFIG>/Engine/Binaries)
-    set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/Dist/$<CONFIG>/Engine/Binaries)
-    set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/Lib)
-else ()
-    set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/Dist/Engine/Binaries)
-    set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/Dist/Engine/Binaries)
-    set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/Lib)
-endif ()
-
+get_cmake_property(generator_is_multi_config GENERATOR_IS_MULTI_CONFIG)
 if (${CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT})
-    if (${GENERATOR_IS_MULTI_CONFIG})
-        set(CMAKE_INSTALL_PREFIX ${CMAKE_BINARY_DIR}/Install/$<CONFIG> CACHE PATH "" FORCE)
-    else ()
-        set(CMAKE_INSTALL_PREFIX ${CMAKE_BINARY_DIR}/Install CACHE PATH "" FORCE)
-    endif ()
+    # TODO support multi config generator for CMAKE_INSTALL_PREFIX
+    set(CMAKE_INSTALL_PREFIX ${CMAKE_BINARY_DIR}/Install CACHE PATH "" FORCE)
 endif()
 
-add_definitions(-DENGINE_CMAKE_SOURCE_DIRECTORY="${CMAKE_SOURCE_DIR}")
-add_definitions(-DENGINE_CMAKE_BINARY_DIRECTORY="${CMAKE_BINARY_DIR}")
-
 add_definitions(-DBUILD_CONFIG_DEBUG=$<IF:$<OR:$<CONFIG:Debug>,$<CONFIG:RelWithDebInfo>>,1,0>)
 
 add_definitions(-DPLATFORM_WINDOWS=$<IF:$<PLATFORM_ID:Windows>,1,0>)
@@ -39,8 +24,6 @@ add_definitions(-DCOMPILER_MSVC=$<IF:$<CXX_COMPILER_ID:MSVC>,1,0>)
 add_definitions(-DCOMPILER_APPLE_CLANG=$<IF:$<CXX_COMPILER_ID:AppleClang>,1,0>)
 add_definitions(-DCOMPILER_GCC=$<IF:$<CXX_COMPILER_ID:GNU>,1,0>)
 
-add_definitions(-DBUILD_EDITOR=$<BOOL:BUILD_EDITOR>)
-
 if (${MSVC})
     add_compile_options(/bigobj)
     add_definitions(-D_SILENCE_ALL_MS_EXT_DEPRECATION_WARNINGS=1)
diff --git a/CMake/Target.cmake b/CMake/Target.cmake
index 29b3921b..97e9dc4d 100644
--- a/CMake/Target.cmake
+++ b/CMake/Target.cmake
@@ -2,8 +2,6 @@ option(BUILD_TEST "Build unit tests" ON)
 option(BUILD_SAMPLE "Build sample" ON)
 
 set(API_HEADER_DIR ${CMAKE_BINARY_DIR}/Generated/Api CACHE PATH "" FORCE)
-set(BASIC_LIBS Common CACHE STRING "" FORCE)
-set(BASIC_TEST_LIBS Test CACHE STRING "" FORCE)
 
 if (${BUILD_TEST})
     enable_testing()
@@ -12,480 +10,513 @@ else()
     add_definitions(-DBUILD_TEST=0)
 endif()
 
-function(exp_combine_runtime_deps)
-    cmake_parse_arguments(PARAMS "" "NAME" "RUNTIME_DEP" ${ARGN})
+function(exp_gather_target_runtime_dependencies_recurse)
+    set(options "")
+    set(singleValueArgs NAME OUT_RUNTIME_DEP)
+    set(multiValueArgs "")
+    cmake_parse_arguments(arg "${options}" "${singleValueArgs}" "${multiValueArgs}" ${ARGN})
 
-    get_target_property(RESULT ${PARAMS_NAME} RUNTIME_DEP)
-    if ("${RESULT}" STREQUAL "RESULT-NOTFOUND")
-        set(RESULT ${PARAMS_RUNTIME_DEP})
-    else()
-        list(APPEND RESULT ${PARAMS_RUNTIME_DEP})
-    endif()
-    set_target_properties(
-        ${PARAMS_NAME} PROPERTIES
-        RUNTIME_DEP "${RESULT}"
-    )
-endfunction()
-
-function(exp_link_libs)
-    cmake_parse_arguments(PARAMS "" "NAME" "LIB" ${ARGN})
-
-    foreach(L ${PARAMS_LIB})
-        if (NOT (TARGET ${L}))
-            target_link_libraries(${PARAMS_NAME} PUBLIC ${L})
-            continue()
-        endif()
-
-        get_target_property(3RD_TYPE ${L} 3RD_TYPE)
-        if (${3RD_TYPE} STREQUAL "3RD_TYPE-NOTFOUND")
-            target_link_libraries(${PARAMS_NAME} PUBLIC ${L})
-        else()
-            get_target_property(INCLUDE ${L} 3RD_INCLUDE)
-            get_target_property(LINK ${L} 3RD_LINK)
-            get_target_property(LIB ${L} 3RD_LIB)
-
-            if (NOT ("${INCLUDE}" STREQUAL "INCLUDE-NOTFOUND"))
-                target_include_directories(${PARAMS_NAME} PUBLIC ${INCLUDE})
-            endif()
-            if (NOT ("${LINK}" STREQUAL "LINK-NOTFOUND"))
-                target_link_directories(${PARAMS_NAME} PUBLIC ${LINK})
-            endif()
-            if (NOT ("${LIB}" STREQUAL "LIB-NOTFOUND"))
-                target_link_libraries(${PARAMS_NAME} PUBLIC ${LIB})
-            endif()
-
-            if (${3RD_TYPE} STREQUAL "CMakeProject")
-                add_dependencies(${PARAMS_NAME} ${L})
-            endif()
-        endif()
-
-        get_target_property(RUNTIME_DEP ${L} 3RD_RUNTIME_DEP)
-        if (NOT ("${RUNTIME_DEP}" STREQUAL "RUNTIME_DEP-NOTFOUND"))
-            exp_combine_runtime_deps(
-                NAME ${PARAMS_NAME}
-                RUNTIME_DEP "${RUNTIME_DEP}"
-            )
-        endif()
-    endforeach()
-endfunction()
-
-function(exp_link_basic_libs)
-    cmake_parse_arguments(PARAMS "" "NAME" "LIB" ${ARGN})
-
-    foreach(L ${PARAMS_LIB})
-        if (NOT (${PARAMS_NAME} STREQUAL ${L}))
-            exp_link_libs(
-                NAME ${PARAMS_NAME}
-                LIB ${L}
-            )
-        endif()
-    endforeach()
-endfunction()
-
-function(exp_get_target_runtime_deps_recurse)
-    cmake_parse_arguments(PARAMS "" "NAME;OUTPUT" "" ${ARGN})
+    if (NOT TARGET ${arg_NAME})
+        set(${arg_OUT_RUNTIME_DEP} "" PARENT_SCOPE)
+        return()
+    endif ()
 
-    get_target_property(RUNTIME_DEP ${PARAMS_NAME} RUNTIME_DEP)
-    if (NOT ("${RUNTIME_DEP}" STREQUAL "RUNTIME_DEP-NOTFOUND"))
-        foreach(R ${RUNTIME_DEP})
-            list(APPEND RESULT ${R})
+    get_target_property(runtime_dep ${arg_NAME} RUNTIME_DEP)
+    if (NOT ("${runtime_dep}" STREQUAL "runtime_dep-NOTFOUND"))
+        foreach(r ${runtime_dep})
+            # workaround to make EXPORT_PROPERTIES support generator expression
+            string(REPLACE "[" "$<" r "${r}")
+            string(REPLACE "]" ">" r "${r}")
+
+            get_target_property(type ${arg_NAME} TYPE)
+            if (${type} STREQUAL "SHARED_LIBRARY")
+                set(target_bin_dir $<TARGET_FILE_DIR:${arg_NAME}>)
+            else ()
+                set(target_bin_dir $<TARGET_FILE_DIR:${arg_NAME}>/../Binaries)
+            endif ()
+            string(REPLACE "$<TARGET_BIN_DIR>" ${target_bin_dir} temp_r ${r})
+            list(APPEND result_runtime_dep ${temp_r})
         endforeach()
     endif()
 
-    get_target_property(LINK_LIBRARIES ${PARAMS_NAME} LINK_LIBRARIES)
-    if (NOT ("${LINK_LIBRARIES}" STREQUAL "LINK_LIBRARIES-NOTFOUND"))
-        foreach(L ${LINK_LIBRARIES})
-            if (NOT TARGET ${L})
+    get_target_property(libs ${arg_NAME} LINK_LIBRARIES)
+    if (NOT ("${libs}" STREQUAL "libs-NOTFOUND"))
+        foreach(l ${libs})
+            if (NOT TARGET ${l})
                 continue()
             endif()
 
-            exp_get_target_runtime_deps_recurse(
-                NAME ${L}
-                OUTPUT TEMP
+            get_target_property(type ${l} TYPE)
+            if (${type} STREQUAL SHARED_LIBRARY)
+                list(APPEND result_runtime_dep $<TARGET_FILE:${l}>)
+            endif ()
+
+            exp_gather_target_runtime_dependencies_recurse(
+                NAME ${l}
+                OUT_RUNTIME_DEP temp_runtime_dep
             )
-            foreach(T ${TEMP})
-                list(APPEND RESULT ${T})
+            foreach(t ${temp_runtime_dep})
+                list(APPEND result_runtime_dep ${t})
             endforeach()
         endforeach()
     endif()
 
-    list(REMOVE_DUPLICATES RESULT)
-    set(${PARAMS_OUTPUT} ${RESULT} PARENT_SCOPE)
+    list(REMOVE_DUPLICATES result_runtime_dep)
+    set(${arg_OUT_RUNTIME_DEP} ${result_runtime_dep} PARENT_SCOPE)
 endfunction()
 
-function(exp_add_runtime_deps_copy_command)
-    cmake_parse_arguments(PARAMS "NOT_INSTALL" "NAME" "" ${ARGN})
+function(exp_process_runtime_dependencies)
+    set(options NOT_INSTALL)
+    set(singleValueArgs NAME)
+    set(multiValueArgs DEP_TARGET)
+    cmake_parse_arguments(arg "${options}" "${singleValueArgs}" "${multiValueArgs}" ${ARGN})
 
-    exp_get_target_runtime_deps_recurse(
-        NAME ${PARAMS_NAME}
-        OUTPUT RUNTIME_DEPS
+    exp_gather_target_runtime_dependencies_recurse(
+        NAME ${arg_NAME}
+        OUT_RUNTIME_DEP runtime_deps
     )
-    foreach(R ${RUNTIME_DEPS})
-        string(FIND ${R} "->" LOCATION)
-        if (NOT ${LOCATION} EQUAL -1)
-            string(REPLACE "->" ";" TEMP ${R})
-            list(GET TEMP 0 SRC)
-            list(GET TEMP 1 DST)
-            set(COPY_COMMAND ${SRC} $<TARGET_FILE_DIR:${PARAMS_NAME}>/${DST})
-            set(INSTALL_DST ${CMAKE_INSTALL_PREFIX}/Engine/Binaries/${DST})
-        else ()
-            set(SRC ${R})
-            set(COPY_COMMAND ${SRC} $<TARGET_FILE_DIR:${PARAMS_NAME}>)
-            set(INSTALL_DST ${CMAKE_INSTALL_PREFIX}/Engine/Binaries)
-        endif ()
-
-        if (IS_DIRECTORY ${SRC})
-            add_custom_command(
-                TARGET ${PARAMS_NAME} POST_BUILD
-                COMMAND ${CMAKE_COMMAND} -E copy_directory_if_different ${COPY_COMMAND}
-            )
-            if (NOT ${PARAMS_NOT_INSTALL})
-                install(
-                    DIRECTORY ${SRC} DESTINATION ${INSTALL_DST}
-                )
-            endif ()
-        else ()
-            add_custom_command(
-                TARGET ${PARAMS_NAME} POST_BUILD
-                COMMAND ${CMAKE_COMMAND} -E copy_if_different ${COPY_COMMAND}
+    foreach (d ${arg_DEP_TARGET})
+        list(APPEND runtime_deps $<TARGET_FILE:${d}>)
+    endforeach ()
+    foreach(r ${runtime_deps})
+        add_custom_command(
+            TARGET ${arg_NAME} POST_BUILD
+            COMMAND ${CMAKE_COMMAND} -E copy_if_different ${r} $<TARGET_FILE_DIR:${arg_NAME}>
+        )
+        if (NOT ${arg_NOT_INSTALL})
+            install(
+                FILES ${r} DESTINATION ${CMAKE_INSTALL_PREFIX}/${SUB_PROJECT_NAME}/Binaries
             )
-            if (NOT ${PARAMS_NOT_INSTALL})
-                install(
-                    FILES ${SRC} DESTINATION ${INSTALL_DST}
-                )
-            endif ()
         endif ()
     endforeach()
 endfunction()
 
 function(exp_expand_resource_path_expression)
-    cmake_parse_arguments(PARAMS "" "INPUT;OUTPUT_SRC;OUTPUT_DST" "" ${ARGN})
+    set(options "")
+    set(singleValueArgs INPUT OUTPUT_SRC OUTPUT_DST)
+    set(multiValueArgs "")
+    cmake_parse_arguments(arg "${options}" "${singleValueArgs}" "${multiValueArgs}" ${ARGN})
 
-    string(REPLACE "->" ";" TEMP ${PARAMS_INPUT})
-    list(GET TEMP 0 SRC)
-    list(GET TEMP 1 DST)
+    string(REPLACE "->" ";" temp ${arg_INPUT})
+    list(GET temp 0 src)
+    list(GET temp 1 dst)
 
-    set(${PARAMS_OUTPUT_SRC} ${SRC} PARENT_SCOPE)
-    set(${PARAMS_OUTPUT_DST} ${DST} PARENT_SCOPE)
+    set(${arg_OUTPUT_SRC} ${src} PARENT_SCOPE)
+    set(${arg_OUTPUT_DST} ${dst} PARENT_SCOPE)
 endfunction()
 
 function(exp_add_resources_copy_command)
-    cmake_parse_arguments(PARAMS "NOT_INSTALL" "NAME" "RES" ${ARGN})
+    set(options NOT_INSTALL)
+    set(singleValueArgs NAME)
+    set(multiValueArgs RES)
+    cmake_parse_arguments(arg "${options}" "${singleValueArgs}" "${multiValueArgs}" ${ARGN})
 
-    foreach(R ${PARAMS_RES})
+    foreach(r ${arg_RES})
         exp_expand_resource_path_expression(
-            INPUT ${R}
-            OUTPUT_SRC SRC
-            OUTPUT_DST DST
+            INPUT ${r}
+            OUTPUT_SRC src
+            OUTPUT_DST dst
         )
 
-        list(APPEND COPY_COMMANDS COMMAND ${CMAKE_COMMAND} -E copy_if_different ${SRC} $<TARGET_FILE_DIR:${PARAMS_NAME}>/${DST})
+        list(APPEND copy_commands COMMAND ${CMAKE_COMMAND} -E copy_if_different ${src} $<TARGET_FILE_DIR:${arg_NAME}>/${dst})
 
-        get_filename_component(ABSOLUTE_DST ${CMAKE_INSTALL_PREFIX}/Engine/Binaries/${DST} ABSOLUTE)
-        get_filename_component(DST_DIR ${ABSOLUTE_DST} DIRECTORY)
-        if (NOT ${PARAMS_NOT_INSTALL})
-            install(FILES ${SRC} DESTINATION ${DST_DIR})
+        get_filename_component(absolute_dst ${CMAKE_INSTALL_PREFIX}/${SUB_PROJECT_NAME}/Binaries/${dst} ABSOLUTE)
+        get_filename_component(dst_dir ${absolute_dst} DIRECTORY)
+        if (NOT ${arg_NOT_INSTALL})
+            install(FILES ${src} DESTINATION ${dst_dir})
         endif ()
     endforeach()
 
-    set(COPY_RES_TARGET_NAME ${PARAMS_NAME}.CopyRes)
+    set(copy_res_target_name ${arg_NAME}.CopyRes)
     add_custom_target(
-        ${COPY_RES_TARGET_NAME}
-        ${COPY_COMMANDS}
+        ${copy_res_target_name}
+        ${copy_commands}
     )
-    add_dependencies(${PARAMS_NAME} ${COPY_RES_TARGET_NAME})
+    add_dependencies(${arg_NAME} ${copy_res_target_name})
 endfunction()
 
-function(exp_get_target_include_dirs_recurse)
-    cmake_parse_arguments(PARAMS "" "NAME;OUTPUT" "" ${ARGN})
+function(exp_gather_target_include_dirs)
+    set(options "")
+    set(singleValueArgs NAME OUTPUT)
+    set(multiValueArgs "")
+    cmake_parse_arguments(arg "${options}" "${singleValueArgs}" "${multiValueArgs}" ${ARGN})
 
-    if (NOT (TARGET ${PARAMS_NAME}))
+    if (NOT (TARGET ${arg_NAME}))
         return()
     endif()
 
-    get_target_property(3RD_TYPE ${PARAMS_NAME} 3RD_TYPE)
-    if ("${3RD_TYPE}" STREQUAL "3RD_TYPE-NOTFOUND")
-        get_target_property(TARGET_INCS ${PARAMS_NAME} INCLUDE_DIRECTORIES)
-        if (NOT ("${TARGET_INCS}" STREQUAL "TARGET_INCS-NOTFOUND"))
-            foreach(TARGET_INC ${TARGET_INCS})
-                list(APPEND RESULT ${TARGET_INC})
-            endforeach()
-        endif()
-
-        get_target_property(TARGET_LIBS ${PARAMS_NAME} LINK_LIBRARIES)
-        if (NOT ("${TARGET_LIBS}" STREQUAL "TARGET_LIBS-NOTFOUND"))
-            foreach(TARGET_LIB ${TARGET_LIBS})
-                exp_get_target_include_dirs_recurse(
-                    NAME ${TARGET_LIB}
-                    OUTPUT LIB_INCS
-                )
-                foreach(LIB_INC ${LIB_INCS})
-                    list(APPEND RESULT ${LIB_INC})
-                endforeach()
-            endforeach()
-        endif()
-    else ()
-        get_target_property(3RD_INCLUDE ${PARAMS_NAME} 3RD_INCLUDE)
-        if (NOT ("${3RD_INCLUDE}" STREQUAL "3RD_INCLUDE-NOTFOUND"))
-            foreach(3RD_INC ${3RD_INCLUDE})
-                list(APPEND RESULT ${3RD_INC})
+    get_target_property(target_incs ${arg_NAME} INTERFACE_INCLUDE_DIRECTORIES)
+    if (NOT ("${target_incs}" STREQUAL "target_incs-NOTFOUND"))
+        foreach(target_inc ${target_incs})
+            list(APPEND result ${target_inc})
+        endforeach()
+    endif()
+
+    get_target_property(target_libs ${arg_NAME} LINK_LIBRARIES)
+    if (NOT ("${target_libs}" STREQUAL "target_libs-NOTFOUND"))
+        foreach(target_lib ${target_libs})
+            exp_gather_target_include_dirs(
+                NAME ${target_lib}
+                OUTPUT lib_incs
+            )
+            foreach(lib_inc ${lib_incs})
+                list(APPEND result ${lib_inc})
             endforeach()
-        endif ()
-    endif ()
+        endforeach()
+    endif()
 
-    list(REMOVE_DUPLICATES RESULT)
-    set(${PARAMS_OUTPUT} ${RESULT} PARENT_SCOPE)
+    list(REMOVE_DUPLICATES result)
+    set(${arg_OUTPUT} ${result} PARENT_SCOPE)
 endfunction()
 
 function(exp_add_mirror_info_source_generation_target)
-    cmake_parse_arguments(PARAMS "DYNAMIC" "NAME;OUTPUT_SRC;OUTPUT_TARGET_NAME" "SEARCH_DIR;PUBLIC_INC;PRIVATE_INC;LIB;FRAMEWORK_DIR" ${ARGN})
-
-    if (DEFINED PARAMS_PUBLIC_INC)
-        list(APPEND INC ${PARAMS_PUBLIC_INC})
+    set(options DYNAMIC)
+    set(singleValueArgs NAME OUTPUT_SRC OUTPUT_TARGET_NAME)
+    set(multiValueArgs SEARCH_DIR PUBLIC_INC PRIVATE_INC LIB FRAMEWORK_DIR)
+    cmake_parse_arguments(arg "${options}" "${singleValueArgs}" "${multiValueArgs}" ${ARGN})
+
+    if (DEFINED arg_PUBLIC_INC)
+        foreach (i ${arg_PUBLIC_INC})
+            get_filename_component(absolute_i ${i} ABSOLUTE)
+            list(APPEND inc ${absolute_i})
+        endforeach ()
     endif()
-    if (DEFINED PARAMS_PRIVATE_INC)
-        list(APPEND INC ${PARAMS_PRIVATE_INC})
+    if (DEFINED arg_PRIVATE_INC)
+        foreach (i ${arg_PRIVATE_INC})
+            get_filename_component(absolute_i ${i} ABSOLUTE)
+            list(APPEND inc ${absolute_i})
+        endforeach ()
     endif()
-    if (DEFINED PARAMS_LIB)
-        foreach (L ${PARAMS_LIB})
-            exp_get_target_include_dirs_recurse(
-                NAME ${L}
-                OUTPUT TARGET_INCS
+    if (DEFINED arg_LIB)
+        foreach (l ${arg_LIB})
+            exp_gather_target_include_dirs(
+                NAME ${l}
+                OUTPUT target_incs
             )
-            foreach (I ${TARGET_INCS})
-                list(APPEND INC ${I})
+            foreach (i ${target_incs})
+                list(APPEND inc ${i})
             endforeach ()
         endforeach()
     endif()
-    list(REMOVE_DUPLICATES INC)
+    list(REMOVE_DUPLICATES inc)
 
-    list(APPEND INC_ARGS "-I")
-    foreach (I ${INC})
-        get_filename_component(ABSOLUTE_I ${I} ABSOLUTE)
-        list(APPEND INC_ARGS ${ABSOLUTE_I})
+    list(APPEND inc_args "-I")
+    foreach (i ${inc})
+        list(APPEND inc_args ${i})
     endforeach()
 
-    if (DEFINED PARAMS_FRAMEWORK_DIR)
-        list(APPEND FWK_DIR ${PARAMS_FRAMEWORK_DIR})
-        list(APPEND FWK_DIR_ARGS "-F")
+    if (DEFINED arg_FRAMEWORK_DIR)
+        list(APPEND fwk_dir ${arg_FRAMEWORK_DIR})
+        list(APPEND fwk_dir_args "-F")
     endif ()
-    list(REMOVE_DUPLICATES FWK_DIR)
+    list(REMOVE_DUPLICATES fwk_dir)
 
-    foreach (F ${FWK_DIR})
-        get_filename_component(ABSOLUTE_F ${F} ABSOLUTE)
-        list(APPEND FWK_DIR_ARGS ${ABSOLUTE_F})
+    foreach (f ${fwk_dir})
+        get_filename_component(absolute_f ${f} ABSOLUTE)
+        list(APPEND fwk_dir_args ${absolute_f})
     endforeach ()
 
-    if (${PARAMS_DYNAMIC})
-        list(APPEND DYNAMIC_ARG "-d")
+    if (${arg_DYNAMIC})
+        list(APPEND dynamic_arg "-d")
     endif ()
 
-    foreach (SEARCH_DIR ${PARAMS_SEARCH_DIR})
-        file(GLOB_RECURSE INPUT_HEADER_FILES "${SEARCH_DIR}/*.h")
-        foreach (INPUT_HEADER_FILE ${INPUT_HEADER_FILES})
-            string(REPLACE "${CMAKE_SOURCE_DIR}/" "" TEMP ${INPUT_HEADER_FILE})
-            get_filename_component(DIR ${TEMP} DIRECTORY)
-            get_filename_component(FILENAME ${TEMP} NAME_WE)
+    foreach (search_dir ${arg_SEARCH_DIR})
+        file(GLOB_RECURSE input_header_files "${search_dir}/*.h")
+        foreach (input_header_file ${input_header_files})
+            string(REPLACE "${CMAKE_SOURCE_DIR}/" "" temp ${input_header_file})
+            get_filename_component(dir ${temp} DIRECTORY)
+            get_filename_component(filename ${temp} NAME_WE)
 
-            set(OUTPUT_SOURCE "${CMAKE_BINARY_DIR}/Generated/MirrorInfoSource/${DIR}/${FILENAME}.generated.cpp")
-            list(APPEND OUTPUT_SOURCES ${OUTPUT_SOURCE})
+            set(output_source "${CMAKE_BINARY_DIR}/Generated/MirrorInfoSource/${dir}/${filename}.generated.cpp")
+            list(APPEND output_sources ${output_source})
 
             add_custom_command(
-                OUTPUT ${OUTPUT_SOURCE}
-                COMMAND "$<TARGET_FILE:MirrorTool>" ${DYNAMIC_ARG} "-i" ${INPUT_HEADER_FILE} "-o" ${OUTPUT_SOURCE} ${INC_ARGS} ${FWK_DIR_ARGS}
-                DEPENDS MirrorTool ${INPUT_HEADER_FILE}
+                OUTPUT ${output_source}
+                COMMAND "$<TARGET_FILE:MirrorTool>" ${dynamic_arg} "-i" ${input_header_file} "-o" ${output_source} ${inc_args} ${fwk_dir_args}
+                DEPENDS MirrorTool ${input_header_file}
             )
         endforeach()
     endforeach ()
 
-    set(CUSTOM_TARGET_NAME "${PARAMS_NAME}.Generated")
+    set(custom_target_name "${arg_NAME}.Generated")
     add_custom_target(
-        ${CUSTOM_TARGET_NAME}
-        DEPENDS MirrorTool ${OUTPUT_SOURCES}
+        ${custom_target_name}
+        DEPENDS MirrorTool ${output_sources}
     )
-    set(${PARAMS_OUTPUT_SRC} ${OUTPUT_SOURCES} PARENT_SCOPE)
-    set(${PARAMS_OUTPUT_TARGET_NAME} ${CUSTOM_TARGET_NAME} PARENT_SCOPE)
+    set(${arg_OUTPUT_SRC} ${output_sources} PARENT_SCOPE)
+    set(${arg_OUTPUT_TARGET_NAME} ${custom_target_name} PARENT_SCOPE)
 
-    if (DEFINED PARAMS_LIB)
-        add_dependencies(${CUSTOM_TARGET_NAME} ${PARAMS_LIB})
+    if (DEFINED arg_LIB)
+        add_dependencies(${custom_target_name} ${arg_LIB})
     endif()
 endfunction()
 
 function(exp_add_executable)
-    cmake_parse_arguments(PARAMS "SAMPLE;NOT_INSTALL" "NAME" "SRC;INC;LINK;LIB;DEP_TARGET;RES;REFLECT" ${ARGN})
+    set(options SAMPLE NOT_INSTALL)
+    set(singleValueArgs NAME)
+    set(multiValueArgs SRC INC LINK LIB DEP_TARGET RES REFLECT)
+    cmake_parse_arguments(arg "${options}" "${singleValueArgs}" "${multiValueArgs}" ${ARGN})
 
-    if (${PARAMS_SAMPLE} AND (NOT ${BUILD_SAMPLE}))
+    if (${arg_SAMPLE} AND (NOT ${BUILD_SAMPLE}))
         return()
     endif()
 
-    if (${PARAMS_NOT_INSTALL})
-        set(NOT_INSTALL_FLAG NOT_INSTALL)
+    if (${arg_NOT_INSTALL})
+        set(not_install_flag NOT_INSTALL)
     else ()
-        set(NOT_INSTALL_FLAG "")
+        set(not_install_flag "")
     endif ()
 
-    if (DEFINED PARAMS_REFLECT)
+    if (DEFINED arg_REFLECT)
         exp_add_mirror_info_source_generation_target(
-            NAME ${PARAMS_NAME}
-            OUTPUT_SRC GENERATED_SRC
-            OUTPUT_TARGET_NAME GENERATED_TARGET
-            SEARCH_DIR ${PARAMS_REFLECT}
-            PRIVATE_INC ${PARAMS_INC}
-            LIB ${PARAMS_LIB}
+            NAME ${arg_NAME}
+            OUTPUT_SRC generated_src
+            OUTPUT_TARGET_NAME generated_target
+            SEARCH_DIR ${arg_REFLECT}
+            PRIVATE_INC ${arg_INC}
+            LIB ${arg_LIB}
         )
     endif()
 
-    add_executable(${PARAMS_NAME})
+    add_executable(${arg_NAME})
     target_sources(
-        ${PARAMS_NAME}
-        PRIVATE ${PARAMS_SRC} ${GENERATED_SRC}
+        ${arg_NAME}
+        PRIVATE ${arg_SRC} ${generated_src}
+    )
+    get_cmake_property(generated_is_multi_config GENERATOR_IS_MULTI_CONFIG)
+    if (${generated_is_multi_config})
+        set(runtime_output_dir ${CMAKE_BINARY_DIR}/Dist/$<CONFIG>/${SUB_PROJECT_NAME}/Binaries)
+    else ()
+        set(runtime_output_dir ${CMAKE_BINARY_DIR}/Dist/${SUB_PROJECT_NAME}/Binaries)
+    endif ()
+    set_target_properties(
+        ${arg_NAME} PROPERTIES
+        RUNTIME_OUTPUT_DIRECTORY ${runtime_output_dir}
     )
+
     target_include_directories(
-        ${PARAMS_NAME}
-        PRIVATE ${PARAMS_INC}
+        ${arg_NAME}
+        PRIVATE ${arg_INC}
     )
     target_link_directories(
-        ${PARAMS_NAME}
-        PRIVATE ${PARAMS_LINK}
-    )
-    exp_link_basic_libs(
-        NAME ${PARAMS_NAME}
-        LIB ${BASIC_LIBS}
+        ${arg_NAME}
+        PRIVATE ${arg_LINK}
     )
-    exp_link_libs(
-        NAME ${PARAMS_NAME}
-        LIB ${PARAMS_LIB}
+    target_link_libraries(
+        ${arg_NAME}
+        PUBLIC ${arg_LIB}
     )
-    exp_add_runtime_deps_copy_command(
-        NAME ${PARAMS_NAME}
-        ${NOT_INSTALL_FLAG}
+    exp_process_runtime_dependencies(
+        NAME ${arg_NAME}
+        DEP_TARGET ${arg_DEP_TARGET}
+        ${not_install_flag}
     )
     exp_add_resources_copy_command(
-        NAME ${PARAMS_NAME}
-        RES ${PARAMS_RES}
-        ${NOT_INSTALL_FLAG}
+        NAME ${arg_NAME}
+        RES ${arg_RES}
+        ${not_install_flag}
     )
-    if (DEFINED PARAMS_DEP_TARGET)
-        add_dependencies(${PARAMS_NAME} ${PARAMS_DEP_TARGET})
+    if (DEFINED arg_DEP_TARGET)
+        add_dependencies(${arg_NAME} ${arg_DEP_TARGET})
     endif()
-    if (DEFINED PARAMS_REFLECT)
-        add_dependencies(${PARAMS_NAME} ${GENERATED_TARGET})
+    if (DEFINED arg_REFLECT)
+        add_dependencies(${arg_NAME} ${generated_target})
     endif()
 
     if (${MSVC})
-        set_target_properties(${PARAMS_NAME} PROPERTIES VS_DEBUGGER_WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})
+        set_target_properties(
+            ${arg_NAME} PROPERTIES
+            VS_DEBUGGER_WORKING_DIRECTORY ${runtime_output_dir}
+        )
     endif()
 
-    if (NOT ${PARAMS_NOT_INSTALL})
+    if (NOT ${arg_NOT_INSTALL})
         install(
-            TARGETS ${PARAMS_NAME}
-            RUNTIME DESTINATION ${CMAKE_INSTALL_PREFIX}/Engine/Binaries
+            TARGETS ${arg_NAME}
+            EXPORT ${SUB_PROJECT_NAME}Targets
+            RUNTIME DESTINATION ${SUB_PROJECT_NAME}/Binaries
         )
 
         if (${CMAKE_SYSTEM_NAME} STREQUAL "Darwin")
-            install(CODE "execute_process(COMMAND install_name_tool -add_rpath @executable_path ${CMAKE_INSTALL_PREFIX}/Engine/Binaries/$<TARGET_FILE_NAME:${PARAMS_NAME}>)")
+            install(CODE "execute_process(COMMAND install_name_tool -add_rpath @executable_path ${CMAKE_INSTALL_PREFIX}/${SUB_PROJECT_NAME}/Binaries/$<TARGET_FILE_NAME:${arg_NAME}>)")
         endif ()
     endif ()
 endfunction()
 
 function(exp_add_library)
-    cmake_parse_arguments(PARAMS "NOT_INSTALL" "NAME;TYPE" "SRC;PRIVATE_INC;PUBLIC_INC;PRIVATE_LINK;LIB;REFLECT" ${ARGN})
+    set(options NOT_INSTALL)
+    set(singleValueArgs NAME TYPE)
+    set(multiValueArgs SRC PRIVATE_INC PUBLIC_INC PRIVATE_LINK PUBLIC_LINK PRIVATE_LIB PUBLIC_LIB PRIVATE_MERGE_LIB PUBLIC_MERGE_LIB REFLECT)
+    cmake_parse_arguments(arg "${options}" "${singleValueArgs}" "${multiValueArgs}" ${ARGN})
 
-    if ("${PARAMS_TYPE}" STREQUAL "SHARED")
-        list(APPEND PARAMS_PUBLIC_INC ${API_HEADER_DIR}/${PARAMS_NAME})
+    if ("${arg_TYPE}" STREQUAL "SHARED")
+        list(APPEND arg_PUBLIC_INC ${API_HEADER_DIR}/${arg_NAME})
     endif ()
 
-    if (DEFINED PARAMS_REFLECT)
-        if ("${PARAMS_TYPE}" STREQUAL "SHARED")
-            list(APPEND EXTRA_PARAMS DYNAMIC)
+    if (DEFINED arg_REFLECT)
+        if ("${arg_TYPE}" STREQUAL "SHARED")
+            list(APPEND extra_params DYNAMIC)
         endif ()
 
         exp_add_mirror_info_source_generation_target(
-            NAME ${PARAMS_NAME}
-            OUTPUT_SRC GENERATED_SRC
-            OUTPUT_TARGET_NAME GENERATED_TARGET
-            SEARCH_DIR ${PARAMS_REFLECT}
-            PUBLIC_INC ${PARAMS_PUBLIC_INC}
-            PRIVATE_INC ${PARAMS_PRIVATE_INC}
-            LIB ${PARAMS_LIB}
-            ${EXTRA_PARAMS}
+            NAME ${arg_NAME}
+            OUTPUT_SRC generated_src
+            OUTPUT_TARGET_NAME generated_target
+            SEARCH_DIR ${arg_REFLECT}
+            PUBLIC_INC ${arg_PUBLIC_INC}
+            PRIVATE_INC ${arg_PRIVATE_INC}
+            LIB ${arg_PRIVATE_LIB} ${arg_PUBLIC_LIB}
+            ${extra_params}
         )
     endif()
 
     add_library(
-        ${PARAMS_NAME}
-        ${PARAMS_TYPE}
+        ${arg_NAME}
+        ${arg_TYPE}
     )
     target_sources(
-        ${PARAMS_NAME}
-        PRIVATE ${PARAMS_SRC} ${GENERATED_SRC}
+        ${arg_NAME}
+        PRIVATE ${arg_SRC} ${generated_src}
+    )
+    get_cmake_property(generator_is_multi_config GENERATOR_IS_MULTI_CONFIG)
+    if (${generator_is_multi_config})
+        set(runtime_output_dir ${CMAKE_BINARY_DIR}/Targets/${SUB_PROJECT_NAME}/${arg_NAME}/$<CONFIG>/Binaries)
+        set(library_output_dir ${CMAKE_BINARY_DIR}/Targets/${SUB_PROJECT_NAME}/${arg_NAME}/$<CONFIG>/Binaries)
+        set(archive_output_directory ${CMAKE_BINARY_DIR}/Targets/${SUB_PROJECT_NAME}/${arg_NAME}/$<CONFIG>/Lib)
+    else ()
+        set(runtime_output_dir ${CMAKE_BINARY_DIR}/Targets/${SUB_PROJECT_NAME}/${arg_NAME}/Binaries)
+        set(library_output_dir ${CMAKE_BINARY_DIR}/Targets/${SUB_PROJECT_NAME}/${arg_NAME}/Binaries)
+        set(archive_output_directory ${CMAKE_BINARY_DIR}/Targets/${SUB_PROJECT_NAME}/${arg_NAME}/Lib)
+    endif ()
+    set_target_properties(
+        ${arg_NAME} PROPERTIES
+        RUNTIME_OUTPUT_DIRECTORY ${runtime_output_dir}
+        LIBRARY_OUTPUT_DIRECTORY ${library_output_dir}
+        ARCHIVE_OUTPUT_DIRECTORY ${archive_output_directory}
     )
+
+    foreach (inc ${arg_PUBLIC_INC})
+        list(APPEND public_inc ${inc})
+    endforeach ()
+    foreach (lib ${arg_PUBLIC_MERGE_LIB})
+        if (TARGET ${lib})
+            get_target_property(target_incs ${lib} INTERFACE_INCLUDE_DIRECTORIES)
+            if (NOT ("${target_incs}" STREQUAL "target_incs-NOTFOUND"))
+                foreach(target_inc ${target_incs})
+                    list(APPEND public_inc ${target_inc})
+                endforeach()
+            endif()
+        endif ()
+    endforeach ()
+
+    foreach (inc ${public_inc})
+        get_filename_component(absolute_inc ${inc} ABSOLUTE)
+        list(APPEND public_build_inc $<BUILD_INTERFACE:${absolute_inc}>)
+    endforeach ()
     target_include_directories(
-        ${PARAMS_NAME}
-        PRIVATE ${PARAMS_PRIVATE_INC}
-        PUBLIC ${PARAMS_PUBLIC_INC}
+        ${arg_NAME}
+        PRIVATE ${arg_PRIVATE_INC}
+        PUBLIC ${public_build_inc} $<INSTALL_INTERFACE:${SUB_PROJECT_NAME}/Target/${arg_NAME}/Include>
     )
+
     target_link_directories(
-        ${PARAMS_NAME}
-        PRIVATE ${PARAMS_PRIVATE_LINK}
-        PUBLIC ${PARAMS_PUBLIC_LINK}
-    )
-    exp_link_basic_libs(
-        NAME ${PARAMS_NAME}
-        LIB ${BASIC_LIBS}
+        ${arg_NAME}
+        PRIVATE ${arg_PRIVATE_LINK}
+        PUBLIC ${arg_PUBLIC_LINK}
     )
-    exp_link_libs(
-        NAME ${PARAMS_NAME}
-        LIB ${PARAMS_LIB}
+
+    foreach (lib ${arg_PRIVATE_MERGE_LIB})
+        list(APPEND merge_lib ${lib})
+    endforeach ()
+    foreach (lib ${arg_PUBLIC_MERGE_LIB})
+        list(APPEND merge_lib ${lib})
+    endforeach ()
+
+    foreach (lib ${merge_lib})
+        list(APPEND build_merge_lib $<BUILD_INTERFACE:${lib}>)
+
+        exp_gather_target_runtime_dependencies_recurse(
+            NAME ${lib}
+            OUT_RUNTIME_DEP temp_runtime_dep
+        )
+        list(APPEND runtime_dep ${temp_runtime_dep})
+    endforeach ()
+    target_link_libraries(
+        ${arg_NAME}
+        PRIVATE ${build_merge_lib}
+        PUBLIC ${arg_PUBLIC_LIB}
     )
 
+    if (DEFINED runtime_dep)
+        foreach (r ${runtime_dep})
+            get_filename_component(FILE_NAME ${r} NAME)
+            list(APPEND commands COMMAND ${CMAKE_COMMAND} -E copy_if_different ${r} ${runtime_output_dir}/${FILE_NAME})
+            list(APPEND runtime_dep_files $<TARGET_BIN_DIR>/${FILE_NAME})
+        endforeach ()
+        add_custom_command(
+            TARGET ${arg_NAME} POST_BUILD
+            ${commands}
+        )
+
+        # workaround to make EXPORT_PROPERTIES support generator expression
+        string(REPLACE "$<" "[" runtime_dep_files "${runtime_dep_files}")
+        string(REPLACE ">" "]" runtime_dep_files "${runtime_dep_files}")
+        set_target_properties(
+            ${arg_NAME} PROPERTIES
+            EXPORT_PROPERTIES "runtime_dep"
+            RUNTIME_DEP "${runtime_dep_files}"
+        )
+    endif ()
+
     if (${MSVC})
         target_compile_options(
-            ${PARAMS_NAME}
-            PUBLIC /MD$<$<CONFIG:Debug>:d>
+            ${arg_NAME}
+            PRIVATE /MD$<$<CONFIG:Debug>:d>
         )
     endif()
 
-    if ("${PARAMS_TYPE}" STREQUAL "SHARED")
-        string(TOUPPER ${PARAMS_NAME}_API API_NAME)
-        string(REPLACE "-" "/" API_DIR ${PARAMS_NAME})
+    if ("${arg_TYPE}" STREQUAL "SHARED")
+        string(TOUPPER ${arg_NAME}_API api_name)
+        string(REPLACE "-" "/" api_dir ${arg_NAME})
 
         generate_export_header(
-            ${PARAMS_NAME}
-            EXPORT_MACRO_NAME ${API_NAME}
-            EXPORT_FILE_NAME ${API_HEADER_DIR}/${PARAMS_NAME}/${API_DIR}/Api.h
+            ${arg_NAME}
+            EXPORT_MACRO_NAME ${api_name}
+            EXPORT_FILE_NAME ${API_HEADER_DIR}/${arg_NAME}/${api_dir}/Api.h
         )
     endif()
 
-    if (DEFINED PARAMS_REFLECT)
-        add_dependencies(${PARAMS_NAME} ${GENERATED_TARGET})
+    if (DEFINED arg_REFLECT)
+        add_dependencies(${arg_NAME} ${generated_target})
     endif()
 
-    if (NOT ${PARAMS_NOT_INSTALL})
-        foreach (INC ${PARAMS_PUBLIC_INC})
-            get_filename_component(ABSOLUTE_INC ${INC} ABSOLUTE)
-            file(GLOB_RECURSE PUBLIC_HEADERS ${ABSOLUTE_INC}/*.h)
-            target_sources(
-                ${PARAMS_NAME}
-                PUBLIC FILE_SET HEADERS
-                BASE_DIRS ${ABSOLUTE_INC} FILES ${PUBLIC_HEADERS}
-            )
+    if (NOT ${arg_NOT_INSTALL})
+        foreach (inc ${public_inc})
+            list(APPEND install_inc ${inc}/)
         endforeach ()
+        install(
+            DIRECTORY ${install_inc}
+            DESTINATION ${SUB_PROJECT_NAME}/Target/${arg_NAME}/Include
+        )
 
-        if (NOT ${CMAKE_SYSTEM_NAME} STREQUAL "Darwin" OR "${PARAMS_TYPE}" STREQUAL "STATIC")
+        if (DEFINED runtime_dep)
             install(
-                TARGETS ${PARAMS_NAME}
-                FILE_SET HEADERS DESTINATION ${CMAKE_INSTALL_PREFIX}/Engine/Include
-                ARCHIVE DESTINATION ${CMAKE_INSTALL_PREFIX}/Engine/Lib
-                LIBRARY DESTINATION ${CMAKE_INSTALL_PREFIX}/Engine/Lib
-                RUNTIME DESTINATION ${CMAKE_INSTALL_PREFIX}/Engine/Binaries
+                FILES ${runtime_dep}
+                DESTINATION ${SUB_PROJECT_NAME}/Target/${arg_NAME}/Binaries
             )
         endif ()
 
-        if (${CMAKE_SYSTEM_NAME} STREQUAL "Darwin" AND "${PARAMS_TYPE}" STREQUAL "SHARED")
+        install(
+            TARGETS ${arg_NAME}
+            EXPORT ${SUB_PROJECT_NAME}Targets
+            ARCHIVE DESTINATION ${SUB_PROJECT_NAME}/Target/${arg_NAME}/Lib
+            LIBRARY DESTINATION ${SUB_PROJECT_NAME}/Target/${arg_NAME}/Lib
+            RUNTIME DESTINATION ${SUB_PROJECT_NAME}/Binaries
+        )
+        if ("${arg_TYPE}" STREQUAL "SHARED")
             install(
-                FILES $<TARGET_FILE:${PARAMS_NAME}>
-                DESTINATION ${CMAKE_INSTALL_PREFIX}/Engine/Binaries
+                FILES $<TARGET_FILE:${arg_NAME}>
+                DESTINATION ${SUB_PROJECT_NAME}/Target/${arg_NAME}/Binaries
             )
         endif ()
     endif ()
@@ -496,59 +527,79 @@ function(exp_add_test)
         return()
     endif()
 
-    cmake_parse_arguments(PARAMS "META" "NAME" "SRC;INC;LINK;LIB;DEP_TARGET;RES;REFLECT" ${ARGN})
+    set(options META)
+    set(singleValueArgs NAME)
+    set(multiValueArgs SRC INC LINK LIB DEP_TARGET RES REFLECT)
+    cmake_parse_arguments(arg "${options}" "${singleValueArgs}" "${multiValueArgs}" ${ARGN})
 
-    if (DEFINED PARAMS_REFLECT)
+    if (DEFINED arg_REFLECT)
         exp_add_mirror_info_source_generation_target(
-            NAME ${PARAMS_NAME}
-            OUTPUT_SRC GENERATED_SRC
-            OUTPUT_TARGET_NAME GENERATED_TARGET
-            SEARCH_DIR ${PARAMS_REFLECT}
-            PRIVATE_INC ${PARAMS_INC}
-            LIB ${PARAMS_LIB} ${BASIC_LIBS} ${BASIC_TEST_LIBS}
+            NAME ${arg_NAME}
+            OUTPUT_SRC generated_src
+            OUTPUT_TARGET_NAME generated_target
+            SEARCH_DIR ${arg_REFLECT}
+            PRIVATE_INC ${arg_INC}
+            LIB ${arg_LIB}
         )
     endif()
 
-    add_executable(${PARAMS_NAME})
+    add_executable(${arg_NAME})
     target_sources(
-        ${PARAMS_NAME}
-        PRIVATE ${PARAMS_SRC} ${GENERATED_SRC}
+        ${arg_NAME}
+        PRIVATE ${arg_SRC} ${generated_src}
     )
+    get_cmake_property(generator_is_multi_config GENERATOR_IS_MULTI_CONFIG)
+    if (${generator_is_multi_config})
+        set_target_properties(
+            ${arg_NAME} PROPERTIES
+            RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/Dist/$<CONFIG>/${SUB_PROJECT_NAME}/Binaries
+        )
+    else ()
+        set_target_properties(
+            ${arg_NAME} PROPERTIES
+            RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/Dist/${SUB_PROJECT_NAME}/Binaries
+        )
+    endif ()
+
     target_include_directories(
-        ${PARAMS_NAME}
-        PRIVATE ${PARAMS_INC}
+        ${arg_NAME}
+        PRIVATE ${arg_INC}
     )
     target_link_directories(
-        ${PARAMS_NAME}
-        PRIVATE ${PARAMS_LINK}
-    )
-    exp_link_basic_libs(
-        NAME ${PARAMS_NAME}
-        LIB ${BASIC_LIBS} ${BASIC_TEST_LIBS}
+        ${arg_NAME}
+        PRIVATE ${arg_LINK}
     )
-    exp_link_libs(
-        NAME ${PARAMS_NAME}
-        LIB ${PARAMS_LIB}
+    target_link_libraries(
+        ${arg_NAME}
+        PRIVATE Test ${arg_LIB}
     )
-    exp_add_runtime_deps_copy_command(
-        NAME ${PARAMS_NAME}
+    exp_process_runtime_dependencies(
+        NAME ${arg_NAME}
+        DEP_TARGET ${arg_DEP_TARGET}
         NOT_INSTALL
     )
     exp_add_resources_copy_command(
-        NAME ${PARAMS_NAME}
-        RES ${PARAMS_RES}
+        NAME ${arg_NAME}
+        RES ${arg_RES}
         NOT_INSTALL
     )
-    if (DEFINED PARAMS_DEP_TARGET)
-        add_dependencies(${PARAMS_NAME} ${PARAMS_DEP_TARGET})
+    if (DEFINED arg_DEP_TARGET)
+        add_dependencies(${arg_NAME} ${arg_DEP_TARGET})
     endif()
-    if (DEFINED PARAMS_REFLECT)
-        add_dependencies(${PARAMS_NAME} ${GENERATED_TARGET})
+    if (DEFINED arg_REFLECT)
+        add_dependencies(${arg_NAME} ${generated_target})
     endif()
 
     add_test(
-        NAME ${PARAMS_NAME}
-        COMMAND ${PARAMS_NAME}
-        WORKING_DIRECTORY $<TARGET_FILE_DIR:${PARAMS_NAME}>
+        NAME ${arg_NAME}
+        COMMAND ${arg_NAME}
+        WORKING_DIRECTORY $<TARGET_FILE_DIR:${arg_NAME}>
     )
 endfunction()
+
+install(
+    EXPORT ${SUB_PROJECT_NAME}Targets
+    FILE ${SUB_PROJECT_NAME}Targets.cmake
+    NAMESPACE ${SUB_PROJECT_NAME}::
+    DESTINATION ${SUB_PROJECT_NAME}/CMake
+)
diff --git a/CMake/ThirdParty.cmake b/CMake/ThirdParty.cmake
index 98c94370..1d3716b7 100644
--- a/CMake/ThirdParty.cmake
+++ b/CMake/ThirdParty.cmake
@@ -1,458 +1,337 @@
-option(CUSTOM_3RD_REPO "using custom 3rd repo" OFF)
-
-if (${CUSTOM_3RD_REPO})
-    set(3RD_REPO ${3RD_REPO_URL} CACHE STRING "" FORCE)
-else()
-    set(3RD_REPO "http://1.13.181.171" CACHE STRING "" FORCE)
-endif()
-
-set(3RD_DIR ${CMAKE_SOURCE_DIR}/ThirdParty CACHE PATH "" FORCE)
-set(3RD_ZIP_DIR ${3RD_DIR}/Zip CACHE PATH "" FORCE)
-set(3RD_SOURCE_DIR ${3RD_DIR}/Lib CACHE PATH "" FORCE)
-set(3RD_BINARY_DIR ${CMAKE_BINARY_DIR}/ThirdPartyBuild CACHE PATH "" FORCE)
-set(3RD_INSTALL_DIR ${CMAKE_BINARY_DIR}/ThirdPartyInstall CACHE PATH "" FORCE)
-
 function(exp_download_and_extract_3rd_package)
-    cmake_parse_arguments(PARAMS "" "URL;SAVE_AS;EXTRACT_TO;HASH" "ARG" ${ARGN})
+    set(options "")
+    set(singleValueArgs URL SAVE_AS EXTRACT_TO)
+    set(multiValueArgs HASH)
+    cmake_parse_arguments(arg "${options}" "${singleValueArgs}" "${multiValueArgs}" ${ARGN})
 
-    if (EXISTS ${PARAMS_SAVE_AS})
-        message("found downloaded file for ${PARAMS_URL} -> ${PARAMS_SAVE_AS}")
+    if (EXISTS ${arg_SAVE_AS})
+        message("found downloaded file for ${arg_URL} -> ${arg_SAVE_AS}")
     else()
-        message("starting download package ${PARAMS_URL}")
+        message("starting download package ${arg_URL}")
         file(
             DOWNLOAD
-            ${PARAMS_URL} ${PARAMS_SAVE_AS}
+            ${arg_URL} ${arg_SAVE_AS}
             SHOW_PROGRESS
         )
     endif()
 
-    if (DEFINED PARAMS_HASH)
-        file(SHA256 ${PARAMS_SAVE_AS} HASH_VALUE)
-        if (NOT (${PARAMS_HASH} STREQUAL ${HASH_VALUE}))
-            message(FATAL_ERROR "check hash value failed for file ${PARAMS_SAVE_AS}, given ${PARAMS_HASH} actual ${HASH_VALUE}")
+    if (DEFINED arg_HASH)
+        exp_get_3rd_platform_value(
+            OUTPUT platform_hash
+            INPUT ${arg_HASH}
+        )
+
+        file(SHA256 ${arg_SAVE_AS} hash_value)
+        if (NOT (${platform_hash} STREQUAL ${hash_value}))
+            message(FATAL_ERROR "check hash value failed for file ${arg_SAVE_AS}, given ${platform_hash} actual ${hash_value}")
         endif ()
     endif()
 
-    if (NOT EXISTS ${PARAMS_EXTRACT_TO})
+    if (NOT EXISTS ${arg_EXTRACT_TO})
         file(
             ARCHIVE_EXTRACT
-            INPUT ${PARAMS_SAVE_AS}
-            DESTINATION ${PARAMS_EXTRACT_TO}
+            INPUT ${arg_SAVE_AS}
+            DESTINATION ${arg_EXTRACT_TO}
         )
     endif()
 endfunction()
 
 function(exp_expand_3rd_path_expression)
-    cmake_parse_arguments(PARAMS "" "OUTPUT;SOURCE_DIR;BINARY_DIR;INSTALL_DIR" "INPUT" ${ARGN})
-
-    foreach(I ${PARAMS_INPUT})
-        set(TEMP "${I}")
-        if (DEFINED PARAMS_SOURCE_DIR)
-            string(REPLACE "$<SOURCE_DIR>" ${PARAMS_SOURCE_DIR} TEMP ${TEMP})
+    set(options "")
+    set(singleValueArgs OUTPUT SOURCE_DIR BINARY_DIR INSTALL_DIR)
+    set(multiValueArgs INPUT)
+    cmake_parse_arguments(arg "${options}" "${singleValueArgs}" "${multiValueArgs}" ${ARGN})
+
+    foreach(i ${arg_INPUT})
+        set(temp "${i}")
+        if (DEFINED arg_SOURCE_DIR)
+            string(REPLACE "$<SOURCE_DIR>" ${arg_SOURCE_DIR} temp ${temp})
         endif()
-        if (DEFINED PARAMS_BINARY_DIR)
-            string(REPLACE "$<BINARY_DIR>" ${PARAMS_BINARY_DIR} TEMP ${TEMP})
+        if (DEFINED arg_BINARY_DIR)
+            string(REPLACE "$<BINARY_DIR>" ${arg_BINARY_DIR} temp ${temp})
         endif()
-        if (DEFINED PARAMS_INSTALL_DIR)
-            string(REPLACE "$<INSTALL_DIR>" ${PARAMS_INSTALL_DIR} TEMP ${TEMP})
+        if (DEFINED arg_INSTALL_DIR)
+            string(REPLACE "$<INSTALL_DIR>" ${arg_INSTALL_DIR} temp ${temp})
         endif()
-        list(APPEND RESULT ${TEMP})
+        list(APPEND result ${temp})
     endforeach()
 
-    set(${PARAMS_OUTPUT} ${RESULT} PARENT_SCOPE)
+    set(${arg_OUTPUT} ${result} PARENT_SCOPE)
 endfunction()
 
 function(exp_get_3rd_platform_value)
-    cmake_parse_arguments(PARAMS "ARCH" "OUTPUT" "INPUT" ${ARGN})
-
-    if (${PARAMS_ARCH})
-        set(PLATFORM_KEYWORDS "Windows-AMD64;Darwin-arm64")
-        set(CURRENT_KEYWORDS "${CMAKE_SYSTEM_NAME}-${CMAKE_SYSTEM_PROCESSOR}")
-    else()
-        set(PLATFORM_KEYWORDS "Windows;Darwin;Linux")
-        set(CURRENT_KEYWORDS "${CMAKE_SYSTEM_NAME}")
-    endif()
-
-    set(HAS_KEYWORDS FALSE)
-    foreach (I ${PARAMS_INPUT})
-        foreach (K ${PLATFORM_KEYWORDS})
-            if (${I} STREQUAL ${K})
-                set(HAS_KEYWORDS TRUE)
+    set(options "")
+    set(singleValueArgs OUTPUT)
+    set(multiValueArgs INPUT)
+    cmake_parse_arguments(arg "${options}" "${singleValueArgs}" "${multiValueArgs}" ${ARGN})
+
+    set(platform_keywords "Windows;Darwin;Linux")
+
+    set(has_keywords FALSE)
+    foreach (i ${arg_INPUT})
+        foreach (k ${platform_keywords})
+            if (${i} STREQUAL ${k})
+                set(has_keywords TRUE)
                 break()
             endif()
         endforeach()
 
-        if (${HAS_KEYWORDS})
+        if (${has_keywords})
             break()
         endif()
     endforeach()
 
-    set(START_LOG FALSE)
-    foreach (I ${PARAMS_INPUT})
-        if ((NOT ${START_LOG}) AND (${I} STREQUAL ${CURRENT_KEYWORDS}))
-            set(START_LOG TRUE)
+    set(start_log FALSE)
+    foreach (i ${arg_INPUT})
+        if ((NOT ${start_log}) AND (${i} STREQUAL ${CMAKE_SYSTEM_NAME}))
+            set(start_log TRUE)
             continue()
         endif()
 
-        if (NOT ${START_LOG})
+        if (NOT ${start_log})
             continue()
         endif()
 
-        set(END_LOG FALSE)
-        foreach (K ${PLATFORM_KEYWORDS})
-            if (${K} STREQUAL ${I})
-                set(END_LOG TRUE)
+        set(end_log FALSE)
+        foreach (k ${platform_keywords})
+            if (${k} STREQUAL ${i})
+                set(end_log TRUE)
                 break()
             endif()
         endforeach()
 
-        if (${END_LOG})
+        if (${end_log})
             break()
         endif()
 
-        list(APPEND RESULT ${I})
+        list(APPEND result ${i})
     endforeach ()
 
-    if (${HAS_KEYWORDS})
-        set(${PARAMS_OUTPUT} ${RESULT} PARENT_SCOPE)
+    if (${has_keywords})
+        set(${arg_OUTPUT} ${result} PARENT_SCOPE)
     else()
-        set(${PARAMS_OUTPUT} ${PARAMS_INPUT} PARENT_SCOPE)
+        set(${arg_OUTPUT} ${arg_INPUT} PARENT_SCOPE)
     endif()
 endfunction()
 
 function(exp_add_3rd_header_only_package)
-    cmake_parse_arguments(PARAMS "" "NAME;PLATFORM;VERSION" "HASH;INCLUDE" ${ARGN})
-
-    set(NAME "${PARAMS_NAME}")
-
-    if (DEFINED PARAMS_PLATFORM)
-        if ((NOT (${PARAMS_PLATFORM} STREQUAL "All")) AND (NOT (${PARAMS_PLATFORM} STREQUAL ${CMAKE_SYSTEM_NAME})))
-            return()
-        endif()
-        set(FULL_NAME "${PARAMS_NAME}-${PARAMS_PLATFORM}-${PARAMS_VERSION}")
-    else()
-        set(FULL_NAME "${PARAMS_NAME}-${CMAKE_SYSTEM_NAME}-${PARAMS_VERSION}")
-    endif()
-
-    set(URL "${3RD_REPO}/${FULL_NAME}.7z")
-    set(ZIP "${3RD_ZIP_DIR}/${FULL_NAME}.7z")
-    set(SOURCE_DIR "${3RD_SOURCE_DIR}/${FULL_NAME}")
-
-    exp_get_3rd_platform_value(
-        OUTPUT HASH_VALUE
-        INPUT ${PARAMS_HASH}
-    )
-    exp_download_and_extract_3rd_package(
-        URL ${URL}
-        SAVE_AS ${ZIP}
-        EXTRACT_TO ${SOURCE_DIR}
-        HASH ${HASH_VALUE}
-    )
-
-    add_custom_target(${NAME} ALL)
-    set_target_properties(
-        ${NAME} PROPERTIES
-        3RD_TYPE "HeaderOnly"
-    )
+    set(options "")
+    set(singleValueArgs NAME SOURCE_DIR INSTALL_DIR)
+    set(multiValueArgs INSTALL_FILES INCLUDE)
+    cmake_parse_arguments(arg "${options}" "${singleValueArgs}" "${multiValueArgs}" ${ARGN})
+
+    add_library(${arg_NAME} INTERFACE)
+
+    if (DEFINED arg_INSTALL_DIR AND DEFINED arg_INSTALL_FILES)
+        foreach (install_file ${arg_INSTALL_FILES})
+            if (IS_DIRECTORY ${arg_SOURCE_DIR}/${install_file})
+                list(APPEND commands COMMAND ${CMAKE_COMMAND} -E copy_directory_if_different ${arg_SOURCE_DIR}/${install_file} ${arg_INSTALL_DIR}/${install_file})
+            else ()
+                list(APPEND commands COMMAND ${CMAKE_COMMAND} -E copy_if_different ${arg_SOURCE_DIR}/${install_file} ${arg_INSTALL_DIR}/${install_file})
+            endif ()
+        endforeach ()
+
+        add_custom_target(
+            ${arg_NAME}.Install
+            COMMAND ${commands}
+        )
+        add_dependencies(${arg_NAME} ${arg_NAME}.Install)
+    endif ()
 
-    if (DEFINED PARAMS_INCLUDE)
+    if (DEFINED arg_INCLUDE)
         exp_expand_3rd_path_expression(
-            INPUT ${PARAMS_INCLUDE}
-            OUTPUT R_INCLUDE
-            SOURCE_DIR ${SOURCE_DIR}
+            INPUT ${arg_INCLUDE}
+            OUTPUT r_include
+            SOURCE_DIR ${arg_SOURCE_DIR}
+            INSTALL_DIR ${arg_INSTALL_DIR}
         )
         exp_get_3rd_platform_value(
-            OUTPUT P_INCLUDE
-            INPUT ${R_INCLUDE}
+            OUTPUT p_include
+            INPUT ${r_include}
         )
-        set_target_properties(
-            ${NAME} PROPERTIES
-            3RD_INCLUDE "${P_INCLUDE}"
+        target_include_directories(
+            ${arg_NAME}
+            INTERFACE ${p_include}
         )
-    endif()
+    endif ()
 endfunction()
 
 function(exp_add_3rd_binary_package)
-    cmake_parse_arguments(PARAMS "ARCH" "NAME;PLATFORM" "VERSION;HASH;INCLUDE;LINK;LIB;RUNTIME_DEP" ${ARGN})
-
-    set(NAME "${PARAMS_NAME}")
-    if (${PARAMS_ARCH})
-        set(COUNT_ARCH "ARCH")
-    else()
-        set(COUNT_ARCH "")
-    endif()
-
-    exp_get_3rd_platform_value(
-        ${COUNT_ARCH}
-        OUTPUT VERSION_VALUE
-        INPUT ${PARAMS_VERSION}
-    )
-
-    if (DEFINED PARAMS_PLATFORM)
-        if ((NOT (${PARAMS_PLATFORM} STREQUAL "All")) AND (NOT (${PARAMS_PLATFORM} STREQUAL ${CMAKE_SYSTEM_NAME})))
-            return()
-        endif()
-        set(FULL_NAME "${PARAMS_NAME}-${PARAMS_PLATFORM}-${VERSION_VALUE}")
-    else()
-        set(FULL_NAME "${PARAMS_NAME}-${CMAKE_SYSTEM_NAME}-${VERSION_VALUE}")
-    endif()
+    set(options "")
+    set(singleValueArgs NAME SOURCE_DIR)
+    set(multiValueArgs INCLUDE LINK LIB RUNTIME_DEP)
+    cmake_parse_arguments(arg "${options}" "${singleValueArgs}" "${multiValueArgs}" ${ARGN})
 
-    if (${PARAMS_ARCH})
-        set(FULL_NAME "${PARAMS_NAME}-${CMAKE_SYSTEM_NAME}-${CMAKE_SYSTEM_PROCESSOR}-${VERSION_VALUE}")
-    endif()
-
-    set(URL "${3RD_REPO}/${FULL_NAME}.7z")
-    set(ZIP "${3RD_ZIP_DIR}/${FULL_NAME}.7z")
-    set(SOURCE_DIR "${3RD_SOURCE_DIR}/${FULL_NAME}")
-
-    exp_get_3rd_platform_value(
-        ${COUNT_ARCH}
-        OUTPUT HASH_VALUE
-        INPUT ${PARAMS_HASH}
-    )
-    exp_download_and_extract_3rd_package(
-        URL ${URL}
-        SAVE_AS ${ZIP}
-        EXTRACT_TO ${SOURCE_DIR}
-        HASH ${HASH_VALUE}
-    )
+    add_library(${arg_NAME} INTERFACE)
 
-    add_custom_target(${NAME} ALL)
-    set_target_properties(
-        ${NAME} PROPERTIES
-        3RD_TYPE "Binary"
-    )
-
-    if (DEFINED PARAMS_INCLUDE)
+    if (DEFINED arg_INCLUDE)
         exp_expand_3rd_path_expression(
-            INPUT ${PARAMS_INCLUDE}
-            OUTPUT R_INCLUDE
-            SOURCE_DIR ${SOURCE_DIR}
+            INPUT ${arg_INCLUDE}
+            OUTPUT r_include
+            SOURCE_DIR ${arg_SOURCE_DIR}
         )
         exp_get_3rd_platform_value(
-            ${COUNT_ARCH}
-            INPUT ${R_INCLUDE}
-            OUTPUT P_INCLUDE
+            INPUT ${r_include}
+            OUTPUT p_include
         )
-        set_target_properties(
-            ${NAME} PROPERTIES
-            3RD_INCLUDE "${P_INCLUDE}"
+        target_include_directories(
+            ${arg_NAME}
+            INTERFACE ${p_include}
         )
     endif()
 
-    if (DEFINED PARAMS_LINK)
+    if (DEFINED arg_LINK)
         exp_expand_3rd_path_expression(
-            INPUT ${PARAMS_LINK}
-            OUTPUT R_LINK
-            SOURCE_DIR ${SOURCE_DIR}
+            INPUT ${arg_LINK}
+            OUTPUT r_link
+            SOURCE_DIR ${arg_SOURCE_DIR}
         )
         exp_get_3rd_platform_value(
-            ${COUNT_ARCH}
-            INPUT ${R_LINK}
-            OUTPUT P_LINK
+            INPUT ${r_link}
+            OUTPUT p_link
         )
-        set_target_properties(
-            ${NAME} PROPERTIES
-            3RD_LINK "${P_LINK}"
+        target_link_directories(
+            ${arg_NAME}
+            INTERFACE ${p_link}
         )
     endif()
 
-    if (DEFINED PARAMS_LIB)
+    if (DEFINED arg_LIB)
         exp_expand_3rd_path_expression(
-            INPUT ${PARAMS_LIB}
-            OUTPUT R_LIB
-            SOURCE_DIR ${SOURCE_DIR}
+            INPUT ${arg_LIB}
+            OUTPUT r_lib
+            SOURCE_DIR ${arg_SOURCE_DIR}
         )
         exp_get_3rd_platform_value(
-            ${COUNT_ARCH}
-            OUTPUT P_LIB
-            INPUT ${R_LIB}
+            OUTPUT p_lib
+            INPUT ${r_lib}
         )
-        set_target_properties(
-            ${NAME} PROPERTIES
-            3RD_LIB "${P_LIB}"
+        target_link_libraries(
+            ${arg_NAME}
+            INTERFACE "${p_lib}"
         )
     endif()
 
-    if (DEFINED PARAMS_RUNTIME_DEP)
+    if (DEFINED arg_RUNTIME_DEP)
         exp_expand_3rd_path_expression(
-            INPUT ${PARAMS_RUNTIME_DEP}
-            OUTPUT R_RUNTIME_DEP
-            SOURCE_DIR ${SOURCE_DIR}
+            INPUT ${arg_RUNTIME_DEP}
+            OUTPUT r_runtime_dep
+            SOURCE_DIR ${arg_SOURCE_DIR}
         )
         exp_get_3rd_platform_value(
-            INPUT ${R_RUNTIME_DEP}
-            OUTPUT P_RUNTIME_DEP
+            INPUT ${r_runtime_dep}
+            OUTPUT p_runtime_dep
         )
         set_target_properties(
-            ${NAME} PROPERTIES
-            3RD_RUNTIME_DEP "${P_RUNTIME_DEP}"
+            ${arg_NAME} PROPERTIES
+            RUNTIME_DEP "${p_runtime_dep}"
         )
     endif()
 endfunction()
 
 function(exp_add_3rd_cmake_package)
-    cmake_parse_arguments(PARAMS "" "NAME;PLATFORM;VERSION" "HASH;CMAKE_ARG;INCLUDE;LINK;LIB;RUNTIME_DEP" ${ARGN})
-
-    set(NAME "${PARAMS_NAME}")
-
-    if (DEFINED PARAMS_PLATFORM)
-        if ((NOT (${PARAMS_PLATFORM} STREQUAL "All")) AND (NOT (${PARAMS_PLATFORM} STREQUAL ${CMAKE_SYSTEM_NAME})))
-            return()
-        endif()
-        set(FULL_NAME "${PARAMS_NAME}-${PARAMS_PLATFORM}-${PARAMS_VERSION}")
-    else()
-        set(FULL_NAME "${PARAMS_NAME}-${CMAKE_SYSTEM_NAME}-${PARAMS_VERSION}")
-    endif()
-
-    set(URL "${3RD_REPO}/${FULL_NAME}.7z")
-    set(ZIP "${3RD_ZIP_DIR}/${FULL_NAME}.7z")
-    set(SOURCE_DIR "${3RD_SOURCE_DIR}/${FULL_NAME}")
-    set(BINARY_DIR "${3RD_BINARY_DIR}/${NAME}")
-    set(INSTALL_DIR "${3RD_INSTALL_DIR}/${NAME}/$<CONFIG>")
-
-    exp_get_3rd_platform_value(
-        OUTPUT HASH_VALUE
-        INPUT ${PARAMS_HASH}
-    )
-    exp_download_and_extract_3rd_package(
-        URL ${URL}
-        SAVE_AS ${ZIP}
-        EXTRACT_TO ${SOURCE_DIR}
-        HASH ${HASH_VALUE}
-    )
+    set(options "")
+    set(singleValueArgs NAME SOURCE_DIR BINARY_DIR INSTALL_DIR)
+    set(multiValueArgs CMAKE_ARG INCLUDE LINK LIB RUNTIME_DEP)
+    cmake_parse_arguments(arg "${options}" "${singleValueArgs}" "${multiValueArgs}" ${ARGN})
 
-    if (NOT ${GENERATOR_IS_MULTI_CONFIG})
-        set(CMAKE_BUILD_TYPE_ARGS -DCMAKE_BUILD_TYPE=$<CONFIG>)
+    if (NOT ${generator_is_multi_config})
+        set(build_type_args -DCMAKE_BUILD_TYPE=$<CONFIG>)
     endif ()
 
     ExternalProject_Add(
-        ${NAME}
-        SOURCE_DIR ${SOURCE_DIR}
-        BINARY_DIR ${BINARY_DIR}
-        CMAKE_ARGS ${CMAKE_BUILD_TYPE_ARGS} -DCMAKE_INSTALL_PREFIX=${INSTALL_DIR} ${PARAMS_CMAKE_ARG}
+        ${arg_NAME}.External
+        SOURCE_DIR ${arg_SOURCE_DIR}
+        BINARY_DIR ${arg_BINARY_DIR}
+        CMAKE_ARGS ${build_type_args} -DCMAKE_INSTALL_PREFIX=${arg_INSTALL_DIR} ${arg_CMAKE_ARG}
         BUILD_COMMAND ${CMAKE_COMMAND} --build <BINARY_DIR> --config $<CONFIG> -j 16
         INSTALL_COMMAND ${CMAKE_COMMAND} --install <BINARY_DIR> --config $<CONFIG>
     )
-    set_target_properties(
-        ${NAME} PROPERTIES
-        3RD_TYPE "CMakeProject"
-    )
+    add_library(${arg_NAME} INTERFACE)
+    add_dependencies(${arg_NAME} ${arg_NAME}.External)
 
-    if (DEFINED PARAMS_INCLUDE)
+    if (DEFINED arg_INCLUDE)
         exp_expand_3rd_path_expression(
-            INPUT ${PARAMS_INCLUDE}
-            OUTPUT R_INCLUDE
-            SOURCE_DIR ${SOURCE_DIR}
-            BINARY_DIR ${BINARY_DIR}
-            INSTALL_DIR ${INSTALL_DIR}
+            INPUT ${arg_INCLUDE}
+            OUTPUT r_include
+            SOURCE_DIR ${arg_SOURCE_DIR}
+            BINARY_DIR ${arg_BINARY_DIR}
+            INSTALL_DIR ${arg_INSTALL_DIR}
         )
         exp_get_3rd_platform_value(
-            INPUT ${R_INCLUDE}
-            OUTPUT P_INCLUDE
+            INPUT ${r_include}
+            OUTPUT p_include
         )
-        set_target_properties(
-            ${NAME} PROPERTIES
-            3RD_INCLUDE "${P_INCLUDE}"
+        target_include_directories(
+            ${arg_NAME}
+            INTERFACE ${p_include}
         )
     endif()
 
-    if (DEFINED PARAMS_LINK)
+    if (DEFINED arg_LINK)
         exp_expand_3rd_path_expression(
-            INPUT ${PARAMS_LINK}
-            OUTPUT R_LINK
-            SOURCE_DIR ${SOURCE_DIR}
-            BINARY_DIR ${BINARY_DIR}
-            INSTALL_DIR ${INSTALL_DIR}
+            INPUT ${arg_LINK}
+            OUTPUT r_link
+            SOURCE_DIR ${arg_SOURCE_DIR}
+            BINARY_DIR ${arg_BINARY_DIR}
+            INSTALL_DIR ${arg_INSTALL_DIR}
         )
         exp_get_3rd_platform_value(
-            INPUT ${R_LINK}
-            OUTPUT P_LINK
+            INPUT ${r_link}
+            OUTPUT p_link
         )
-        set_target_properties(
-            ${NAME} PROPERTIES
-            3RD_LINK "${P_LINK}"
+        target_link_directories(
+            ${arg_NAME}
+            INTERFACE ${p_link}
         )
     endif()
 
-    if (DEFINED PARAMS_LIB)
+    if (DEFINED arg_LIB)
         exp_expand_3rd_path_expression(
-            INPUT ${PARAMS_LIB}
-            OUTPUT R_LIB
-            SOURCE_DIR ${SOURCE_DIR}
-            BINARY_DIR ${BINARY_DIR}
-            INSTALL_DIR ${INSTALL_DIR}
+            INPUT ${arg_LIB}
+            OUTPUT r_lib
+            SOURCE_DIR ${arg_SOURCE_DIR}
+            BINARY_DIR ${arg_BINARY_DIR}
+            INSTALL_DIR ${arg_INSTALL_DIR}
         )
         exp_get_3rd_platform_value(
-            INPUT ${R_LIB}
-            OUTPUT P_LIB
+            INPUT ${r_lib}
+            OUTPUT p_lib
         )
-        set_target_properties(
-            ${NAME} PROPERTIES
-            3RD_LIB "${P_LIB}"
+        target_link_libraries(
+            ${arg_NAME}
+            INTERFACE "${p_lib}"
         )
     endif()
 
-    if (DEFINED PARAMS_RUNTIME_DEP)
+    if (DEFINED arg_RUNTIME_DEP)
         exp_expand_3rd_path_expression(
-            INPUT ${PARAMS_RUNTIME_DEP}
-            OUTPUT R_RUNTIME_DEP
-            SOURCE_DIR ${SOURCE_DIR}
-            BINARY_DIR ${BINARY_DIR}
-            INSTALL_DIR ${INSTALL_DIR}
+            INPUT ${arg_RUNTIME_DEP}
+            OUTPUT r_runtime_dep
+            SOURCE_DIR ${arg_SOURCE_DIR}
+            BINARY_DIR ${arg_BINARY_DIR}
+            INSTALL_DIR ${arg_INSTALL_DIR}
         )
         exp_get_3rd_platform_value(
-            INPUT ${R_RUNTIME_DEP}
-            OUTPUT P_RUNTIME_DEP
+            INPUT ${r_runtime_dep}
+            OUTPUT p_runtime_dep
         )
         set_target_properties(
-            ${NAME} PROPERTIES
-            3RD_RUNTIME_DEP "${P_RUNTIME_DEP}"
+            ${arg_NAME} PROPERTIES
+            RUNTIME_DEP "${p_runtime_dep}"
         )
     endif()
 endfunction()
 
 function(exp_add_3rd_alias_package)
-    cmake_parse_arguments(PARAMS "" "NAME;PLATFORM" "LIB" ${ARGN})
-
-    if ((NOT (${PARAMS_PLATFORM} STREQUAL "All")) AND (NOT (${PARAMS_PLATFORM} STREQUAL ${CMAKE_SYSTEM_NAME})))
-        return()
-    endif()
-
-    add_custom_target(${PARAMS_NAME} ALL)
-    set_target_properties(
-        ${PARAMS_NAME} PROPERTIES
-        3RD_TYPE "Alias"
-        3RD_LIB "${PARAMS_LIB}"
-    )
-endfunction()
-
-function(exp_setup_3rd_package)
-    cmake_parse_arguments(PARAMS "" "NAME;PLATFORM;VERSION" "HASH" ${ARGN})
-
-    set(NAME "${PARAMS_NAME}")
-    if (DEFINED PARAMS_PLATFORM)
-        if ((NOT (${PARAMS_PLATFORM} STREQUAL "All")) AND (NOT (${PARAMS_PLATFORM} STREQUAL ${CMAKE_SYSTEM_NAME})))
-            return()
-        endif()
-        set(FULL_NAME "${PARAMS_NAME}-${PARAMS_PLATFORM}-${PARAMS_VERSION}")
-    else()
-        set(FULL_NAME "${PARAMS_NAME}-${CMAKE_SYSTEM_NAME}-${PARAMS_VERSION}")
-    endif()
-    set(URL "${3RD_REPO}/${FULL_NAME}.7z")
-    set(ZIP "${3RD_ZIP_DIR}/${FULL_NAME}.7z")
-    set(SOURCE_DIR "${3RD_SOURCE_DIR}/${FULL_NAME}")
-
-    exp_get_3rd_platform_value(
-        OUTPUT HASH_VALUE
-        INPUT ${PARAMS_HASH}
+    set(options "")
+    set(singleValueArgs NAME)
+    set(multiValueArgs LIB)
+    cmake_parse_arguments(arg "${options}" "${singleValueArgs}" "${multiValueArgs}" ${ARGN})
+
+    add_library(${arg_NAME} INTERFACE)
+    target_link_libraries(
+        ${arg_NAME}
+        INTERFACE "${arg_LIB}"
     )
-    exp_download_and_extract_3rd_package(
-        URL ${URL}
-        SAVE_AS ${ZIP}
-        EXTRACT_TO ${SOURCE_DIR}
-        HASH ${HASH_VALUE}
-    )
-
-    set(${PARAMS_NAME}_SOURCE_DIR ${SOURCE_DIR} CACHE PATH "" FORCE)
 endfunction()
diff --git a/CMakeLists.txt b/CMakeLists.txt
index a6f6e8bb..201559d9 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,8 +1,13 @@
 cmake_minimum_required(VERSION 3.25)
 project(Explosion)
 
-include(ExternalProject)
-include(GenerateExportHeader)
+option(BUILD_EDITOR "Build Explosion editor" ON)
+option(CI "Build in CI" OFF)
+
+set(SUB_PROJECT_NAME "Engine" CACHE STRING "" FORCE)
+set(ENGINE_SUB_PROJECT_NAME "Engine" CACHE STRING "" FORCE)
+
+add_definitions(-DBUILD_EDITOR=$<BOOL:BUILD_EDITOR>)
 
 include(CMake/Common.cmake)
 include(CMake/Target.cmake)
diff --git a/Editor/CMakeLists.txt b/Editor/CMakeLists.txt
index 1b746043..0b51913c 100644
--- a/Editor/CMakeLists.txt
+++ b/Editor/CMakeLists.txt
@@ -9,7 +9,7 @@ qt_standard_project_setup(REQUIRES ${QT_VERSION})
 
 if (${CMAKE_SYSTEM_NAME} STREQUAL "Darwin")
     set(PLATFORM_EXECUTABLE_HINT MACOSX_BUNDLE)
-    set(BUNDLE_INSTALL_DESTINATION BUNDLE DESTINATION ${CMAKE_INSTALL_PREFIX}/Engine/Binaries)
+    set(BUNDLE_INSTALL_DESTINATION BUNDLE DESTINATION ${CMAKE_INSTALL_PREFIX}/${ENGINE_SUB_PROJECT_NAME}/Binaries)
     set(PLATFORM_FRAMEWORK_DIR ${QT_LIB_PREFIX}/lib)
 endif ()
 
@@ -34,11 +34,22 @@ exp_add_mirror_info_source_generation_target(
 
 file(GLOB_RECURSE SOURCES Src/*.cpp)
 qt_add_executable(Editor ${PLATFORM_EXECUTABLE_HINT} ${SOURCES} ${EDITOR_MIRROR_GENERATED_SRC})
+
+get_cmake_property(GENERATOR_IS_MULTI_CONFIG GENERATOR_IS_MULTI_CONFIG)
+if (${GENERATOR_IS_MULTI_CONFIG})
+    set_target_properties(
+        Editor PROPERTIES
+        RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/Dist/$<CONFIG>/${SUB_PROJECT_NAME}/Binaries
+    )
+else ()
+    set_target_properties(
+        Editor PROPERTIES
+        RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/Dist/${SUB_PROJECT_NAME}/Binaries
+    )
+endif ()
+
 target_include_directories(Editor PRIVATE ${EDITOR_INCLUDES})
-exp_link_libs(
-    NAME Editor
-    LIB ${EDITOR_LIBS}
-)
+target_link_libraries(Editor PRIVATE ${EDITOR_LIBS})
 
 if (${CMAKE_SYSTEM_NAME} STREQUAL "Windows")
     set(RHI_DEP_TARGETS RHI-DirectX12 RHI-Vulkan)
@@ -47,12 +58,12 @@ else()
 endif()
 add_dependencies(Editor ${EDITOR_MIRROR_GENERATED_TARGET} ${RHI_DEP_TARGETS})
 
-exp_add_runtime_deps_copy_command(
+exp_process_runtime_dependencies(
     NAME Editor
 )
 install(
     TARGETS Editor
-    RUNTIME DESTINATION ${CMAKE_INSTALL_PREFIX}/Engine/Binaries
+    RUNTIME DESTINATION ${CMAKE_INSTALL_PREFIX}/${ENGINE_SUB_PROJECT_NAME}/Binaries
     ${BUNDLE_INSTALL_DESTINATION}
 )
 
@@ -67,24 +78,24 @@ if (${CMAKE_SYSTEM_NAME} STREQUAL "Windows")
         COMMAND ${CMAKE_COMMAND} -E copy_if_different ${QT_LIB_PREFIX}/resources/qtwebengine_resources.pak ${QT_LIB_PREFIX}/resources/qtwebengine_resources.debug.pak
         COMMAND ${CMAKE_COMMAND} -E copy_if_different ${QT_LIB_PREFIX}/resources/qtwebengine_resources_100p.pak ${QT_LIB_PREFIX}/resources/qtwebengine_resources_100p.debug.pak
         COMMAND ${CMAKE_COMMAND} -E copy_if_different ${QT_LIB_PREFIX}/resources/qtwebengine_resources_200p.pak ${QT_LIB_PREFIX}/resources/qtwebengine_resources_200p.debug.pak
-        COMMAND ${CMAKE_COMMAND} -E copy_if_different ${QT_LIB_PREFIX}/resources/qtwebengine_devtools_resources.pak ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/resources/qtwebengine_devtools_resources.pak
-        COMMAND ${CMAKE_COMMAND} -E copy_if_different ${QT_LIB_PREFIX}/resources/qtwebengine_resources.pak ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/resources/qtwebengine_resources.pak
-        COMMAND ${CMAKE_COMMAND} -E copy_if_different ${QT_LIB_PREFIX}/resources/qtwebengine_resources_100p.pak ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/resources/qtwebengine_resources_100p.pak
-        COMMAND ${CMAKE_COMMAND} -E copy_if_different ${QT_LIB_PREFIX}/resources/qtwebengine_resources_200p.pak ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/resources/qtwebengine_resources_200p.pak
+        COMMAND ${CMAKE_COMMAND} -E copy_if_different ${QT_LIB_PREFIX}/resources/qtwebengine_devtools_resources.pak $<TARGET_PROPERTY:Editor,RUNTIME_OUTPUT_DIRECTORY>/resources/qtwebengine_devtools_resources.pak
+        COMMAND ${CMAKE_COMMAND} -E copy_if_different ${QT_LIB_PREFIX}/resources/qtwebengine_resources.pak $<TARGET_PROPERTY:Editor,RUNTIME_OUTPUT_DIRECTORY>/resources/qtwebengine_resources.pak
+        COMMAND ${CMAKE_COMMAND} -E copy_if_different ${QT_LIB_PREFIX}/resources/qtwebengine_resources_100p.pak $<TARGET_PROPERTY:Editor,RUNTIME_OUTPUT_DIRECTORY>/resources/qtwebengine_resources_100p.pak
+        COMMAND ${CMAKE_COMMAND} -E copy_if_different ${QT_LIB_PREFIX}/resources/qtwebengine_resources_200p.pak $<TARGET_PROPERTY:Editor,RUNTIME_OUTPUT_DIRECTORY>/resources/qtwebengine_resources_200p.pak
         # -- QT 6.9.1 Temporal Fix End
         COMMAND ${QT_WIN_DEPLOY_EXECUTABLE} $<TARGET_FILE:Editor>
     )
     install(
-        CODE "execute_process(COMMAND ${QT_WIN_DEPLOY_EXECUTABLE} ${CMAKE_INSTALL_PREFIX}/Engine/Binaries/$<TARGET_FILE_NAME:Editor>)"
+        CODE "execute_process(COMMAND ${QT_WIN_DEPLOY_EXECUTABLE} ${CMAKE_INSTALL_PREFIX}/${ENGINE_SUB_PROJECT_NAME}/Binaries/$<TARGET_FILE_NAME:Editor>)"
     )
 elseif (${CMAKE_SYSTEM_NAME} STREQUAL "Darwin")
     set(QT_MAC_DEPLOY_EXECUTABLE ${QT_LIB_PREFIX}/bin/macdeployqt)
     add_custom_command(
         TARGET Editor POST_BUILD
-        COMMAND ${QT_MAC_DEPLOY_EXECUTABLE} ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/Editor.app -no-strip
+        COMMAND ${QT_MAC_DEPLOY_EXECUTABLE} $<TARGET_PROPERTY:Editor,RUNTIME_OUTPUT_DIRECTORY>/Editor.app -no-strip
     )
     install(
-        CODE "execute_process(COMMAND ${QT_MAC_DEPLOY_EXECUTABLE} ${CMAKE_INSTALL_PREFIX}/Engine/Binaries/Editor.app -no-strip)"
+        CODE "execute_process(COMMAND ${QT_MAC_DEPLOY_EXECUTABLE} ${CMAKE_INSTALL_PREFIX}/${ENGINE_SUB_PROJECT_NAME}/Binaries/Editor.app -no-strip)"
     )
 endif ()
 
@@ -100,10 +111,7 @@ if (${CMAKE_SYSTEM_NAME} STREQUAL "Darwin")
 endif ()
 
 # ---- begin shaders ---------------------------------------------------------------------------------
-get_engine_shader_resources(
-    NAME Editor
-    OUTPUT EDITOR_RESOURCES
-)
+get_engine_shader_resources(OUTPUT EDITOR_RESOURCES)
 
 file(GLOB_RECURSE SHADERS Shader/*.es*)
 foreach (SHADER ${SHADERS})
@@ -126,43 +134,10 @@ exp_add_resources_copy_command(
 # ---- end shaders -----------------------------------------------------------------------------------
 
 # ---- begin web project -----------------------------------------------------------------------------
-set(NODEJS_HOME ${3RD_SOURCE_DIR}/Nodejs-${CMAKE_SYSTEM_NAME}-${NODEJS_VERSION})
-if (${CMAKE_SYSTEM_NAME} STREQUAL "Windows")
-    set(NODEJS_PATH ${NODEJS_HOME})
-    set(NPM_EXECUTABLE npm.cmd)
-elseif (${CMAKE_SYSTEM_NAME} STREQUAL "Darwin")
-    set(NODEJS_BIN_PATH ${NODEJS_HOME}/bin)
-    set(NODEJS_MODULES_PATH ${NODEJS_HOME}/lib/node_modules)
-    file(REMOVE ${NODEJS_BIN_PATH}/corepack)
-    file(REMOVE ${NODEJS_BIN_PATH}/npm)
-    file(REMOVE ${NODEJS_BIN_PATH}/npx)
-    execute_process(
-        COMMAND ln -s ${NODEJS_MODULES_PATH} ${NODEJS_BIN_PATH}/node_modules
-        RESULT_VARIABLE LINK_RESULT
-        OUTPUT_VARIABLE LINK_OUTPUT
-        ERROR_VARIABLE LINK_ERROR
-    )
-    execute_process(
-        COMMAND ln -s ${NODEJS_MODULES_PATH}/npm/bin/npm ${NODEJS_BIN_PATH}/npm
-        RESULT_VARIABLE LINK_RESULT
-        OUTPUT_VARIABLE LINK_OUTPUT
-        ERROR_VARIABLE LINK_ERROR
-    )
-    execute_process(
-        COMMAND ln -s ${NODEJS_MODULES_PATH}/npm/bin/npx ${NODEJS_BIN_PATH}/npx
-        RESULT_VARIABLE LINK_RESULT
-        OUTPUT_VARIABLE LINK_OUTPUT
-        ERROR_VARIABLE LINK_ERROR
-    )
-    set(NODEJS_PATH "$ENV{PATH}:${NODEJS_BIN_PATH}")
-    set(NPM_EXECUTABLE npm)
-else ()
-    message(FATAL_ERROR "Unsupported OS")
-endif ()
-
+find_program(NPM_EXECUTABLE NAMES npm.cmd npm REQUIRED NO_CACHE)
 message("Perform web project npm install......")
 execute_process(
-    COMMAND ${CMAKE_COMMAND} -E env PATH=${NODEJS_PATH} ${NPM_EXECUTABLE} install --no-fund --registry=https://registry.npmmirror.com
+    COMMAND ${CMAKE_COMMAND} -E env ${NPM_EXECUTABLE} install --no-fund --registry=https://registry.npmmirror.com
     WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/Web
     RESULT_VARIABLE NPM_INSTALL_RESULT
     OUTPUT_VARIABLE NPM_INSTALL_OUTPUT
@@ -176,7 +151,7 @@ endif ()
 
 add_custom_target(
     Editor.Web
-    COMMAND ${CMAKE_COMMAND} -E env PATH=${NODEJS_PATH} ${NPM_EXECUTABLE} run build
+    COMMAND ${CMAKE_COMMAND} -E env ${NPM_EXECUTABLE} run build
     WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/Web
     VERBATIM
 )
@@ -187,6 +162,6 @@ add_custom_command(
     COMMAND ${CMAKE_COMMAND} -E copy_directory_if_different ${CMAKE_CURRENT_SOURCE_DIR}/Web/dist $<TARGET_FILE_DIR:Editor>/Web
 )
 if (NOT ${CMAKE_SYSTEM_NAME} STREQUAL "Darwin")
-    install(CODE "execute_process(COMMAND ${CMAKE_COMMAND} -E copy_directory_if_different ${CMAKE_CURRENT_SOURCE_DIR}/Web/dist ${CMAKE_INSTALL_PREFIX}/Engine/Binaries/Web)")
+    install(CODE "execute_process(COMMAND ${CMAKE_COMMAND} -E copy_directory_if_different ${CMAKE_CURRENT_SOURCE_DIR}/Web/dist ${CMAKE_INSTALL_PREFIX}/${ENGINE_SUB_PROJECT_NAME}/Binaries/Web)")
 endif ()
 # ---- end web project -------------------------------------------------------------------------------
diff --git a/Engine/CMakeLists.txt b/Engine/CMakeLists.txt
index dfc9b66f..cbb69742 100644
--- a/Engine/CMakeLists.txt
+++ b/Engine/CMakeLists.txt
@@ -1,14 +1,17 @@
 add_subdirectory(Source)
 
 function(get_engine_shader_resources)
-    cmake_parse_arguments(PARAMS "" "NAME" "OUTPUT" ${ARGN})
+    set(options "")
+    set(singleValueArgs OUTPUT)
+    set(multiValueArgs "")
+    cmake_parse_arguments(arg "${options}" "${singleValueArgs}" "${multiValueArgs}" ${ARGN})
 
-    file(GLOB_RECURSE ENGINE_SHADERS ${CMAKE_SOURCE_DIR}/Engine/Shader/*.es*)
-    foreach (SHADER ${ENGINE_SHADERS})
-        get_filename_component(SHADER_ABSOLUTE ${SHADER} ABSOLUTE)
-        string(REPLACE ${CMAKE_SOURCE_DIR}/Engine/Shader ../Shader/Engine COPY_DST ${SHADER_ABSOLUTE})
-        list(APPEND RESULT ${SHADER}->${COPY_DST})
+    file(GLOB_RECURSE engine_shaders ${CMAKE_SOURCE_DIR}/${ENGINE_SUB_PROJECT_NAME}/Shader/*.es*)
+    foreach (shader ${engine_shaders})
+        get_filename_component(shader_absolute ${shader} ABSOLUTE)
+        string(REPLACE ${CMAKE_SOURCE_DIR}/${ENGINE_SUB_PROJECT_NAME}/Shader ../Shader/${ENGINE_SUB_PROJECT_NAME} copy_dst ${shader_absolute})
+        list(APPEND result ${shader}->${copy_dst})
     endforeach ()
 
-    set(${PARAMS_OUTPUT} ${RESULT} PARENT_SCOPE)
+    set(${arg_OUTPUT} ${result} PARENT_SCOPE)
 endfunction()
diff --git a/Engine/Source/Common/CMakeLists.txt b/Engine/Source/Common/CMakeLists.txt
index 994ebea7..674e6a9e 100644
--- a/Engine/Source/Common/CMakeLists.txt
+++ b/Engine/Source/Common/CMakeLists.txt
@@ -4,7 +4,7 @@ exp_add_library(
     TYPE STATIC
     SRC ${SOURCES}
     PUBLIC_INC Include
-    LIB debugbreak cityhash taskflow rapidjson
+    PUBLIC_MERGE_LIB rapidjson debugbreak cityhash taskflow
 )
 
 file(GLOB TEST_SOURCES Test/*.cpp)
@@ -12,4 +12,5 @@ exp_add_test(
     NAME Common.Test
     INC Test
     SRC ${TEST_SOURCES}
+    LIB Common
 )
diff --git a/Engine/Source/Core/CMakeLists.txt b/Engine/Source/Core/CMakeLists.txt
index f22b0413..cc02b910 100644
--- a/Engine/Source/Core/CMakeLists.txt
+++ b/Engine/Source/Core/CMakeLists.txt
@@ -4,7 +4,8 @@ exp_add_library(
     TYPE SHARED
     SRC ${SOURCES}
     PUBLIC_INC Include
-    LIB clipp
+    PUBLIC_LIB Common
+    PUBLIC_MERGE_LIB clipp
 )
 
 file(GLOB TEST_SOURCES Test/*.cpp)
diff --git a/Engine/Source/Core/Include/Core/Paths.h b/Engine/Source/Core/Include/Core/Paths.h
index 6f0d4844..be822fa8 100644
--- a/Engine/Source/Core/Include/Core/Paths.h
+++ b/Engine/Source/Core/Include/Core/Paths.h
@@ -41,8 +41,6 @@ namespace Core {
         static Common::Path GamePluginDir();
         static Common::Path GamePluginDir(const std::string& pluginName);
         static Common::Path GamePluginAssetDir(const std::string& pluginName);
-        static Common::Path EngineCMakeSourceDir();
-        static Common::Path EngineCMakeBinaryDir();
 #if BUILD_TEST
         static Common::Path EngineTestDir();
 #endif
diff --git a/Engine/Source/Core/Src/Paths.cpp b/Engine/Source/Core/Src/Paths.cpp
index efefd63a..b494d305 100644
--- a/Engine/Source/Core/Src/Paths.cpp
+++ b/Engine/Source/Core/Src/Paths.cpp
@@ -147,16 +147,6 @@ namespace Core {
         return GamePluginDir() / pluginName / "Asset";
     }
 
-    Common::Path Paths::EngineCMakeSourceDir()
-    {
-        return ENGINE_CMAKE_SOURCE_DIRECTORY;
-    }
-
-    Common::Path Paths::EngineCMakeBinaryDir()
-    {
-        return ENGINE_CMAKE_BINARY_DIRECTORY;
-    }
-
     bool Paths::IsEnginePath(const Common::Path& inPath)
     {
         return Common::StringUtils::RegexMatch(inPath.String(), R"(Engine/.*)");
diff --git a/Engine/Source/Launch/CMakeLists.txt b/Engine/Source/Launch/CMakeLists.txt
index f7e94cf6..857208f4 100644
--- a/Engine/Source/Launch/CMakeLists.txt
+++ b/Engine/Source/Launch/CMakeLists.txt
@@ -3,6 +3,7 @@ exp_add_library(
     NAME Launch
     TYPE STATIC
     SRC ${SOURCES}
-    PRIVATE_INC Include
-    LIB glfw Runtime
+    PUBLIC_INC Include
+    PUBLIC_LIB Runtime
+    PUBLIC_MERGE_LIB glfw
 )
\ No newline at end of file
diff --git a/Engine/Source/Mirror/CMakeLists.txt b/Engine/Source/Mirror/CMakeLists.txt
index 4b7bfa92..240bfb2f 100644
--- a/Engine/Source/Mirror/CMakeLists.txt
+++ b/Engine/Source/Mirror/CMakeLists.txt
@@ -4,6 +4,7 @@ exp_add_library(
     TYPE SHARED
     SRC ${SOURCES}
     PUBLIC_INC Include
+    PUBLIC_LIB Common
 )
 
 file(GLOB TEST_SOURCES Test/*.cpp)
diff --git a/Engine/Source/RHI-DirectX12/CMakeLists.txt b/Engine/Source/RHI-DirectX12/CMakeLists.txt
index 5278e2c3..9b5c29b2 100644
--- a/Engine/Source/RHI-DirectX12/CMakeLists.txt
+++ b/Engine/Source/RHI-DirectX12/CMakeLists.txt
@@ -4,5 +4,6 @@ exp_add_library(
     TYPE SHARED
     SRC ${SOURCES}
     PUBLIC_INC Include
-    LIB RHI DirectXHeaders d3d12 dxgi d3dcompiler
+    PUBLIC_LIB RHI d3d12
+    PUBLIC_MERGE_LIB DirectXHeaders dxgi d3dcompiler
 )
diff --git a/Engine/Source/RHI-Dummy/CMakeLists.txt b/Engine/Source/RHI-Dummy/CMakeLists.txt
index 4527131b..23b290d6 100644
--- a/Engine/Source/RHI-Dummy/CMakeLists.txt
+++ b/Engine/Source/RHI-Dummy/CMakeLists.txt
@@ -4,5 +4,5 @@ exp_add_library(
     TYPE SHARED
     SRC ${SOURCES}
     PUBLIC_INC Include
-    LIB RHI
+    PUBLIC_LIB RHI
 )
diff --git a/Engine/Source/RHI-Vulkan/CMakeLists.txt b/Engine/Source/RHI-Vulkan/CMakeLists.txt
index a76ac464..3dedd5fc 100644
--- a/Engine/Source/RHI-Vulkan/CMakeLists.txt
+++ b/Engine/Source/RHI-Vulkan/CMakeLists.txt
@@ -15,7 +15,8 @@ exp_add_library(
     TYPE SHARED
     SRC ${SOURCES} ${PLATFORM_SOURCES}
     PUBLIC_INC Include
-    LIB RHI VulkanSDK spirv-cross VulkanMemoryAllocator ${PLATFORM_EXT_LIBS}
+    PUBLIC_LIB RHI ${PLATFORM_EXT_LIBS}
+    PUBLIC_MERGE_LIB VulkanSDK spirv-cross VulkanMemoryAllocator
 )
 
 # .mm files can not perform unity build with .cpp files
diff --git a/Engine/Source/RHI/CMakeLists.txt b/Engine/Source/RHI/CMakeLists.txt
index 77c3b61d..55dc88ff 100644
--- a/Engine/Source/RHI/CMakeLists.txt
+++ b/Engine/Source/RHI/CMakeLists.txt
@@ -4,5 +4,5 @@ exp_add_library(
     TYPE STATIC
     SRC ${SOURCES}
     PUBLIC_INC Include
-    LIB Core
+    PUBLIC_LIB Core
 )
diff --git a/Engine/Source/Render/CMakeLists.txt b/Engine/Source/Render/CMakeLists.txt
index b0689bc1..fbd8cd6e 100644
--- a/Engine/Source/Render/CMakeLists.txt
+++ b/Engine/Source/Render/CMakeLists.txt
@@ -1,5 +1,5 @@
 if (${CMAKE_SYSTEM_NAME} STREQUAL "Darwin")
-    set(PLATFORM_LIBS VulkanSDK)
+    set(platform_libs VulkanSDK)
 endif()
 
 file(GLOB SOURCES Src/*.cpp)
@@ -8,7 +8,8 @@ exp_add_library(
     TYPE STATIC
     SRC ${SOURCES}
     PUBLIC_INC Include
-    LIB Core RHI ${PLATFORM_LIBS} dxc spirv-cross
+    PUBLIC_LIB Core RHI
+    PUBLIC_MERGE_LIB dxc spirv-cross ${platform_libs}
 )
 
 file(GLOB SHARED_SOURCES SharedSrc/*.cpp)
@@ -16,7 +17,7 @@ exp_add_library(
     NAME Render
     TYPE SHARED
     SRC ${SHARED_SOURCES}
-    LIB Render.Static
+    PUBLIC_LIB Render.Static
 )
 
 file(GLOB TEST_SOURCES Test/*.cpp)
@@ -24,4 +25,5 @@ exp_add_test(
     NAME Render.Test
     SRC ${TEST_SOURCES}
     LIB RHI Render.Static
+    DEP_TARGET RHI-Dummy
 )
diff --git a/Engine/Source/Runtime/CMakeLists.txt b/Engine/Source/Runtime/CMakeLists.txt
index 5133a8bc..8c102a2f 100644
--- a/Engine/Source/Runtime/CMakeLists.txt
+++ b/Engine/Source/Runtime/CMakeLists.txt
@@ -5,7 +5,8 @@ exp_add_library(
     SRC ${SOURCES}
     PUBLIC_INC Include
     REFLECT Include
-    LIB Core Mirror assimp-lib Render
+    PUBLIC_LIB Core Mirror Render
+    PUBLIC_MERGE_LIB assimp-lib
 )
 
 file(GLOB TEST_SOURCES Test/*.cpp)
@@ -15,4 +16,5 @@ exp_add_test(
     LIB Runtime
     INC Test
     REFLECT Test
+    DEP_TARGET RHI-Dummy
 )
diff --git a/Engine/Source/Test/CMakeLists.txt b/Engine/Source/Test/CMakeLists.txt
index 64d14628..1cf82677 100644
--- a/Engine/Source/Test/CMakeLists.txt
+++ b/Engine/Source/Test/CMakeLists.txt
@@ -3,5 +3,6 @@ exp_add_library(
     TYPE STATIC
     SRC Src/Main.cpp
     PUBLIC_INC Include
-    LIB googletest Core
+    PUBLIC_LIB Core
+    PUBLIC_MERGE_LIB googletest
 )
\ No newline at end of file
diff --git a/README.md b/README.md
index b79c9a76..ec3ab662 100644
--- a/README.md
+++ b/README.md
@@ -16,9 +16,19 @@
 
 Explosion is a cross-platform C++ game engine, based on modern graphics api (aka Vulkan, DirectX 12, Metal), powered by ECS gameplay framework.
 
+# Requirements
+
+You need install those tools to system by yourself and add them to path:
+
+* [Python3](https://www.python.org/downloads/)
+* [CMake](https://cmake.org/download/)
+* [Node.js](https://nodejs.org/en/download)
+
+build steps of engine may use them.
+
 # Build
 
-We use cmake as build tool, the following table contains supported platform, toolchain and generator:
+The following table contains supported platform, toolchain and generator:
 
 <table>
     <tr>
@@ -100,8 +110,6 @@ sudo xcode-select -s /Library/Developer/CommandLineTools
 
 Thanks all those following projects:
 
-* [EnTT](https://github.com/skypjack/entt)
-* [GLM](https://github.com/g-truc/glm)
 * [DirectX-Headers](https://github.com/microsoft/DirectX-Headers)
 * [Vulkan](https://www.vulkan.org/)
 * [DirectXShaderCompiler](https://github.com/microsoft/DirectXShaderCompiler)
@@ -120,7 +128,6 @@ Thanks all those following projects:
 * [Qt6](https://www.qt.io/product/qt6)
 * [rapidjson](https://github.com/Tencent/rapidjson)
 * [cpp-httplib](https://github.com/yhirose/cpp-httplib)
-* [Node.js](https://nodejs.org/zh-cn)
 * [React](https://react.dev)
 * [Vite](https://vite.dev)
 * [HeroUI](https://www.heroui.com)
diff --git a/Sample/CMakeLists.txt b/Sample/CMakeLists.txt
index 69db523c..71d6c2f7 100644
--- a/Sample/CMakeLists.txt
+++ b/Sample/CMakeLists.txt
@@ -1,37 +1,40 @@
 function(add_sample)
-    cmake_parse_arguments(PARAMS "" "NAME" "SRC;INC;SHADER;IMAGE;MODEL" ${ARGN})
+    set(options "")
+    set(singleValueArgs NAME)
+    set(multiValueArgs SRC INC SHADER IMAGE MODEL)
+    cmake_parse_arguments(arg "${options}" "${singleValueArgs}" "${multiValueArgs}" ${ARGN})
 
     if (${CMAKE_SYSTEM_NAME} STREQUAL "Windows")
-        set(PLATFORM_DEP_TARGET RHI-DirectX12 RHI-Vulkan)
+        set(platform_dep_target RHI-DirectX12 RHI-Vulkan)
     else()
-        set(PLATFORM_DEP_TARGET RHI-Vulkan)
+        set(platform_dep_target RHI-Vulkan)
     endif()
 
-    foreach(S ${PARAMS_SHADER})
-        set(path "${CMAKE_CURRENT_SOURCE_DIR}/${S}->../Test/Sample/${S}")
-        list(APPEND PATHS ${path})
+    foreach(s ${arg_SHADER})
+        set(path "${CMAKE_CURRENT_SOURCE_DIR}/${s}->../Test/Sample/${s}")
+        list(APPEND paths ${path})
     endforeach()
 
-    foreach(I ${PARAMS_IMAGE})
-        set(path "${CMAKE_CURRENT_SOURCE_DIR}/${I}->../Test/Sample/${I}")
-        list(APPEND PATHS ${path})
+    foreach(i ${arg_IMAGE})
+        set(path "${CMAKE_CURRENT_SOURCE_DIR}/${i}->../Test/Sample/${i}")
+        list(APPEND paths ${path})
     endforeach()
 
-    foreach(M ${PARAMS_MODEL})
-        set(path "${CMAKE_CURRENT_SOURCE_DIR}/${M}->../Test/Sample/${M}")
-        list(APPEND PATHS ${path})
+    foreach(m ${arg_MODEL})
+        set(path "${CMAKE_CURRENT_SOURCE_DIR}/${m}->../Test/Sample/${m}")
+        list(APPEND paths ${path})
     endforeach()
 
-    list(APPEND PATHS "${CMAKE_SOURCE_DIR}/Engine/Shader/Platform.esh->../Test/Sample/ShaderInclude/Platform.esh")
+    list(APPEND paths "${CMAKE_SOURCE_DIR}/${ENGINE_SUB_PROJECT_NAME}/Shader/Platform.esh->../Test/Sample/ShaderInclude/Platform.esh")
 
     exp_add_executable(
         SAMPLE
-        NAME ${PARAMS_NAME}
-        SRC ${PARAMS_SRC}
-        INC ${PARAMS_INC}
+        NAME ${arg_NAME}
+        SRC ${arg_SRC}
+        INC ${arg_INC}
         LIB Sample-Base
-        DEP_TARGET ${PLATFORM_DEP_TARGET}
-        RES ${PATHS}
+        DEP_TARGET ${platform_dep_target}
+        RES ${paths}
         NOT_INSTALL
     )
 endfunction()
@@ -48,7 +51,8 @@ exp_add_library(
     NAME Sample-Base
     SRC ${SOURCES}
     PUBLIC_INC Base
-    LIB RHI glfw clipp ${PLATFORM_EXT_LIBS} Render.Static stb assimp-lib
+    PUBLIC_LIB RHI ${PLATFORM_EXT_LIBS} Render.Static
+    PUBLIC_MERGE_LIB glfw clipp stb assimp-lib
     NOT_INSTALL
 )
 
diff --git a/Script/start_editor_web_dev_server.py b/Script/start_editor_web_dev_server.py
deleted file mode 100644
index a9e3958e..00000000
--- a/Script/start_editor_web_dev_server.py
+++ /dev/null
@@ -1,61 +0,0 @@
-import os
-import re
-import platform
-import subprocess
-from sys import argv
-from pathlib import Path
-
-def get_nodejs_version(py_path):
-    third_party_cmake = Path(py_path).parent.parent / 'ThirdParty' / 'CMakeLists.txt'
-    if not third_party_cmake.exists():
-        raise RuntimeError('Third-party CMakeLists.txt not found')
-
-    nodejs_version_line = None
-    with open(third_party_cmake) as cmake_file:
-        for line in cmake_file.readlines():
-            if 'NODEJS_VERSION' in line:
-                nodejs_version_line = line
-                break
-
-    if nodejs_version_line is None:
-        raise RuntimeError('NODEJS_VERSION define in third_party CMakeLists.txt not found')
-
-    found = re.findall(r'.*NODEJS_VERSION \"(.+?)\".*', nodejs_version_line)
-    return found[0]
-
-
-def get_nodejs_root(py_path, nodejs_version):
-    nodejs_root = Path(py_path).parent.parent / 'ThirdParty' / 'Lib' / '{}-{}-{}'.format('Nodejs', platform.system(), nodejs_version)
-    if not nodejs_root.exists():
-        raise RuntimeError('Root of node.js not found')
-    return nodejs_root
-
-
-def get_web_project_root(py_path):
-    web_project_root = Path(py_path).parent.parent / 'Editor' / 'Web'
-    return web_project_root
-
-
-def start_dev_server(nodejs_root, web_project_root):
-    env = os.environ.copy()
-    if platform.system() == 'Windows':
-        env['PATH'] = '{};{}'.format(env['PATH'], os.path.normpath(nodejs_root))
-        subprocess.run(['npm', 'run', 'dev'], shell=True, encoding='utf-8', env=env, cwd=web_project_root)
-    elif platform.system() == 'Darwin':
-        nodejs_bin = Path(nodejs_root) / 'bin'
-        env['PATH'] = '{}:{}'.format(env['PATH'], nodejs_bin)
-        subprocess.run(['npm', 'run', 'dev'], encoding='utf-8', env=env, cwd=web_project_root)
-    else:
-        raise RuntimeError('Unsupported OS')
-
-
-if __name__ == '__main__':
-    py_path = os.path.realpath(__file__)
-    print('Python File Path:', py_path)
-    nodejs_version = get_nodejs_version(py_path)
-    print('Node.js version:', nodejs_version)
-    nodejs_root = get_nodejs_root(py_path, nodejs_version)
-    print('Node.js root:', nodejs_root)
-    web_project_root = get_web_project_root(py_path)
-    print('Web project root:', web_project_root)
-    start_dev_server(nodejs_root, web_project_root)
diff --git a/ThirdParty/CMakeLists.txt b/ThirdParty/CMakeLists.txt
index 0d43e733..f06dc4cc 100644
--- a/ThirdParty/CMakeLists.txt
+++ b/ThirdParty/CMakeLists.txt
@@ -1,267 +1,430 @@
+set(3RD_REPO "http://1.13.181.171" CACHE STRING "" FORCE)
+set(3RD_DIR ${CMAKE_SOURCE_DIR}/ThirdParty CACHE PATH "" FORCE)
+set(3RD_ZIP_DIR ${3RD_DIR}/Zip CACHE PATH "" FORCE)
+set(3RD_SOURCE_DIR ${3RD_DIR}/Lib CACHE PATH "" FORCE)
+set(3RD_BINARY_DIR ${CMAKE_BINARY_DIR}/ThirdPartyBuild CACHE PATH "" FORCE)
+set(3RD_INSTALL_DIR ${CMAKE_BINARY_DIR}/ThirdPartyInstall CACHE PATH "" FORCE)
+
+function(download_and_setup_3rd_package)
+    set(options "")
+    set(singleValueArgs NAME)
+    set(multiValueArgs PLATFORM VERSION HASH)
+    cmake_parse_arguments(arg "${options}" "${singleValueArgs}" "${multiValueArgs}" ${ARGN})
+
+    exp_get_3rd_platform_value(
+        OUTPUT version_value
+        INPUT ${arg_VERSION}
+    )
+
+    set(cur_platform All ${CMAKE_SYSTEM_NAME})
+    foreach (platform ${cur_platform})
+        if (${platform} IN_LIST arg_PLATFORM)
+            set(full_name "${arg_NAME}-${platform}-${version_value}")
+        endif ()
+    endforeach ()
+
+    if (NOT DEFINED full_name)
+        set(${arg_NAME}_READY FALSE PARENT_SCOPE)
+        return()
+    endif ()
+
+    set(source_dir ${3RD_SOURCE_DIR}/${full_name})
+    exp_download_and_extract_3rd_package(
+        URL ${3RD_REPO}/${full_name}.7z
+        SAVE_AS ${3RD_ZIP_DIR}/${full_name}.7z
+        EXTRACT_TO ${source_dir}
+        HASH ${arg_HASH}
+    )
+    set(${arg_NAME}_READY TRUE PARENT_SCOPE)
+    set(${arg_NAME}_SOURCE_DIR ${source_dir} PARENT_SCOPE)
+    set(${arg_NAME}_BINARY_DIR ${3RD_BINARY_DIR}/${arg_NAME} PARENT_SCOPE)
+    set(${arg_NAME}_INSTALL_DIR ${3RD_INSTALL_DIR}/${arg_NAME}/$<CONFIG> PARENT_SCOPE)
+endfunction()
+
+function(should_setup_3rd_package)
+    set(options "")
+    set(singleValueArgs NAME)
+    set(multiValueArgs PLATFORM)
+    cmake_parse_arguments(arg "${options}" "${singleValueArgs}" "${multiValueArgs}" ${ARGN})
+
+    set(cur_platform All ${CMAKE_SYSTEM_NAME})
+    foreach (platform ${cur_platform})
+        if (${platform} IN_LIST arg_PLATFORM)
+            set(${arg_NAME}_READY TRUE PARENT_SCOPE)
+            return()
+        endif ()
+    endforeach ()
+
+    set(${arg_NAME}_READY FALSE PARENT_SCOPE)
+endfunction()
+
 # DirectX 12 Headers
-exp_add_3rd_header_only_package(
+download_and_setup_3rd_package(
     NAME DirectXHeaders
     PLATFORM Windows
     VERSION 1.4.9
     HASH 0313c5145214dda2a183af97212878482aafbb2433d4f0ec0a2efeec7cc9ef2a
-    INCLUDE $<SOURCE_DIR>/include
 )
+if (${DirectXHeaders_READY})
+    exp_add_3rd_header_only_package(
+        NAME DirectXHeaders
+        SOURCE_DIR ${DirectXHeaders_SOURCE_DIR}
+        INCLUDE $<SOURCE_DIR>/include
+    )
+endif ()
 
 # VulkanSDK
 set(VULKAN_SDK_VERSION 1.3.296.0)
-exp_add_3rd_binary_package(
+download_and_setup_3rd_package(
     NAME VulkanSDK
+    PLATFORM Windows Darwin
     VERSION ${VULKAN_SDK_VERSION}
     HASH
         Windows 27b8344a5b1333222d55c9c107914dba1cc9beb788b207e087c27dc7b8762816
         Darwin a792aaad3937a694a4cb853d2fbb3fa7025ba3754bedd52799e687a4c254129c
-    INCLUDE
-        Windows $<SOURCE_DIR>/Include
-        Darwin $<SOURCE_DIR>/macOS/include
-    LINK
-        Windows $<SOURCE_DIR>/Lib
-        Darwin $<SOURCE_DIR>/macOS/lib
-    LIB
-        Windows vulkan-1
-        Darwin vulkan.1
 )
-if (NOT ${CI})
-    #see https://github.com/KhronosGroup/Vulkan-Loader/blob/main/docs/LoaderLayerInterface.md
-    if (${CMAKE_SYSTEM_NAME} STREQUAL "Windows")
-        execute_process(COMMAND reg query "HKEY_LOCAL_MACHINE\\SOFTWARE\\Khronos\\Vulkan\\ExplicitLayers" OUTPUT_VARIABLE LAYERS)
-        string(REGEX MATCH "VkLayer_khronos_validation\.json" MATCH_RESULT ${LAYERS})
-        list(LENGTH MATCH_RESULT MATCH_RESULT_LENGTH)
-
-        if (${MATCH_RESULT_LENGTH} GREATER 0)
-            message("Used registered validation layer in HKEY_LOCAL_MACHINE\\SOFTWARE\\Khronos\\Vulkan\\ExplicitLayers")
-        else ()
-            set(VALIDATION_LAYER_JSON ${3RD_SOURCE_DIR}/VulkanSDK-Windows-${VULKAN_SDK_VERSION}/Bin/VkLayer_khronos_validation.json)
-            message("Found no registered validation layer, will register ${VALIDATION_LAYER_JSON} to reg HKEY_LOCAL_MACHINE\\SOFTWARE\\Khronos\\Vulkan\\ExplicitLayers")
-            string(REPLACE "/" "\\" VALIDATION_LAYER_JSON ${VALIDATION_LAYER_JSON})
-            execute_process(COMMAND PowerShell -Command "Start-Process reg -ArgumentList 'add HKEY_LOCAL_MACHINE\\SOFTWARE\\Khronos\\Vulkan\\ExplicitLayers /v ${VALIDATION_LAYER_JSON} /t REG_DWORD /d 0' -Verb RunAs")
-        endif ()
-    else (${CMAKE_SYSTEM_NAME} STREQUAL "Darwin")
-        # new version of vulkaninfo application use volk to perform dynamic loading, which need libvulkan.dylib in working directory or system,
-        # so if vulkaninfo print initialized failed, we need copy vulkan dynamic lib to working directory
-        set(PLATFORM_VULKAN_SDK_DIR ${CMAKE_SOURCE_DIR}/ThirdParty/Lib/VulkanSDK-Darwin-${VULKAN_SDK_VERSION}/macOS)
-        execute_process(COMMAND ${PLATFORM_VULKAN_SDK_DIR}/bin/vulkaninfo WORKING_DIRECTORY ${PLATFORM_VULKAN_SDK_DIR}/bin OUTPUT_VARIABLE VULKAN_INFO ERROR_VARIABLE VULKAN_INFO)
-        string(REGEX MATCH "Failed to initialize" MATCH_RESULT ${VULKAN_INFO})
-        list(LENGTH MATCH_RESULT MATCH_RESULT_LENGTH)
-        if (${MATCH_RESULT_LENGTH} GREATER 0)
-            set(SRC_FILE ${PLATFORM_VULKAN_SDK_DIR}/lib/libvulkan.dylib)
-            set(DST_FILE ${PLATFORM_VULKAN_SDK_DIR}/bin/libvulkan.dylib)
-            message("vulkaninfo initialized failed, perform vulkan dynamic library copy: ${SRC_FILE} -> ${DST_FILE}")
-            file(COPY_FILE ${SRC_FILE} ${DST_FILE} ONLY_IF_DIFFERENT)
-        else ()
-            message("vulkaninfo test success")
-        endif ()
+if (${VulkanSDK_READY})
+    exp_add_3rd_binary_package(
+        NAME VulkanSDK
+        SOURCE_DIR ${VulkanSDK_SOURCE_DIR}
+        INCLUDE
+            Windows $<SOURCE_DIR>/Include
+            Darwin $<SOURCE_DIR>/macOS/include
+        LINK
+            Windows $<SOURCE_DIR>/Lib
+            Darwin $<SOURCE_DIR>/macOS/lib
+        LIB
+            Windows vulkan-1
+            Darwin vulkan.1
+    )
+    if (NOT ${CI})
+        #see https://github.com/KhronosGroup/Vulkan-Loader/blob/main/docs/LoaderLayerInterface.md
+        if (${CMAKE_SYSTEM_NAME} STREQUAL "Windows")
+            execute_process(COMMAND reg query "HKEY_LOCAL_MACHINE\\SOFTWARE\\Khronos\\Vulkan\\ExplicitLayers" OUTPUT_VARIABLE LAYERS)
+            string(REGEX MATCH "VkLayer_khronos_validation\.json" MATCH_RESULT ${LAYERS})
+            list(LENGTH MATCH_RESULT MATCH_RESULT_LENGTH)
 
-        # check drivers
-        execute_process(COMMAND ${PLATFORM_VULKAN_SDK_DIR}/bin/vulkaninfo WORKING_DIRECTORY ${PLATFORM_VULKAN_SDK_DIR}/bin OUTPUT_VARIABLE VULKAN_INFO ERROR_VARIABLE VULKAN_INFO)
-        string(REGEX MATCH "ERROR_INCOMPATIBLE_DRIVER" MATCH_RESULT ${VULKAN_INFO})
-        list(LENGTH MATCH_RESULT MATCH_RESULT_LENGTH)
-        if (${MATCH_RESULT_LENGTH} GREATER 0)
-            message("there is no drivers found for vulkan, copy and rewrite driver files to ~/.config/vulkan/icd.d")
-            get_filename_component(DRIVERS_DIR_ABSOLUTE ~/.config/vulkan/icd.d ABSOLUTE)
-            if (NOT EXISTS ${DRIVERS_DIR_ABSOLUTE})
-                file(MAKE_DIRECTORY ${DRIVERS_DIR_ABSOLUTE})
+            if (${MATCH_RESULT_LENGTH} GREATER 0)
+                message("Used registered validation layer in HKEY_LOCAL_MACHINE\\SOFTWARE\\Khronos\\Vulkan\\ExplicitLayers")
+            else ()
+                set(VALIDATION_LAYER_JSON ${3RD_SOURCE_DIR}/VulkanSDK-Windows-${VULKAN_SDK_VERSION}/Bin/VkLayer_khronos_validation.json)
+                message("Found no registered validation layer, will register ${VALIDATION_LAYER_JSON} to reg HKEY_LOCAL_MACHINE\\SOFTWARE\\Khronos\\Vulkan\\ExplicitLayers")
+                string(REPLACE "/" "\\" VALIDATION_LAYER_JSON ${VALIDATION_LAYER_JSON})
+                execute_process(COMMAND PowerShell -Command "Start-Process reg -ArgumentList 'add HKEY_LOCAL_MACHINE\\SOFTWARE\\Khronos\\Vulkan\\ExplicitLayers /v ${VALIDATION_LAYER_JSON} /t REG_DWORD /d 0' -Verb RunAs")
+            endif ()
+        else (${CMAKE_SYSTEM_NAME} STREQUAL "Darwin")
+            # new version of vulkaninfo application use volk to perform dynamic loading, which need libvulkan.dylib in working directory or system,
+            # so if vulkaninfo print initialized failed, we need copy vulkan dynamic lib to working directory
+            set(PLATFORM_VULKAN_SDK_DIR ${CMAKE_SOURCE_DIR}/ThirdParty/Lib/VulkanSDK-Darwin-${VULKAN_SDK_VERSION}/macOS)
+            execute_process(COMMAND ${PLATFORM_VULKAN_SDK_DIR}/bin/vulkaninfo WORKING_DIRECTORY ${PLATFORM_VULKAN_SDK_DIR}/bin OUTPUT_VARIABLE VULKAN_INFO ERROR_VARIABLE VULKAN_INFO)
+            string(REGEX MATCH "Failed to initialize" MATCH_RESULT ${VULKAN_INFO})
+            list(LENGTH MATCH_RESULT MATCH_RESULT_LENGTH)
+            if (${MATCH_RESULT_LENGTH} GREATER 0)
+                set(SRC_FILE ${PLATFORM_VULKAN_SDK_DIR}/lib/libvulkan.dylib)
+                set(DST_FILE ${PLATFORM_VULKAN_SDK_DIR}/bin/libvulkan.dylib)
+                message("vulkaninfo initialized failed, perform vulkan dynamic library copy: ${SRC_FILE} -> ${DST_FILE}")
+                file(COPY_FILE ${SRC_FILE} ${DST_FILE} ONLY_IF_DIFFERENT)
+            else ()
+                message("vulkaninfo test success")
             endif ()
 
-            file(GLOB DRIVER_FILES ${PLATFORM_VULKAN_SDK_DIR}/share/vulkan/icd.d/*.json)
-            foreach (DRIVER_FILE ${DRIVER_FILES})
-                file(READ ${DRIVER_FILE} FILE_CONTENT)
-                string(REPLACE "../../../lib" "${PLATFORM_VULKAN_SDK_DIR}/lib" FILE_CONTENT ${FILE_CONTENT})
-                get_filename_component(FILE_NAME ${DRIVER_FILE} NAME)
-                file(WRITE ${DRIVERS_DIR_ABSOLUTE}/${FILE_NAME} ${FILE_CONTENT})
-            endforeach ()
-        else ()
-            message("found vulkan drivers installed in system, will use it")
-        endif ()
+            # check drivers
+            execute_process(COMMAND ${PLATFORM_VULKAN_SDK_DIR}/bin/vulkaninfo WORKING_DIRECTORY ${PLATFORM_VULKAN_SDK_DIR}/bin OUTPUT_VARIABLE VULKAN_INFO ERROR_VARIABLE VULKAN_INFO)
+            string(REGEX MATCH "ERROR_INCOMPATIBLE_DRIVER" MATCH_RESULT ${VULKAN_INFO})
+            list(LENGTH MATCH_RESULT MATCH_RESULT_LENGTH)
+            if (${MATCH_RESULT_LENGTH} GREATER 0)
+                message("there is no drivers found for vulkan, copy and rewrite driver files to ~/.config/vulkan/icd.d")
+                get_filename_component(DRIVERS_DIR_ABSOLUTE ~/.config/vulkan/icd.d ABSOLUTE)
+                if (NOT EXISTS ${DRIVERS_DIR_ABSOLUTE})
+                    file(MAKE_DIRECTORY ${DRIVERS_DIR_ABSOLUTE})
+                endif ()
 
-        # check layers
-        execute_process(COMMAND ${PLATFORM_VULKAN_SDK_DIR}/bin/vulkaninfo WORKING_DIRECTORY ${PLATFORM_VULKAN_SDK_DIR}/bin OUTPUT_VARIABLE VULKAN_INFO ERROR_VARIABLE VULKAN_INFO)
-        string(REGEX MATCH "Layers:\n=======" MATCH_RESULT ${VULKAN_INFO})
-        list(LENGTH MATCH_RESULT MATCH_RESULT_LENGTH)
-        if (${MATCH_RESULT_LENGTH} GREATER 0)
-            message("there is no layers found for vulkan, copy and rewrite layer files to ~/.config/vulkan/explicit_layer.d")
-            get_filename_component(LAYERS_DIR_ABSOLUTE ~/.config/vulkan/explicit_layer.d ABSOLUTE)
-            if (NOT EXISTS ${LAYERS_DIR_ABSOLUTE})
-                file(MAKE_DIRECTORY ${LAYERS_DIR_ABSOLUTE})
+                file(GLOB DRIVER_FILES ${PLATFORM_VULKAN_SDK_DIR}/share/vulkan/icd.d/*.json)
+                foreach (DRIVER_FILE ${DRIVER_FILES})
+                    file(READ ${DRIVER_FILE} FILE_CONTENT)
+                    string(REPLACE "../../../lib" "${PLATFORM_VULKAN_SDK_DIR}/lib" FILE_CONTENT ${FILE_CONTENT})
+                    get_filename_component(FILE_NAME ${DRIVER_FILE} NAME)
+                    file(WRITE ${DRIVERS_DIR_ABSOLUTE}/${FILE_NAME} ${FILE_CONTENT})
+                endforeach ()
+            else ()
+                message("found vulkan drivers installed in system, will use it")
             endif ()
 
-            file(GLOB LAYER_FILES ${PLATFORM_VULKAN_SDK_DIR}/share/vulkan/explicit_layer.d/*.json)
-            foreach (LAYER_FILE ${LAYER_FILES})
-                file(READ ${LAYER_FILE} FILE_CONTENT)
-                string(REPLACE "../../../lib" "${PLATFORM_VULKAN_SDK_DIR}/lib" FILE_CONTENT ${FILE_CONTENT})
-                get_filename_component(FILE_NAME ${LAYER_FILE} NAME)
-                file(WRITE ${LAYERS_DIR_ABSOLUTE}/${FILE_NAME} ${FILE_CONTENT})
-            endforeach ()
-        else ()
-            message("found vulkan layers installed in system, will use it")
+            # check layers
+            execute_process(COMMAND ${PLATFORM_VULKAN_SDK_DIR}/bin/vulkaninfo WORKING_DIRECTORY ${PLATFORM_VULKAN_SDK_DIR}/bin OUTPUT_VARIABLE VULKAN_INFO ERROR_VARIABLE VULKAN_INFO)
+            string(REGEX MATCH "Layers:\n=======" MATCH_RESULT ${VULKAN_INFO})
+            list(LENGTH MATCH_RESULT MATCH_RESULT_LENGTH)
+            if (${MATCH_RESULT_LENGTH} GREATER 0)
+                message("there is no layers found for vulkan, copy and rewrite layer files to ~/.config/vulkan/explicit_layer.d")
+                get_filename_component(LAYERS_DIR_ABSOLUTE ~/.config/vulkan/explicit_layer.d ABSOLUTE)
+                if (NOT EXISTS ${LAYERS_DIR_ABSOLUTE})
+                    file(MAKE_DIRECTORY ${LAYERS_DIR_ABSOLUTE})
+                endif ()
+
+                file(GLOB LAYER_FILES ${PLATFORM_VULKAN_SDK_DIR}/share/vulkan/explicit_layer.d/*.json)
+                foreach (LAYER_FILE ${LAYER_FILES})
+                    file(READ ${LAYER_FILE} FILE_CONTENT)
+                    string(REPLACE "../../../lib" "${PLATFORM_VULKAN_SDK_DIR}/lib" FILE_CONTENT ${FILE_CONTENT})
+                    get_filename_component(FILE_NAME ${LAYER_FILE} NAME)
+                    file(WRITE ${LAYERS_DIR_ABSOLUTE}/${FILE_NAME} ${FILE_CONTENT})
+                endforeach ()
+            else ()
+                message("found vulkan layers installed in system, will use it")
+            endif ()
         endif ()
     endif ()
 endif ()
 
 # DXC
 # Windows uses standalone package, macOS uses lib in VulkanSDK
-exp_add_3rd_binary_package(
-    NAME dxc
-    PLATFORM Windows
-    VERSION 1.6.2112
-    HASH b8d8e5cd03234e477bc3fe5d4258652a7fb61916141660408ee4c54a4f1eb939
-    INCLUDE $<SOURCE_DIR>/inc
-    LINK $<SOURCE_DIR>/lib/x64
-    LIB dxcompiler
-    RUNTIME_DEP
-        Windows $<SOURCE_DIR>/bin/x64/dxcompiler.dll $<SOURCE_DIR>/bin/x64/dxil.dll
-)
-exp_add_3rd_alias_package(
-    NAME dxc
-    PLATFORM Darwin
-    LIB dxcompiler
-)
+if (${CMAKE_SYSTEM_NAME} STREQUAL "Windows")
+    download_and_setup_3rd_package(
+        NAME dxc
+        PLATFORM Windows
+        VERSION 1.6.2112
+        HASH b8d8e5cd03234e477bc3fe5d4258652a7fb61916141660408ee4c54a4f1eb939
+    )
+    if (${dxc_READY})
+        exp_add_3rd_binary_package(
+            NAME dxc
+            SOURCE_DIR ${dxc_SOURCE_DIR}
+            INCLUDE $<SOURCE_DIR>/inc
+            LINK $<SOURCE_DIR>/lib/x64
+            LIB dxcompiler
+            RUNTIME_DEP
+                Windows $<SOURCE_DIR>/bin/x64/dxcompiler.dll $<SOURCE_DIR>/bin/x64/dxil.dll
+        )
+    endif ()
+elseif (${CMAKE_SYSTEM_NAME} STREQUAL "Darwin")
+    should_setup_3rd_package(
+        NAME dxc
+        PLATFORM Darwin
+    )
+    if (${dxc_READY})
+        exp_add_3rd_alias_package(
+            NAME dxc
+            LIB dxcompiler
+        )
+    endif ()
+endif ()
 
 # GLFW
-exp_add_3rd_cmake_package(
+download_and_setup_3rd_package(
     NAME glfw
     PLATFORM All
     VERSION 4.0
     HASH 2483836f085d616acaa48f6dc8efec5239f6a538c3a25d13fdc6a7afb2cce1d4
-    CMAKE_ARG -DUSE_MSVC_RUNTIME_LIBRARY_DLL=OFF -DGLFW_BUILD_EXAMPLES=OFF -DGLFW_BUILD_TESTS=OFF -DGLFW_BUILD_DOCS=OFF
-    INCLUDE $<INSTALL_DIR>/include
-    LINK $<INSTALL_DIR>/lib
-    LIB glfw3
 )
+if (${glfw_READY})
+    exp_add_3rd_cmake_package(
+        NAME glfw
+        SOURCE_DIR ${glfw_SOURCE_DIR}
+        BINARY_DIR ${glfw_BINARY_DIR}
+        INSTALL_DIR ${glfw_INSTALL_DIR}
+        CMAKE_ARG -DUSE_MSVC_RUNTIME_LIBRARY_DLL=OFF -DGLFW_BUILD_EXAMPLES=OFF -DGLFW_BUILD_TESTS=OFF -DGLFW_BUILD_DOCS=OFF
+        INCLUDE $<INSTALL_DIR>/include
+        LINK $<INSTALL_DIR>/lib
+        LIB glfw3
+    )
+endif ()
 
 # clipp
-exp_add_3rd_header_only_package(
+download_and_setup_3rd_package(
     NAME clipp
     PLATFORM All
     VERSION forked-f7cffbd61a7b64189d6573e8c3848d094c35168a
     HASH 59db8b8586381652b5e0ae629a9d32e0e443428bc4d94af091b9525a62d167fb
-    INCLUDE $<SOURCE_DIR>/include
 )
+if (${clipp_READY})
+    exp_add_3rd_header_only_package(
+        NAME clipp
+        SOURCE_DIR ${clipp_SOURCE_DIR}
+        INCLUDE $<SOURCE_DIR>/include
+    )
+endif ()
 
 # DebugBreak
-exp_add_3rd_header_only_package(
+download_and_setup_3rd_package(
     NAME debugbreak
     PLATFORM All
     VERSION 1.0
     HASH 16e35a330a9927181ed2e03a92efe6d39670b33c1bdf61ab88d29673ef3a89d4
-    INCLUDE $<SOURCE_DIR>
 )
+if (${debugbreak_READY})
+    exp_add_3rd_header_only_package(
+        NAME debugbreak
+        SOURCE_DIR ${debugbreak_SOURCE_DIR}
+        INSTALL_DIR ${debugbreak_INSTALL_DIR}
+        INSTALL_FILES debugbreak.h
+        INCLUDE $<INSTALL_DIR>
+    )
+endif ()
 
 # LLVM-Clang
-exp_add_3rd_binary_package(
+download_and_setup_3rd_package(
     NAME llvm-clang
-    ARCH
-    VERSION
-        Windows-AMD64 19.1.6
-        Darwin-arm64 19.1.6
+    PLATFORM Windows Darwin
+    VERSION 19.1.6
     HASH
-        Windows-AMD64 f68b922c87a99b22c0b53a5cbd55db86bd3870c16c4e9060efaecfb9ce49e726
-        Darwin-arm64 08fdf1b6208823acadc23027fda1f12e5171101ec05fa526b545088be31fe19d
-    INCLUDE $<SOURCE_DIR>/include
-    LINK $<SOURCE_DIR>/lib
-    LIB
-        Windows-AMD64 libclang
-        Darwin-arm64 clang
-    RUNTIME_DEP
-        Windows $<SOURCE_DIR>/bin/libclang.dll
-        Darwin $<SOURCE_DIR>/lib/libclang.dylib
+        Windows f68b922c87a99b22c0b53a5cbd55db86bd3870c16c4e9060efaecfb9ce49e726
+        Darwin 08fdf1b6208823acadc23027fda1f12e5171101ec05fa526b545088be31fe19d
 )
+if (${llvm-clang_READY})
+    exp_add_3rd_binary_package(
+        NAME llvm-clang
+        SOURCE_DIR ${llvm-clang_SOURCE_DIR}
+        INCLUDE $<SOURCE_DIR>/include
+        LINK $<SOURCE_DIR>/lib
+        LIB
+            Windows libclang
+            Darwin clang
+        RUNTIME_DEP
+            Windows $<SOURCE_DIR>/bin/libclang.dll
+            Darwin $<SOURCE_DIR>/lib/libclang.dylib
+    )
+endif ()
 
 # Google Test
-exp_add_3rd_cmake_package(
+download_and_setup_3rd_package(
     NAME googletest
     PLATFORM All
     VERSION 1.11.0
     HASH bb1146f051868868b96fa83069d4d05f0e05216b5c3f697859c591fd73b93a86
-    CMAKE_ARG -DCMAKE_POLICY_VERSION_MINIMUM=3.5 -Dgtest_force_shared_crt=ON
-    INCLUDE $<INSTALL_DIR>/include
-    LINK $<INSTALL_DIR>/lib
-    LIB gtest$<IF:$<CONFIG:Debug>,d,> gmock$<IF:$<CONFIG:Debug>,d,>
 )
+if (${googletest_READY})
+    exp_add_3rd_cmake_package(
+        NAME googletest
+        SOURCE_DIR ${googletest_SOURCE_DIR}
+        BINARY_DIR ${googletest_BINARY_DIR}
+        INSTALL_DIR ${googletest_INSTALL_DIR}
+        CMAKE_ARG -DCMAKE_POLICY_VERSION_MINIMUM=3.5 -Dgtest_force_shared_crt=ON
+        INCLUDE $<INSTALL_DIR>/include
+        LINK $<INSTALL_DIR>/lib
+        LIB gtest$<IF:$<CONFIG:Debug>,d,> gmock$<IF:$<CONFIG:Debug>,d,>
+    )
+endif ()
 
 # TaskFlow
-exp_add_3rd_header_only_package(
+download_and_setup_3rd_package(
     NAME taskflow
     PLATFORM All
     VERSION 3.4.0
     HASH 774e23d5b6be17a5482d70ffd76ba4ccfd8821c86b7c3f0bcdcd5d96bc264041
-    INCLUDE $<SOURCE_DIR>
 )
+if (${taskflow_READY})
+    exp_add_3rd_header_only_package(
+        NAME taskflow
+        SOURCE_DIR ${taskflow_SOURCE_DIR}
+        INSTALL_DIR ${taskflow_INSTALL_DIR}
+        INSTALL_FILES taskflow
+        INCLUDE $<INSTALL_DIR>
+    )
+endif ()
 
 # CityHash
-exp_add_3rd_cmake_package(
+download_and_setup_3rd_package(
     NAME cityhash
     PLATFORM All
     VERSION forked-2f248cfbf88d0895d069258e4971b5f2fc3a9f19
     HASH 5acf325794585578915dfa7fbac9eb2ca436ffe4831b05c40d1f286b68d7ac20
-    INCLUDE $<INSTALL_DIR>/include
-    LINK $<INSTALL_DIR>/lib
-    LIB city
 )
+if (${cityhash_READY})
+    exp_add_3rd_cmake_package(
+        NAME cityhash
+        SOURCE_DIR ${cityhash_SOURCE_DIR}
+        BINARY_DIR ${cityhash_BINARY_DIR}
+        INSTALL_DIR ${cityhash_INSTALL_DIR}
+        INCLUDE $<INSTALL_DIR>/include
+        LINK $<INSTALL_DIR>/lib
+        LIB city
+    )
+endif ()
 
 # stb-image
-exp_add_3rd_header_only_package(
+download_and_setup_3rd_package(
     NAME stb
     PLATFORM All
     VERSION master-8b5f1f37b5b75829fc72d38e7b5d4bcbf8a26d55
     HASH 32e28f89a85b3bb6749e8caed9eb5226f7f5956769005d2b5a41d48d9481d90c
-    INCLUDE $<SOURCE_DIR>
 )
+if (${stb_READY})
+    exp_add_3rd_header_only_package(
+        NAME stb
+        SOURCE_DIR ${stb_SOURCE_DIR}
+        INCLUDE $<SOURCE_DIR>
+    )
+endif ()
 
 # spirv-cross
-exp_add_3rd_cmake_package(
+download_and_setup_3rd_package(
     NAME spirv-cross
     PLATFORM All
     VERSION 1.3.243.0
     HASH 2b09e3cf9357156e8a4f1bd7cde3771184f652ec3b632993495748112a7f4665
-    CMAKE_ARG -DCMAKE_POLICY_VERSION_MINIMUM=3.5 -DSPIRV_CROSS_CLI=OFF -DSPIRV_CROSS_ENABLE_C_API=OFF -DSPIRV_CROSS_ENABLE_TESTS=OFF
-    INCLUDE $<INSTALL_DIR>/include
-    LINK $<INSTALL_DIR>/lib
-    LIB spirv-cross-core$<IF:$<AND:$<CONFIG:Debug>,$<PLATFORM_ID:Windows>>,d,>
-        spirv-cross-msl$<IF:$<AND:$<CONFIG:Debug>,$<PLATFORM_ID:Windows>>,d,>
-        spirv-cross-glsl$<IF:$<AND:$<CONFIG:Debug>,$<PLATFORM_ID:Windows>>,d,>
 )
+if (${spirv-cross_READY})
+    exp_add_3rd_cmake_package(
+        NAME spirv-cross
+        SOURCE_DIR ${spirv-cross_SOURCE_DIR}
+        BINARY_DIR ${spirv-cross_BINARY_DIR}
+        INSTALL_DIR ${spirv-cross_INSTALL_DIR}
+        CMAKE_ARG -DCMAKE_POLICY_VERSION_MINIMUM=3.5 -DSPIRV_CROSS_CLI=OFF -DSPIRV_CROSS_ENABLE_C_API=OFF -DSPIRV_CROSS_ENABLE_TESTS=OFF
+        INCLUDE $<INSTALL_DIR>/include
+        LINK $<INSTALL_DIR>/lib
+        LIB spirv-cross-core$<IF:$<AND:$<CONFIG:Debug>,$<PLATFORM_ID:Windows>>,d,>
+            spirv-cross-msl$<IF:$<AND:$<CONFIG:Debug>,$<PLATFORM_ID:Windows>>,d,>
+            spirv-cross-glsl$<IF:$<AND:$<CONFIG:Debug>,$<PLATFORM_ID:Windows>>,d,>
+    )
+endif ()
 
 # assimp
-exp_add_3rd_cmake_package(
+download_and_setup_3rd_package(
     NAME assimp-lib
     PLATFORM All
     VERSION 5.2.5
     HASH ae55d305a607ad8cc598c306663796dbf6e50a3cb0b952fe1ea3175f0f342ad9
-    CMAKE_ARG -DASSIMP_BUILD_TESTS=OFF -DASSIMP_WARNINGS_AS_ERRORS=OFF -DASSIMP_INSTALL_PDB=OFF
-    INCLUDE $<INSTALL_DIR>/include
-    LINK $<INSTALL_DIR>/lib
-    LIB
-        Windows "assimp-vc${MSVC_TOOLSET_VERSION}-mt$<IF:$<CONFIG:Debug>,d,>"
-        Darwin "assimp$<IF:$<CONFIG:Debug>,d,>"
-    RUNTIME_DEP
-        Windows "$<INSTALL_DIR>/bin/assimp-vc${MSVC_TOOLSET_VERSION}-mt$<IF:$<CONFIG:Debug>,d,>.dll"
 )
+if (${assimp-lib_READY})
+    exp_add_3rd_cmake_package(
+        NAME assimp-lib
+        SOURCE_DIR ${assimp-lib_SOURCE_DIR}
+        BINARY_DIR ${assimp-lib_BINARY_DIR}
+        INSTALL_DIR ${assimp-lib_INSTALL_DIR}
+        CMAKE_ARG -DASSIMP_BUILD_TESTS=OFF -DASSIMP_WARNINGS_AS_ERRORS=OFF -DASSIMP_INSTALL_PDB=OFF
+        INCLUDE $<INSTALL_DIR>/include
+        LINK $<INSTALL_DIR>/lib
+        LIB
+            Windows "assimp-vc${MSVC_TOOLSET_VERSION}-mt$<IF:$<CONFIG:Debug>,d,>"
+            Darwin "assimp$<IF:$<CONFIG:Debug>,d,>"
+        RUNTIME_DEP
+            Windows "$<INSTALL_DIR>/bin/assimp-vc${MSVC_TOOLSET_VERSION}-mt$<IF:$<CONFIG:Debug>,d,>.dll"
+    )
+endif ()
 
 # vma
-exp_add_3rd_header_only_package(
+download_and_setup_3rd_package(
     NAME VulkanMemoryAllocator
     PLATFORM All
     VERSION 3.0.1
     HASH a63a5e32c21fa9e839580d0c8727c6dead9da01730a8f0d10717cd784bc632de
-    INCLUDE $<SOURCE_DIR>/include
 )
+if (${VulkanMemoryAllocator_READY})
+    exp_add_3rd_header_only_package(
+        NAME VulkanMemoryAllocator
+        SOURCE_DIR ${VulkanMemoryAllocator_SOURCE_DIR}
+        INCLUDE $<SOURCE_DIR>/include
+    )
+endif ()
 
 # Qt6
 set(QT_VERSION "6.9.1" CACHE STRING "" FORCE)
-exp_setup_3rd_package(
+download_and_setup_3rd_package(
     NAME Qt
+    PLATFORM Windows Darwin
     VERSION ${QT_VERSION}
     HASH
         Windows 9cd849f79784fda5436b0da3b7625b4530a77b93c5e80ea9a2d8a95060c174b6
         Darwin 3938c6156228fcf63c33029067bd4b6dd333ed284e069198b85d92de3d9b3e13
-    PREFIX
-        Windows $<SOURCE_DIR>/6.9.1/msvc2019_64
-        Darwin $<SOURCE_DIR>/6.9.1/macos
 )
 if (${CMAKE_SYSTEM_NAME} STREQUAL "Windows")
     set(QT_LIB_PREFIX ${Qt_SOURCE_DIR}/${QT_VERSION}/msvc2022_64 CACHE PATH "" FORCE)
@@ -275,30 +438,31 @@ elseif (${CMAKE_SYSTEM_NAME} STREQUAL "Darwin")
 endif ()
 
 # rapidjson
-exp_add_3rd_header_only_package(
+download_and_setup_3rd_package(
     NAME rapidjson
     PLATFORM All
     VERSION d621dc9
     HASH 696f6ca1ecca9d13170c0a47eda66a3015bcf02a7b4bdd23f574ea302eb4bf3e
-    INCLUDE $<SOURCE_DIR>/include
-)
-
-# Node.js
-set(NODEJS_VERSION "22.18.0" CACHE STRING "" FORCE)
-exp_add_3rd_binary_package(
-    NAME Nodejs
-    VERSION ${NODEJS_VERSION}
-    HASH
-        Windows 6c5fc993dacd58f2e3b145b06599e8a3aa1b0d0c2dea48b0a09af31c5c6ebe23
-        Darwin 0f6e16a5564c29aa45d2354ac66ea5f66232a7c45baa45fec372edb00e491c16
 )
+if (${rapidjson_READY})
+    exp_add_3rd_header_only_package(
+        NAME rapidjson
+        SOURCE_DIR ${rapidjson_SOURCE_DIR}
+        INCLUDE $<SOURCE_DIR>/include
+    )
+endif ()
 
 # cpp-httplib
-set(CPP_HTTP_LIB_VERSION "0.24.0")
-exp_add_3rd_header_only_package(
+download_and_setup_3rd_package(
     NAME cpp-httplib
     PLATFORM All
     VERSION 0.24.0
     HASH a0320b106f4a8f945ec2556e62fffab05b068f2ddfff99c6a367b2e16c14bde1
-    INCLUDE $<SOURCE_DIR>
 )
+if (${cpp-httplib_READY})
+    exp_add_3rd_header_only_package(
+        NAME cpp-httplib
+        SOURCE_DIR ${cpp-httplib_SOURCE_DIR}
+        INCLUDE $<SOURCE_DIR>
+    )
+endif ()
diff --git a/Tool/MirrorTool/CMakeLists.txt b/Tool/MirrorTool/CMakeLists.txt
index fcd5a331..af9a5f68 100644
--- a/Tool/MirrorTool/CMakeLists.txt
+++ b/Tool/MirrorTool/CMakeLists.txt
@@ -3,7 +3,9 @@ exp_add_library(
     NAME MirrorTool.Static
     SRC ${SOURCES}
     PUBLIC_INC Include
-    LIB clipp llvm-clang Mirror
+    PUBLIC_LIB Mirror
+    PUBLIC_MERGE_LIB llvm-clang clipp
+    NOT_INSTALL
 )
 
 file(GLOB EXE_SOURCES ExeSrc/*.cpp)
@@ -21,5 +23,5 @@ exp_add_test(
     LIB MirrorTool.Static
     RES
         ${CMAKE_CURRENT_SOURCE_DIR}/Test/MirrorToolInput.h->../Test/Resource/Mirror/MirrorToolInput.h
-        ${CMAKE_SOURCE_DIR}/Engine/Source/Mirror/Include/Mirror/Meta.h->../Test/Resource/Mirror/Mirror/Meta.h
+        ${CMAKE_SOURCE_DIR}/${ENGINE_SUB_PROJECT_NAME}/Source/Mirror/Include/Mirror/Meta.h->../Test/Resource/Mirror/Mirror/Meta.h
 )