diff --git a/CMakeLists.txt b/CMakeLists.txt
index 014aa9c185..1275ca711b 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -22,7 +22,7 @@ project(
 if(NOT CMAKE_BUILD_TYPE)
     set(CMAKE_BUILD_TYPE Debug)
 endif()
-    
+
 message(VERBOSE "*")
 message(VERBOSE "* ${PROJECT_NAME} v${PROJECT_VERSION} (${CMAKE_BUILD_TYPE})")
 message(VERBOSE "* Copyright (c) 2017-2025 Michele Caini <michele.caini@gmail.com>")
@@ -37,6 +37,13 @@ list(INSERT CMAKE_MODULE_PATH 0 ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules)
 option(ENTT_USE_LIBCPP "Use libc++ by adding -stdlib=libc++ flag if available." OFF)
 option(ENTT_USE_SANITIZER "Enable sanitizers by adding -fsanitize=address -fno-omit-frame-pointer -fsanitize=undefined flags if available." OFF)
 option(ENTT_USE_CLANG_TIDY "Enable static analysis with clang-tidy" OFF)
+option(ENTT_MODULE "Build EnTT module instead of a regular header-only library." OFF)
+
+set(ENTT_USER_CONFIG "" CACHE FILEPATH "Path to a file containing user EnTT configuration.")
+
+if (NOT ENTT_MODULE AND ENTT_USER_CONFIG)
+    message(FATAL_ERROR "The option ENTT_USER_CONFIG can be used only when ENTT_MODULE is ON")
+endif()
 
 if(ENTT_USE_LIBCPP)
     if(NOT WIN32)
@@ -83,25 +90,56 @@ endif()
 
 include(GNUInstallDirs)
 
-add_library(EnTT INTERFACE)
+if (ENTT_MODULE)
+    if (CMAKE_VERSION VERSION_LESS 3.28)
+        message(FATAL_ERROR "CMake >= 3.28 is required to build EnTT as a module")
+    endif()
+
+    set(ENTT_LIBRARY_TYPE STATIC)
+    set(ENTT_SCOPE PUBLIC)
+    set(ENTT_CXX_STD cxx_std_20)
+else()
+    set(ENTT_LIBRARY_TYPE INTERFACE)
+    set(ENTT_SCOPE INTERFACE)
+    set(ENTT_CXX_STD cxx_std_17)
+endif()
+
+add_library(EnTT ${ENTT_LIBRARY_TYPE})
 add_library(EnTT::EnTT ALIAS EnTT)
 
 target_include_directories(
     EnTT
-    INTERFACE
+    ${ENTT_SCOPE}
         $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src>
         $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
 )
 
-target_compile_features(EnTT INTERFACE cxx_std_17)
+target_compile_features(EnTT ${ENTT_SCOPE} ${ENTT_CXX_STD})
 
 if(ENTT_HAS_LIBCPP)
-    target_compile_options(EnTT BEFORE INTERFACE -stdlib=libc++)
+    target_compile_options(EnTT BEFORE ${ENTT_SCOPE} -stdlib=libc++)
+    if(ENTT_MODULE)
+        target_link_options(EnTT ${ENTT_SCOPE} -stdlib=libc++)
+    endif()
 endif()
 
 if(ENTT_HAS_SANITIZER)
-    target_compile_options(EnTT INTERFACE $<$<CONFIG:Debug>:-fsanitize=address -fno-omit-frame-pointer -fsanitize=undefined>)
-    target_link_libraries(EnTT INTERFACE $<$<CONFIG:Debug>:-fsanitize=address -fno-omit-frame-pointer -fsanitize=undefined>)
+    target_compile_options(EnTT ${ENTT_SCOPE} $<$<CONFIG:Debug>:-fsanitize=address -fno-omit-frame-pointer -fsanitize=undefined>)
+    target_link_options(EnTT ${ENTT_SCOPE} $<$<CONFIG:Debug>:-fsanitize=address -fno-omit-frame-pointer -fsanitize=undefined>)
+endif()
+
+if (ENTT_USER_CONFIG)
+    target_compile_definitions(EnTT ${ENTT_SCOPE} ENTT_USER_CONFIG=\"${ENTT_USER_CONFIG}\")
+endif()
+
+if (ENTT_MODULE)
+    target_sources(EnTT
+        PUBLIC
+            FILE_SET cxx_modules TYPE CXX_MODULES
+            BASE_DIRS ${EnTT_SOURCE_DIR}/src/entt
+            FILES
+                ${EnTT_SOURCE_DIR}/src/entt/entt.ixx
+    )
 endif()
 
 if(ENTT_CLANG_TIDY_EXECUTABLE)
@@ -268,11 +306,22 @@ if(ENTT_INSTALL)
 
     include(CMakePackageConfigHelpers)
 
-    install(
-        TARGETS EnTT
-        EXPORT EnTTTargets
-        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-    )
+    if(ENTT_MODULE)
+        install(
+            TARGETS EnTT
+            EXPORT EnTTTargets
+            ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+            INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+            FILE_SET cxx_modules DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/entt
+        )
+    else()
+        install(
+            TARGETS EnTT
+            EXPORT EnTTTargets
+            ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+            INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+        )
+    endif()
 
     write_basic_package_version_file(
         EnTTConfigVersion.cmake
@@ -286,18 +335,37 @@ if(ENTT_INSTALL)
         INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/EnTT/cmake
     )
 
-    export(
-        EXPORT EnTTTargets
-        FILE ${CMAKE_CURRENT_BINARY_DIR}/EnTTTargets.cmake
-        NAMESPACE EnTT::
-    )
+    if(ENTT_MODULE)
+        export(
+            TARGETS EnTT
+            FILE "${CMAKE_CURRENT_BINARY_DIR}/EnTTTargets.cmake"
+            NAMESPACE EnTT::
+            CXX_MODULES_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/cxx-modules"
+        )
+    else()
+        export(
+            TARGETS EnTT
+            FILE "${CMAKE_CURRENT_BINARY_DIR}/EnTTTargets.cmake"
+            NAMESPACE EnTT::
+        )
+    endif()
 
-    install(
-        EXPORT EnTTTargets
-        FILE EnTTTargets.cmake
-        DESTINATION ${CMAKE_INSTALL_LIBDIR}/EnTT/cmake
-        NAMESPACE EnTT::
-    )
+    if(ENTT_MODULE)
+        install(
+            EXPORT EnTTTargets
+            FILE EnTTTargets.cmake
+            DESTINATION ${CMAKE_INSTALL_LIBDIR}/EnTT/cmake
+            NAMESPACE EnTT::
+            CXX_MODULES_DIRECTORY ${CMAKE_INSTALL_LIBDIR}/EnTT/cmake/cxx-modules
+        )
+    else()
+        install(
+            EXPORT EnTTTargets
+            FILE EnTTTargets.cmake
+            DESTINATION ${CMAKE_INSTALL_LIBDIR}/EnTT/cmake
+            NAMESPACE EnTT::
+        )
+    endif()
 
     install(
         FILES
@@ -330,12 +398,12 @@ if(ENTT_BUILD_TESTING OR ENTT_BUILD_TESTBED)
     # Tests and tesetbed do not work together because SDL gets confused with EnTT tests
     if(ENTT_BUILD_TESTING)
         option(ENTT_FIND_GTEST_PACKAGE "Enable finding gtest package." OFF)
-    
+
         option(ENTT_BUILD_BENCHMARK "Build benchmark." OFF)
         option(ENTT_BUILD_EXAMPLE "Build examples." OFF)
         option(ENTT_BUILD_LIB "Build lib tests." OFF)
         option(ENTT_BUILD_SNAPSHOT "Build snapshot test with Cereal." OFF)
-    
+
         include(CTest)
         enable_testing()
         add_subdirectory(test)
diff --git a/README.md b/README.md
index c28837d09a..0ca3eff023 100644
--- a/README.md
+++ b/README.md
@@ -111,6 +111,8 @@ mind.
 
 ```cpp
 #include <entt/entt.hpp>
+// or import entt; 
+// See Integration > CMake for details.
 
 struct position {
     float x;
@@ -246,6 +248,9 @@ using `EnTT` as a submodule without conflicting with user logic.<br/>
 It is therefore necessary to set the option to true to take advantage of the
 installation logic provided by this library.
 
+Note that `EnTT` can be consumed also as a C++ module. To enable module support, 
+the `ENTT_MODULE` option has to be set to `ON` in `CMake`.
+
 ## Natvis support
 
 When using `CMake`, just enable the option `ENTT_INCLUDE_NATVIS` and enjoy
diff --git a/src/entt/config/module.h b/src/entt/config/module.h
new file mode 100644
index 0000000000..4e80a12838
--- /dev/null
+++ b/src/entt/config/module.h
@@ -0,0 +1,16 @@
+#ifndef ENTT_MODULE_H
+#define ENTT_MODULE_H
+
+#ifndef ENTT_MODULE_EXPORT
+#    define ENTT_MODULE_EXPORT
+#endif // ENTT_MODULE_EXPORT
+
+#ifndef ENTT_MODULE_EXPORT_BEGIN
+#    define ENTT_MODULE_EXPORT_BEGIN
+#endif // ENTT_MODULE_EXPORT_BEGIN
+
+#ifndef ENTT_MODULE_EXPORT_END
+#    define ENTT_MODULE_EXPORT_END
+#endif // ENTT_MODULE_EXPORT_END
+
+#endif // ENTT_MODULE_H
diff --git a/src/entt/container/dense_map.hpp b/src/entt/container/dense_map.hpp
index 034940737b..23b2c03210 100644
--- a/src/entt/container/dense_map.hpp
+++ b/src/entt/container/dense_map.hpp
@@ -1,23 +1,27 @@
 #ifndef ENTT_CONTAINER_DENSE_MAP_HPP
 #define ENTT_CONTAINER_DENSE_MAP_HPP
 
-#include <cmath>
-#include <cstddef>
-#include <functional>
-#include <iterator>
-#include <limits>
-#include <memory>
-#include <tuple>
-#include <type_traits>
-#include <utility>
-#include <vector>
-#include "../config/config.h"
-#include "../core/bit.hpp"
-#include "../core/compressed_pair.hpp"
-#include "../core/iterator.hpp"
-#include "../core/memory.hpp"
-#include "../core/type_traits.hpp"
-#include "fwd.hpp"
+#include "../config/module.h"
+
+#ifndef ENTT_MODULE
+#   include <cmath>
+#   include <cstddef>
+#   include <functional>
+#   include <iterator>
+#   include <limits>
+#   include <memory>
+#   include <tuple>
+#   include <type_traits>
+#   include <utility>
+#   include <vector>
+#   include "../config/config.h"
+#   include "../core/bit.hpp"
+#   include "../core/compressed_pair.hpp"
+#   include "../core/iterator.hpp"
+#   include "../core/memory.hpp"
+#   include "../core/type_traits.hpp"
+#   include "fwd.hpp"
+#endif // ENTT_MODULE
 
 namespace entt {
 
@@ -55,7 +59,7 @@ struct dense_map_node final {
 template<typename It>
 class dense_map_iterator final {
     template<typename>
-    friend class dense_map_iterator;
+    friend class internal::dense_map_iterator;
 
     using first_type = decltype(std::as_const(std::declval<It>()->element.first));
     using second_type = decltype((std::declval<It>()->element.second));
@@ -139,6 +143,8 @@ class dense_map_iterator final {
     It it;
 };
 
+ENTT_MODULE_EXPORT_BEGIN
+
 template<typename Lhs, typename Rhs>
 [[nodiscard]] constexpr std::ptrdiff_t operator-(const dense_map_iterator<Lhs> &lhs, const dense_map_iterator<Rhs> &rhs) noexcept {
     return lhs.it - rhs.it;
@@ -174,10 +180,12 @@ template<typename Lhs, typename Rhs>
     return !(lhs < rhs);
 }
 
+ENTT_MODULE_EXPORT_END
+
 template<typename It>
 class dense_map_local_iterator final {
     template<typename>
-    friend class dense_map_local_iterator;
+    friend class internal::dense_map_local_iterator;
 
     using first_type = decltype(std::as_const(std::declval<It>()->element.first));
     using second_type = decltype((std::declval<It>()->element.second));
@@ -230,6 +238,8 @@ class dense_map_local_iterator final {
     std::size_t offset;
 };
 
+ENTT_MODULE_EXPORT_BEGIN
+
 template<typename Lhs, typename Rhs>
 [[nodiscard]] constexpr bool operator==(const dense_map_local_iterator<Lhs> &lhs, const dense_map_local_iterator<Rhs> &rhs) noexcept {
     return lhs.index() == rhs.index();
@@ -240,9 +250,13 @@ template<typename Lhs, typename Rhs>
     return !(lhs == rhs);
 }
 
+ENTT_MODULE_EXPORT_END
+
 } // namespace internal
 /*! @endcond */
 
+ENTT_MODULE_EXPORT_BEGIN
+
 /**
  * @brief Associative container for key-value pairs with unique keys.
  *
@@ -1055,6 +1069,8 @@ class dense_map {
     float threshold{default_threshold};
 };
 
+ENTT_MODULE_EXPORT_END
+
 } // namespace entt
 
 /*! @cond TURN_OFF_DOXYGEN */
diff --git a/src/entt/container/dense_set.hpp b/src/entt/container/dense_set.hpp
index ecbe8d7d13..011f5f67a5 100644
--- a/src/entt/container/dense_set.hpp
+++ b/src/entt/container/dense_set.hpp
@@ -1,21 +1,25 @@
 #ifndef ENTT_CONTAINER_DENSE_SET_HPP
 #define ENTT_CONTAINER_DENSE_SET_HPP
 
-#include <cmath>
-#include <cstddef>
-#include <functional>
-#include <iterator>
-#include <limits>
-#include <memory>
-#include <tuple>
-#include <type_traits>
-#include <utility>
-#include <vector>
-#include "../config/config.h"
-#include "../core/bit.hpp"
-#include "../core/compressed_pair.hpp"
-#include "../core/type_traits.hpp"
-#include "fwd.hpp"
+#include "../config/module.h"
+
+#ifndef ENTT_MODULE
+#   include <cmath>
+#   include <cstddef>
+#   include <functional>
+#   include <iterator>
+#   include <limits>
+#   include <memory>
+#   include <tuple>
+#   include <type_traits>
+#   include <utility>
+#   include <vector>
+#   include "../config/config.h"
+#   include "../core/bit.hpp"
+#   include "../core/compressed_pair.hpp"
+#   include "../core/type_traits.hpp"
+#   include "fwd.hpp"
+#endif // ENTT_MODULE
 
 namespace entt {
 
@@ -25,7 +29,7 @@ namespace internal {
 template<typename It>
 class dense_set_iterator final {
     template<typename>
-    friend class dense_set_iterator;
+    friend class internal::dense_set_iterator;
 
 public:
     using value_type = typename It::value_type::second_type;
@@ -105,6 +109,8 @@ class dense_set_iterator final {
     It it;
 };
 
+ENTT_MODULE_EXPORT_BEGIN
+
 template<typename Lhs, typename Rhs>
 [[nodiscard]] constexpr std::ptrdiff_t operator-(const dense_set_iterator<Lhs> &lhs, const dense_set_iterator<Rhs> &rhs) noexcept {
     return lhs.it - rhs.it;
@@ -140,10 +146,12 @@ template<typename Lhs, typename Rhs>
     return !(lhs < rhs);
 }
 
+ENTT_MODULE_EXPORT_END
+
 template<typename It>
 class dense_set_local_iterator final {
     template<typename>
-    friend class dense_set_local_iterator;
+    friend class internal::dense_set_local_iterator;
 
 public:
     using value_type = typename It::value_type::second_type;
@@ -191,6 +199,8 @@ class dense_set_local_iterator final {
     std::size_t offset;
 };
 
+ENTT_MODULE_EXPORT_BEGIN
+
 template<typename Lhs, typename Rhs>
 [[nodiscard]] constexpr bool operator==(const dense_set_local_iterator<Lhs> &lhs, const dense_set_local_iterator<Rhs> &rhs) noexcept {
     return lhs.index() == rhs.index();
@@ -201,9 +211,13 @@ template<typename Lhs, typename Rhs>
     return !(lhs == rhs);
 }
 
+ENTT_MODULE_EXPORT_END
+
 } // namespace internal
 /*! @endcond */
 
+ENTT_MODULE_EXPORT_BEGIN
+
 /**
  * @brief Associative container for unique objects of a given type.
  *
@@ -924,6 +938,8 @@ class dense_set {
     float threshold{default_threshold};
 };
 
+ENTT_MODULE_EXPORT_END
+
 } // namespace entt
 
 #endif
diff --git a/src/entt/container/fwd.hpp b/src/entt/container/fwd.hpp
index 46222634c2..75e1c5dcf7 100644
--- a/src/entt/container/fwd.hpp
+++ b/src/entt/container/fwd.hpp
@@ -1,12 +1,16 @@
 #ifndef ENTT_CONTAINER_FWD_HPP
 #define ENTT_CONTAINER_FWD_HPP
 
-#include <functional>
-#include <memory>
-#include <utility>
-#include <vector>
+#include "../config/module.h"
 
-namespace entt {
+#ifndef ENTT_MODULE
+#   include <functional>
+#   include <memory>
+#   include <utility>
+#   include <vector>
+#endif // ENTT_MODULE
+
+ENTT_MODULE_EXPORT namespace entt {
 
 template<
     typename Key,
diff --git a/src/entt/container/table.hpp b/src/entt/container/table.hpp
index 34dcd64d90..622d1a1027 100644
--- a/src/entt/container/table.hpp
+++ b/src/entt/container/table.hpp
@@ -1,14 +1,18 @@
 #ifndef ENTT_CONTAINER_TABLE_HPP
 #define ENTT_CONTAINER_TABLE_HPP
 
-#include <cstddef>
-#include <iterator>
-#include <tuple>
-#include <type_traits>
-#include <utility>
-#include "../config/config.h"
-#include "../core/iterator.hpp"
-#include "fwd.hpp"
+#include "../config/module.h"
+
+#ifndef ENTT_MODULE
+#   include <cstddef>
+#   include <iterator>
+#   include <tuple>
+#   include <type_traits>
+#   include <utility>
+#   include "../config/config.h"
+#   include "../core/iterator.hpp"
+#   include "fwd.hpp"
+#endif // ENTT_MODULE
 
 namespace entt {
 
@@ -18,7 +22,7 @@ namespace internal {
 template<typename... It>
 class table_iterator {
     template<typename...>
-    friend class table_iterator;
+    friend class internal::table_iterator;
 
 public:
     using value_type = decltype(std::forward_as_tuple(*std::declval<It>()...));
@@ -98,6 +102,8 @@ class table_iterator {
     std::tuple<It...> it;
 };
 
+ENTT_MODULE_EXPORT_BEGIN
+
 template<typename... Lhs, typename... Rhs>
 [[nodiscard]] constexpr std::ptrdiff_t operator-(const table_iterator<Lhs...> &lhs, const table_iterator<Rhs...> &rhs) noexcept {
     return std::get<0>(lhs.it) - std::get<0>(rhs.it);
@@ -133,9 +139,13 @@ template<typename... Lhs, typename... Rhs>
     return !(lhs < rhs);
 }
 
+ENTT_MODULE_EXPORT_END
+
 } // namespace internal
 /*! @endcond */
 
+ENTT_MODULE_EXPORT_BEGIN
+
 /**
  * @brief Basic table implementation.
  *
@@ -447,10 +457,12 @@ class basic_table {
     container_type payload;
 };
 
+ENTT_MODULE_EXPORT_END
+
 } // namespace entt
 
 /*! @cond TURN_OFF_DOXYGEN */
-namespace std {
+ENTT_MODULE_EXPORT namespace std {
 
 template<typename... Container, typename Allocator>
 struct uses_allocator<entt::basic_table<Container...>, Allocator>
diff --git a/src/entt/core/algorithm.hpp b/src/entt/core/algorithm.hpp
index b1c2758780..e75f41e3e0 100644
--- a/src/entt/core/algorithm.hpp
+++ b/src/entt/core/algorithm.hpp
@@ -1,14 +1,18 @@
 #ifndef ENTT_CORE_ALGORITHM_HPP
 #define ENTT_CORE_ALGORITHM_HPP
 
-#include <algorithm>
-#include <functional>
-#include <iterator>
-#include <utility>
-#include <vector>
-#include "utility.hpp"
-
-namespace entt {
+#include "../config/module.h"
+
+#ifndef ENTT_MODULE
+#   include <algorithm>
+#   include <functional>
+#   include <iterator>
+#   include <utility>
+#   include <vector>
+#   include "utility.hpp"
+#endif // ENTT_MODULE
+
+ENTT_MODULE_EXPORT namespace entt {
 
 /**
  * @brief Function object to wrap `std::sort` in a class type.
diff --git a/src/entt/core/any.hpp b/src/entt/core/any.hpp
index 200da0dada..8a14b6eaac 100644
--- a/src/entt/core/any.hpp
+++ b/src/entt/core/any.hpp
@@ -1,15 +1,19 @@
 #ifndef ENTT_CORE_ANY_HPP
 #define ENTT_CORE_ANY_HPP
 
-#include <cstddef>
-#include <memory>
-#include <type_traits>
-#include <utility>
-#include "../config/config.h"
-#include "../core/utility.hpp"
-#include "fwd.hpp"
-#include "type_info.hpp"
-#include "type_traits.hpp"
+#include "../config/module.h"
+
+#ifndef ENTT_MODULE
+#   include <cstddef>
+#   include <memory>
+#   include <type_traits>
+#   include <utility>
+#   include "../config/config.h"
+#   include "../core/utility.hpp"
+#   include "fwd.hpp"
+#   include "type_info.hpp"
+#   include "type_traits.hpp"
+#endif // ENTT_MODULE
 
 namespace entt {
 
@@ -29,6 +33,8 @@ enum class any_request : std::uint8_t {
 } // namespace internal
 /*! @endcond */
 
+ENTT_MODULE_EXPORT_BEGIN
+
 /**
  * @brief A SBO friendly, type-safe container for single values of any type.
  * @tparam Len Size of the storage reserved for the small buffer optimization.
@@ -600,6 +606,8 @@ template<std::size_t Len = basic_any<>::length, std::size_t Align = basic_any<Le
     return basic_any<Len, Align>{std::in_place_type<Type &&>, std::forward<Type>(value)};
 }
 
+ENTT_MODULE_EXPORT_END
+
 } // namespace entt
 
 #endif
diff --git a/src/entt/core/bit.hpp b/src/entt/core/bit.hpp
index 442d168a77..24f317ef72 100644
--- a/src/entt/core/bit.hpp
+++ b/src/entt/core/bit.hpp
@@ -1,12 +1,16 @@
 #ifndef ENTT_CORE_BIT_HPP
 #define ENTT_CORE_BIT_HPP
 
-#include <cstddef>
-#include <limits>
-#include <type_traits>
-#include "../config/config.h"
+#include "../config/module.h"
 
-namespace entt {
+#ifndef ENTT_MODULE
+#   include <cstddef>
+#   include <limits>
+#   include <type_traits>
+#   include "../config/config.h"
+#endif // ENTT_MODULE
+
+ENTT_MODULE_EXPORT namespace entt {
 
 /**
  * @brief Returns the number of set bits in a value (waiting for C++20 and
diff --git a/src/entt/core/compressed_pair.hpp b/src/entt/core/compressed_pair.hpp
index 6faf92202a..48518072e3 100644
--- a/src/entt/core/compressed_pair.hpp
+++ b/src/entt/core/compressed_pair.hpp
@@ -1,12 +1,16 @@
 #ifndef ENTT_CORE_COMPRESSED_PAIR_HPP
 #define ENTT_CORE_COMPRESSED_PAIR_HPP
 
-#include <cstddef>
-#include <tuple>
-#include <type_traits>
-#include <utility>
-#include "fwd.hpp"
-#include "type_traits.hpp"
+#include "../config/module.h"
+
+#ifndef ENTT_MODULE
+#   include <cstddef>
+#   include <tuple>
+#   include <type_traits>
+#   include <utility>
+#   include "fwd.hpp"
+#   include "type_traits.hpp"
+#endif // ENTT_MODULE
 
 namespace entt {
 
@@ -72,6 +76,8 @@ struct compressed_pair_element<Type, Tag, std::enable_if_t<is_ebco_eligible_v<Ty
 } // namespace internal
 /*! @endcond */
 
+ENTT_MODULE_EXPORT_BEGIN
+
 /**
  * @brief A compressed pair.
  *
@@ -244,9 +250,11 @@ constexpr void swap(compressed_pair<First, Second> &lhs, compressed_pair<First,
     lhs.swap(rhs);
 }
 
+ENTT_MODULE_EXPORT_END
+
 } // namespace entt
 
-namespace std {
+ENTT_MODULE_EXPORT namespace std {
 
 /**
  * @brief `std::tuple_size` specialization for `compressed_pair`s.
diff --git a/src/entt/core/enum.hpp b/src/entt/core/enum.hpp
index 5922c2f8ec..f804596d75 100644
--- a/src/entt/core/enum.hpp
+++ b/src/entt/core/enum.hpp
@@ -1,9 +1,13 @@
 #ifndef ENTT_CORE_ENUM_HPP
 #define ENTT_CORE_ENUM_HPP
 
-#include <type_traits>
+#include "../config/module.h"
 
-namespace entt {
+#ifndef ENTT_MODULE
+#    include <type_traits>
+#endif // ENTT_MODULE
+
+ENTT_MODULE_EXPORT namespace entt {
 
 /**
  * @brief Enable bitmask support for enum classes.
@@ -25,6 +29,8 @@ inline constexpr bool enum_as_bitmask_v = enum_as_bitmask<Type>::value;
 
 } // namespace entt
 
+ENTT_MODULE_EXPORT_BEGIN
+
 /**
  * @brief Operator available for enums for which bitmask support is enabled.
  * @tparam Type Enum class type.
@@ -94,4 +100,6 @@ operator^=(Type &lhs, const Type rhs) noexcept {
     return (lhs = (lhs ^ rhs));
 }
 
+ENTT_MODULE_EXPORT_END
+
 #endif
diff --git a/src/entt/core/family.hpp b/src/entt/core/family.hpp
index 71e70635a7..b42db8af4f 100644
--- a/src/entt/core/family.hpp
+++ b/src/entt/core/family.hpp
@@ -1,10 +1,14 @@
 #ifndef ENTT_CORE_FAMILY_HPP
 #define ENTT_CORE_FAMILY_HPP
 
-#include "../config/config.h"
-#include "fwd.hpp"
+#include "../config/module.h"
 
-namespace entt {
+#ifndef ENTT_MODULE
+#   include "../config/config.h"
+#   include "fwd.hpp"
+#endif // ENTT_MODULE
+
+ENTT_MODULE_EXPORT namespace entt {
 
 /**
  * @brief Dynamic identifier generator.
diff --git a/src/entt/core/fwd.hpp b/src/entt/core/fwd.hpp
index 4774d5f4e3..874e552cd2 100644
--- a/src/entt/core/fwd.hpp
+++ b/src/entt/core/fwd.hpp
@@ -1,11 +1,15 @@
 #ifndef ENTT_CORE_FWD_HPP
 #define ENTT_CORE_FWD_HPP
 
-#include <cstddef>
-#include <cstdint>
-#include "../config/config.h"
+#include "../config/module.h"
 
-namespace entt {
+#ifndef ENTT_MODULE
+#   include <cstddef>
+#   include <cstdint>
+#   include "../config/config.h"
+#endif // ENTT_MODULE
+
+ENTT_MODULE_EXPORT namespace entt {
 
 /*! @brief Possible modes of an any object. */
 enum class any_policy : std::uint8_t {
diff --git a/src/entt/core/hashed_string.hpp b/src/entt/core/hashed_string.hpp
index 08e97e6f8f..3703029ca2 100644
--- a/src/entt/core/hashed_string.hpp
+++ b/src/entt/core/hashed_string.hpp
@@ -1,9 +1,13 @@
 #ifndef ENTT_CORE_HASHED_STRING_HPP
 #define ENTT_CORE_HASHED_STRING_HPP
 
-#include <cstddef>
-#include <cstdint>
-#include "fwd.hpp"
+#include "../config/module.h"
+
+#ifndef ENTT_MODULE
+#   include <cstddef>
+#   include <cstdint>
+#   include "fwd.hpp"
+#endif // ENTT_MODULE
 
 namespace entt {
 
@@ -39,6 +43,8 @@ struct basic_hashed_string {
 } // namespace internal
 /*! @endcond */
 
+ENTT_MODULE_EXPORT_BEGIN
+
 /**
  * @brief Zero overhead unique identifier.
  *
@@ -312,6 +318,8 @@ inline namespace literals {
 
 } // namespace literals
 
+ENTT_MODULE_EXPORT_END
+
 } // namespace entt
 
 #endif
diff --git a/src/entt/core/ident.hpp b/src/entt/core/ident.hpp
index 2ff6026703..678f585ae3 100644
--- a/src/entt/core/ident.hpp
+++ b/src/entt/core/ident.hpp
@@ -1,13 +1,17 @@
 #ifndef ENTT_CORE_IDENT_HPP
 #define ENTT_CORE_IDENT_HPP
 
-#include <cstddef>
-#include <type_traits>
-#include <utility>
-#include "fwd.hpp"
-#include "type_traits.hpp"
+#include "../config/module.h"
 
-namespace entt {
+#ifndef ENTT_MODULE
+#   include <cstddef>
+#   include <type_traits>
+#   include <utility>
+#   include "fwd.hpp"
+#   include "type_traits.hpp"
+#endif // ENTT_MODULE
+
+ENTT_MODULE_EXPORT namespace entt {
 
 /**
  * @brief Type integral identifiers.
diff --git a/src/entt/core/iterator.hpp b/src/entt/core/iterator.hpp
index 0885c93303..3461e7344d 100644
--- a/src/entt/core/iterator.hpp
+++ b/src/entt/core/iterator.hpp
@@ -1,12 +1,16 @@
 #ifndef ENTT_CORE_ITERATOR_HPP
 #define ENTT_CORE_ITERATOR_HPP
 
-#include <iterator>
-#include <memory>
-#include <type_traits>
-#include <utility>
+#include "../config/module.h"
 
-namespace entt {
+#ifndef ENTT_MODULE
+#   include <iterator>
+#   include <memory>
+#   include <type_traits>
+#   include <utility>
+#endif // ENTT_MODULE
+
+ENTT_MODULE_EXPORT namespace entt {
 
 /**
  * @brief Helper type to use as pointer with input iterators.
diff --git a/src/entt/core/memory.hpp b/src/entt/core/memory.hpp
index 8f6f34b05c..b54a9765fc 100644
--- a/src/entt/core/memory.hpp
+++ b/src/entt/core/memory.hpp
@@ -1,14 +1,18 @@
 #ifndef ENTT_CORE_MEMORY_HPP
 #define ENTT_CORE_MEMORY_HPP
 
-#include <cstddef>
-#include <memory>
-#include <tuple>
-#include <type_traits>
-#include <utility>
-#include "../config/config.h"
-
-namespace entt {
+#include "../config/module.h"
+
+#ifndef ENTT_MODULE
+#   include <cstddef>
+#   include <memory>
+#   include <tuple>
+#   include <type_traits>
+#   include <utility>
+#   include "../config/config.h"
+#endif // ENTT_MODULE
+
+ENTT_MODULE_EXPORT namespace entt {
 
 /**
  * @brief Unwraps fancy pointers, does nothing otherwise (waiting for C++20).
diff --git a/src/entt/core/monostate.hpp b/src/entt/core/monostate.hpp
index 4116bda853..417a81dfeb 100644
--- a/src/entt/core/monostate.hpp
+++ b/src/entt/core/monostate.hpp
@@ -1,10 +1,14 @@
 #ifndef ENTT_CORE_MONOSTATE_HPP
 #define ENTT_CORE_MONOSTATE_HPP
 
-#include "../config/config.h"
-#include "fwd.hpp"
+#include "../config/module.h"
 
-namespace entt {
+#ifndef ENTT_MODULE
+#   include "../config/config.h"
+#   include "fwd.hpp"
+#endif // ENTT_MODULE
+
+ENTT_MODULE_EXPORT namespace entt {
 
 /**
  * @brief Minimal implementation of the monostate pattern.
diff --git a/src/entt/core/ranges.hpp b/src/entt/core/ranges.hpp
index c1d062c700..6edb0a63ff 100644
--- a/src/entt/core/ranges.hpp
+++ b/src/entt/core/ranges.hpp
@@ -1,12 +1,20 @@
 #ifndef ENTT_CORE_RANGES_HPP
 #define ENTT_CORE_RANGES_HPP
 
+#include "../config/module.h"
+
 #if __has_include(<version>)
-#    include <version>
+#    ifndef ENTT_MODULE
+#        include <version>
+#    endif // ENTT_MODULE
 #
 #    if defined(__cpp_lib_ranges)
-#        include <ranges>
-#        include "iterator.hpp"
+#        ifndef ENTT_MODULE
+#           include <ranges>
+#           include "iterator.hpp"
+#        endif // ENTT_MODULE
+
+ENTT_MODULE_EXPORT_BEGIN
 
 template<class... Args>
 inline constexpr bool std::ranges::enable_borrowed_range<entt::iterable_adaptor<Args...>>{true};
@@ -14,6 +22,8 @@ inline constexpr bool std::ranges::enable_borrowed_range<entt::iterable_adaptor<
 template<class... Args>
 inline constexpr bool std::ranges::enable_view<entt::iterable_adaptor<Args...>>{true};
 
+ENTT_MODULE_EXPORT_END
+
 #    endif
 #endif
 
diff --git a/src/entt/core/tuple.hpp b/src/entt/core/tuple.hpp
index 0a3939f3b1..1cc32e39c8 100644
--- a/src/entt/core/tuple.hpp
+++ b/src/entt/core/tuple.hpp
@@ -1,11 +1,15 @@
 #ifndef ENTT_CORE_TUPLE_HPP
 #define ENTT_CORE_TUPLE_HPP
 
-#include <tuple>
-#include <type_traits>
-#include <utility>
+#include "../config/module.h"
 
-namespace entt {
+#ifndef ENTT_MODULE
+#   include <tuple>
+#   include <type_traits>
+#   include <utility>
+#endif // ENTT_MODULE
+
+ENTT_MODULE_EXPORT namespace entt {
 
 /**
  * @brief Provides the member constant `value` to true if a given type is a
diff --git a/src/entt/core/type_info.hpp b/src/entt/core/type_info.hpp
index fb95ae8ab8..1cf22aa7ba 100644
--- a/src/entt/core/type_info.hpp
+++ b/src/entt/core/type_info.hpp
@@ -1,13 +1,17 @@
 #ifndef ENTT_CORE_TYPE_INFO_HPP
 #define ENTT_CORE_TYPE_INFO_HPP
 
-#include <string_view>
-#include <type_traits>
-#include <utility>
-#include "../config/config.h"
-#include "../core/attribute.h"
-#include "fwd.hpp"
-#include "hashed_string.hpp"
+#include "../config/module.h"
+
+#ifndef ENTT_MODULE
+#   include <string_view>
+#   include <type_traits>
+#   include <utility>
+#   include "../config/config.h"
+#   include "../core/attribute.h"
+#   include "fwd.hpp"
+#   include "hashed_string.hpp"
+#endif // ENTT_MODULE
 
 namespace entt {
 
@@ -72,6 +76,8 @@ template<typename Type>
 } // namespace internal
 /*! @endcond */
 
+ENTT_MODULE_EXPORT_BEGIN
+
 /**
  * @brief Type sequential identifier.
  * @tparam Type Type for which to generate a sequential identifier.
@@ -273,6 +279,8 @@ template<typename Type>
     return type_id<std::remove_const_t<std::remove_reference_t<Type>>>();
 }
 
+ENTT_MODULE_EXPORT_END
+
 } // namespace entt
 
 #endif
diff --git a/src/entt/core/type_traits.hpp b/src/entt/core/type_traits.hpp
index 25cc19626f..585be9a0d2 100644
--- a/src/entt/core/type_traits.hpp
+++ b/src/entt/core/type_traits.hpp
@@ -1,15 +1,19 @@
 #ifndef ENTT_CORE_TYPE_TRAITS_HPP
 #define ENTT_CORE_TYPE_TRAITS_HPP
 
-#include <cstddef>
-#include <iterator>
-#include <tuple>
-#include <type_traits>
-#include <utility>
-#include "../config/config.h"
-#include "fwd.hpp"
+#include "../config/module.h"
 
-namespace entt {
+#ifndef ENTT_MODULE
+#   include <cstddef>
+#   include <iterator>
+#   include <tuple>
+#   include <type_traits>
+#   include <utility>
+#   include "../config/config.h"
+#   include "fwd.hpp"
+#endif // ENTT_MODULE
+
+ENTT_MODULE_EXPORT namespace entt {
 
 /**
  * @brief Utility class to disambiguate overloaded functions.
@@ -906,6 +910,8 @@ using nth_argument_t = typename nth_argument<Index, Candidate>::type;
 
 } // namespace entt
 
+ENTT_MODULE_EXPORT_BEGIN
+
 template<typename... Type>
 struct std::tuple_size<entt::type_list<Type...>>: std::integral_constant<std::size_t, entt::type_list<Type...>::size> {};
 
@@ -918,4 +924,6 @@ struct std::tuple_size<entt::value_list<Value...>>: std::integral_constant<std::
 template<std::size_t Index, auto... Value>
 struct std::tuple_element<Index, entt::value_list<Value...>>: entt::value_list_element<Index, entt::value_list<Value...>> {};
 
+ENTT_MODULE_EXPORT_END
+
 #endif
diff --git a/src/entt/core/utility.hpp b/src/entt/core/utility.hpp
index af8b5bd967..f433387229 100644
--- a/src/entt/core/utility.hpp
+++ b/src/entt/core/utility.hpp
@@ -1,10 +1,14 @@
 #ifndef ENTT_CORE_UTILITY_HPP
 #define ENTT_CORE_UTILITY_HPP
 
-#include <type_traits>
-#include <utility>
+#include "../config/module.h"
 
-namespace entt {
+#ifndef ENTT_MODULE
+#   include <type_traits>
+#   include <utility>
+#endif // ENTT_MODULE
+
+ENTT_MODULE_EXPORT namespace entt {
 
 /*! @brief Identity function object (waiting for C++20). */
 struct identity {
diff --git a/src/entt/entity/component.hpp b/src/entt/entity/component.hpp
index 285d9865d4..fa3d5c45f0 100644
--- a/src/entt/entity/component.hpp
+++ b/src/entt/entity/component.hpp
@@ -1,10 +1,14 @@
 #ifndef ENTT_ENTITY_COMPONENT_HPP
 #define ENTT_ENTITY_COMPONENT_HPP
 
-#include <cstddef>
-#include <type_traits>
-#include "../config/config.h"
-#include "fwd.hpp"
+#include "../config/module.h"
+
+#ifndef ENTT_MODULE
+#    include <cstddef>
+#    include <type_traits>
+#    include "../config/config.h"
+#    include "fwd.hpp"
+#endif // ENTT_MODULE
 
 namespace entt {
 
@@ -34,6 +38,8 @@ struct page_size<Type, std::void_t<decltype(Type::page_size)>>
 } // namespace internal
 /*! @endcond */
 
+ENTT_MODULE_EXPORT_BEGIN
+
 /**
  * @brief Common way to access various properties of components.
  * @tparam Type Element type.
@@ -54,6 +60,8 @@ struct component_traits {
     static constexpr std::size_t page_size = internal::page_size<Type>::value;
 };
 
+ENTT_MODULE_EXPORT_END
+
 } // namespace entt
 
 #endif
diff --git a/src/entt/entity/entity.hpp b/src/entt/entity/entity.hpp
index 3c3dae6970..1ccf6c8173 100644
--- a/src/entt/entity/entity.hpp
+++ b/src/entt/entity/entity.hpp
@@ -1,12 +1,16 @@
 #ifndef ENTT_ENTITY_ENTITY_HPP
 #define ENTT_ENTITY_ENTITY_HPP
 
-#include <cstddef>
-#include <cstdint>
-#include <type_traits>
-#include "../config/config.h"
-#include "../core/bit.hpp"
-#include "fwd.hpp"
+#include "../config/module.h"
+
+#ifndef ENTT_MODULE
+#   include <cstddef>
+#   include <cstdint>
+#   include <type_traits>
+#   include "../config/config.h"
+#   include "../core/bit.hpp"
+#   include "fwd.hpp"
+#endif // ENTT_MODULE
 
 namespace entt {
 
@@ -53,6 +57,8 @@ struct entt_traits<std::uint64_t> {
 } // namespace internal
 /*! @endcond */
 
+ENTT_MODULE_EXPORT_BEGIN
+
 /**
  * @brief Common basic entity traits implementation.
  * @tparam Traits Actual entity traits to use.
@@ -383,6 +389,8 @@ inline constexpr null_t null{};
  */
 inline constexpr tombstone_t tombstone{};
 
+ENTT_MODULE_EXPORT_END
+
 } // namespace entt
 
 #endif
diff --git a/src/entt/entity/fwd.hpp b/src/entt/entity/fwd.hpp
index ba164a7b64..c101c38182 100644
--- a/src/entt/entity/fwd.hpp
+++ b/src/entt/entity/fwd.hpp
@@ -1,14 +1,18 @@
 #ifndef ENTT_ENTITY_FWD_HPP
 #define ENTT_ENTITY_FWD_HPP
 
-#include <cstdint>
-#include <memory>
-#include <type_traits>
-#include "../config/config.h"
-#include "../core/fwd.hpp"
-#include "../core/type_traits.hpp"
-
-namespace entt {
+#include "../config/module.h"
+
+#ifndef ENTT_MODULE
+#   include <cstdint>
+#   include <memory>
+#   include <type_traits>
+#   include "../config/config.h"
+#   include "../core/fwd.hpp"
+#   include "../core/type_traits.hpp"
+#endif // ENTT_MODULE
+
+ENTT_MODULE_EXPORT namespace entt {
 
 /*! @brief Default entity identifier. */
 enum class entity : id_type {};
diff --git a/src/entt/entity/group.hpp b/src/entt/entity/group.hpp
index 7ebe9e0b54..a1308ec35d 100644
--- a/src/entt/entity/group.hpp
+++ b/src/entt/entity/group.hpp
@@ -1,20 +1,24 @@
 #ifndef ENTT_ENTITY_GROUP_HPP
 #define ENTT_ENTITY_GROUP_HPP
 
-#include <array>
-#include <cstddef>
-#include <iterator>
-#include <tuple>
-#include <type_traits>
-#include <utility>
-#include "../config/config.h"
-#include "../core/algorithm.hpp"
-#include "../core/fwd.hpp"
-#include "../core/iterator.hpp"
-#include "../core/type_info.hpp"
-#include "../core/type_traits.hpp"
-#include "entity.hpp"
-#include "fwd.hpp"
+#include "../config/module.h"
+
+#ifndef ENTT_MODULE
+#   include <array>
+#   include <cstddef>
+#   include <iterator>
+#   include <tuple>
+#   include <type_traits>
+#   include <utility>
+#   include "../config/config.h"
+#   include "../core/algorithm.hpp"
+#   include "../core/fwd.hpp"
+#   include "../core/iterator.hpp"
+#   include "../core/type_info.hpp"
+#   include "../core/type_traits.hpp"
+#   include "entity.hpp"
+#   include "fwd.hpp"
+#endif // ENTT_MODULE
 
 namespace entt {
 
@@ -81,6 +85,8 @@ class extended_group_iterator<It, owned_t<Owned...>, get_t<Get...>> {
     std::tuple<Owned *..., Get *...> pools;
 };
 
+ENTT_MODULE_EXPORT_BEGIN
+
 template<typename... Lhs, typename... Rhs>
 [[nodiscard]] constexpr bool operator==(const extended_group_iterator<Lhs...> &lhs, const extended_group_iterator<Rhs...> &rhs) noexcept {
     return lhs.it == rhs.it;
@@ -91,6 +97,8 @@ template<typename... Lhs, typename... Rhs>
     return !(lhs == rhs);
 }
 
+ENTT_MODULE_EXPORT_END
+
 struct group_descriptor {
     using size_type = std::size_t;
     virtual ~group_descriptor() = default;
@@ -247,6 +255,8 @@ class group_handler<Type, 0u, Get, Exclude> final: public group_descriptor {
 } // namespace internal
 /*! @endcond */
 
+ENTT_MODULE_EXPORT_BEGIN
+
 /**
  * @brief Group.
  *
@@ -1056,6 +1066,8 @@ class basic_group<owned_t<Owned...>, get_t<Get...>, exclude_t<Exclude...>> {
     handler *descriptor;
 };
 
+ENTT_MODULE_EXPORT_END
+
 } // namespace entt
 
 #endif
diff --git a/src/entt/entity/handle.hpp b/src/entt/entity/handle.hpp
index bca41b2a42..d710fca2ba 100644
--- a/src/entt/entity/handle.hpp
+++ b/src/entt/entity/handle.hpp
@@ -1,15 +1,19 @@
 #ifndef ENTT_ENTITY_HANDLE_HPP
 #define ENTT_ENTITY_HANDLE_HPP
 
-#include <iterator>
-#include <tuple>
-#include <type_traits>
-#include <utility>
-#include "../config/config.h"
-#include "../core/iterator.hpp"
-#include "../core/type_traits.hpp"
-#include "entity.hpp"
-#include "fwd.hpp"
+#include "../config/module.h"
+
+#ifndef ENTT_MODULE
+#   include <iterator>
+#   include <tuple>
+#   include <type_traits>
+#   include <utility>
+#   include "../config/config.h"
+#   include "../core/iterator.hpp"
+#   include "../core/type_traits.hpp"
+#   include "entity.hpp"
+#   include "fwd.hpp"
+#endif // ENTT_MODULE
 
 namespace entt {
 
@@ -19,7 +23,7 @@ namespace internal {
 template<typename It>
 class handle_storage_iterator final {
     template<typename Other>
-    friend class handle_storage_iterator;
+    friend class internal::handle_storage_iterator;
 
     using underlying_type = std::remove_reference_t<typename It::value_type::second_type>;
     using entity_type = typename underlying_type::entity_type;
@@ -73,6 +77,8 @@ class handle_storage_iterator final {
     It last;
 };
 
+ENTT_MODULE_EXPORT_BEGIN
+
 template<typename ILhs, typename IRhs>
 [[nodiscard]] constexpr bool operator==(const handle_storage_iterator<ILhs> &lhs, const handle_storage_iterator<IRhs> &rhs) noexcept {
     return lhs.it == rhs.it;
@@ -83,9 +89,13 @@ template<typename ILhs, typename IRhs>
     return !(lhs == rhs);
 }
 
+ENTT_MODULE_EXPORT_END
+
 } // namespace internal
 /*! @endcond */
 
+ENTT_MODULE_EXPORT_BEGIN
+
 /**
  * @brief Non-owning handle to an entity.
  *
@@ -426,6 +436,8 @@ template<typename... Args>
     return (rhs != lhs);
 }
 
+ENTT_MODULE_EXPORT_END
+
 } // namespace entt
 
 #endif
diff --git a/src/entt/entity/helper.hpp b/src/entt/entity/helper.hpp
index b1ce7c34c4..cfc19cf411 100644
--- a/src/entt/entity/helper.hpp
+++ b/src/entt/entity/helper.hpp
@@ -1,18 +1,22 @@
 #ifndef ENTT_ENTITY_HELPER_HPP
 #define ENTT_ENTITY_HELPER_HPP
 
-#include <memory>
-#include <type_traits>
-#include <utility>
-#include "../core/fwd.hpp"
-#include "../core/type_traits.hpp"
-#include "component.hpp"
-#include "fwd.hpp"
-#include "group.hpp"
-#include "storage.hpp"
-#include "view.hpp"
-
-namespace entt {
+#include "../config/module.h"
+
+#ifndef ENTT_MODULE
+#   include <memory>
+#   include <type_traits>
+#   include <utility>
+#   include "../core/fwd.hpp"
+#   include "../core/type_traits.hpp"
+#   include "component.hpp"
+#   include "fwd.hpp"
+#   include "group.hpp"
+#   include "storage.hpp"
+#   include "view.hpp"
+#endif // ENTT_MODULE
+
+ENTT_MODULE_EXPORT namespace entt {
 
 /**
  * @brief Converts a registry to a view.
diff --git a/src/entt/entity/mixin.hpp b/src/entt/entity/mixin.hpp
index 5350a921af..0042a117d4 100644
--- a/src/entt/entity/mixin.hpp
+++ b/src/entt/entity/mixin.hpp
@@ -1,14 +1,18 @@
 #ifndef ENTT_ENTITY_MIXIN_HPP
 #define ENTT_ENTITY_MIXIN_HPP
 
-#include <type_traits>
-#include <utility>
-#include "../config/config.h"
-#include "../core/any.hpp"
-#include "../core/type_info.hpp"
-#include "../signal/sigh.hpp"
-#include "entity.hpp"
-#include "fwd.hpp"
+#include "../config/module.h"
+
+#ifndef ENTT_MODULE
+#   include <type_traits>
+#   include <utility>
+#   include "../config/config.h"
+#   include "../core/any.hpp"
+#   include "../core/type_info.hpp"
+#   include "../signal/sigh.hpp"
+#   include "entity.hpp"
+#   include "fwd.hpp"
+#endif // ENTT_MODULE
 
 namespace entt {
 
@@ -39,6 +43,8 @@ struct has_on_destroy<Type, Registry, std::void_t<decltype(Type::on_destroy(std:
 } // namespace internal
 /*! @endcond */
 
+ENTT_MODULE_EXPORT_BEGIN
+
 /**
  * @brief Mixin type used to add signal support to storage types.
  *
@@ -594,6 +600,8 @@ class basic_reactive_mixin final: public Type {
     container_type conn;
 };
 
+ENTT_MODULE_EXPORT_END
+
 } // namespace entt
 
 #endif
diff --git a/src/entt/entity/organizer.hpp b/src/entt/entity/organizer.hpp
index 2c6e1db1e9..0ae1256caa 100644
--- a/src/entt/entity/organizer.hpp
+++ b/src/entt/entity/organizer.hpp
@@ -1,17 +1,21 @@
 #ifndef ENTT_ENTITY_ORGANIZER_HPP
 #define ENTT_ENTITY_ORGANIZER_HPP
 
-#include <cstddef>
-#include <type_traits>
-#include <utility>
-#include <vector>
-#include "../core/type_info.hpp"
-#include "../core/type_traits.hpp"
-#include "../core/utility.hpp"
-#include "../graph/adjacency_matrix.hpp"
-#include "../graph/flow.hpp"
-#include "fwd.hpp"
-#include "helper.hpp"
+#include "../config/module.h"
+
+#ifndef ENTT_MODULE
+#   include <cstddef>
+#   include <type_traits>
+#   include <utility>
+#   include <vector>
+#   include "../core/type_info.hpp"
+#   include "../core/type_traits.hpp"
+#   include "../core/utility.hpp"
+#   include "../graph/adjacency_matrix.hpp"
+#   include "../graph/flow.hpp"
+#   include "fwd.hpp"
+#   include "helper.hpp"
+#endif // ENTT_MODULE
 
 namespace entt {
 
@@ -105,6 +109,8 @@ resource_traits<Registry, type_list<std::remove_reference_t<Args>...>, type_list
 } // namespace internal
 /*! @endcond */
 
+ENTT_MODULE_EXPORT_BEGIN
+
 /**
  * @brief Utility class for creating a static task graph.
  *
@@ -433,6 +439,8 @@ class basic_organizer final {
     flow builder;
 };
 
+ENTT_MODULE_EXPORT_END
+
 } // namespace entt
 
 #endif
diff --git a/src/entt/entity/ranges.hpp b/src/entt/entity/ranges.hpp
index a80c84edda..b52beff169 100644
--- a/src/entt/entity/ranges.hpp
+++ b/src/entt/entity/ranges.hpp
@@ -1,12 +1,20 @@
 #ifndef ENTT_ENTITY_RANGES_HPP
 #define ENTT_ENTITY_RANGES_HPP
 
+#include "../config/module.h"
+
 #if __has_include(<version>)
-#    include <version>
+#    ifndef ENTT_MODULE
+#        include <version>
+#    endif // ENTT_MODULE
 #
 #    if defined(__cpp_lib_ranges)
-#        include <ranges>
-#        include "fwd.hpp"
+#        ifndef ENTT_MODULE
+#           include <ranges>
+#           include "fwd.hpp"
+#        endif // ENTT_MODULE
+
+ENTT_MODULE_EXPORT_BEGIN
 
 template<class... Args>
 inline constexpr bool std::ranges::enable_borrowed_range<entt::basic_view<Args...>>{true};
@@ -20,6 +28,8 @@ inline constexpr bool std::ranges::enable_view<entt::basic_view<Args...>>{true};
 template<class... Args>
 inline constexpr bool std::ranges::enable_view<entt::basic_group<Args...>>{true};
 
+ENTT_MODULE_EXPORT_END
+
 #    endif
 #endif
 
diff --git a/src/entt/entity/registry.hpp b/src/entt/entity/registry.hpp
index 379e164d75..d55372a026 100644
--- a/src/entt/entity/registry.hpp
+++ b/src/entt/entity/registry.hpp
@@ -1,33 +1,37 @@
 #ifndef ENTT_ENTITY_REGISTRY_HPP
 #define ENTT_ENTITY_REGISTRY_HPP
 
-#include <algorithm>
-#include <array>
-#include <cstddef>
-#include <functional>
-#include <iterator>
-#include <memory>
-#include <tuple>
-#include <type_traits>
-#include <utility>
-#include <vector>
-#include "../config/config.h"
-#include "../container/dense_map.hpp"
-#include "../core/algorithm.hpp"
-#include "../core/any.hpp"
-#include "../core/fwd.hpp"
-#include "../core/iterator.hpp"
-#include "../core/memory.hpp"
-#include "../core/type_info.hpp"
-#include "../core/type_traits.hpp"
-#include "../core/utility.hpp"
-#include "entity.hpp"
-#include "fwd.hpp"
-#include "group.hpp"
-#include "mixin.hpp"
-#include "sparse_set.hpp"
-#include "storage.hpp"
-#include "view.hpp"
+#include "../config/module.h"
+
+#ifndef ENTT_MODULE
+#   include <algorithm>
+#   include <array>
+#   include <cstddef>
+#   include <functional>
+#   include <iterator>
+#   include <memory>
+#   include <tuple>
+#   include <type_traits>
+#   include <utility>
+#   include <vector>
+#   include "../config/config.h"
+#   include "../container/dense_map.hpp"
+#   include "../core/algorithm.hpp"
+#   include "../core/any.hpp"
+#   include "../core/fwd.hpp"
+#   include "../core/iterator.hpp"
+#   include "../core/memory.hpp"
+#   include "../core/type_info.hpp"
+#   include "../core/type_traits.hpp"
+#   include "../core/utility.hpp"
+#   include "entity.hpp"
+#   include "fwd.hpp"
+#   include "group.hpp"
+#   include "mixin.hpp"
+#   include "sparse_set.hpp"
+#   include "storage.hpp"
+#   include "view.hpp"
+#endif // ENTT_MODULE
 
 namespace entt {
 
@@ -37,7 +41,7 @@ namespace internal {
 template<typename It>
 class registry_storage_iterator final {
     template<typename Other>
-    friend class registry_storage_iterator;
+    friend class internal::registry_storage_iterator;
 
     using mapped_type = std::remove_reference_t<decltype(std::declval<It>()->second)>;
 
@@ -120,6 +124,8 @@ class registry_storage_iterator final {
     It it;
 };
 
+ENTT_MODULE_EXPORT_BEGIN
+
 template<typename Lhs, typename Rhs>
 [[nodiscard]] constexpr std::ptrdiff_t operator-(const registry_storage_iterator<Lhs> &lhs, const registry_storage_iterator<Rhs> &rhs) noexcept {
     return lhs.it - rhs.it;
@@ -155,6 +161,8 @@ template<typename Lhs, typename Rhs>
     return !(lhs < rhs);
 }
 
+ENTT_MODULE_EXPORT_END
+
 template<typename Allocator>
 class registry_context {
     using alloc_traits = std::allocator_traits<Allocator>;
@@ -229,6 +237,8 @@ class registry_context {
 } // namespace internal
 /*! @endcond */
 
+ENTT_MODULE_EXPORT_BEGIN
+
 /**
  * @brief Fast and reliable entity-component system.
  * @tparam Entity A valid entity type.
@@ -1234,6 +1244,8 @@ class basic_registry {
     storage_for_type<entity_type> entities;
 };
 
+ENTT_MODULE_EXPORT_END
+
 } // namespace entt
 
 #endif
diff --git a/src/entt/entity/runtime_view.hpp b/src/entt/entity/runtime_view.hpp
index e197fdc6f1..88649166fd 100644
--- a/src/entt/entity/runtime_view.hpp
+++ b/src/entt/entity/runtime_view.hpp
@@ -1,13 +1,17 @@
 #ifndef ENTT_ENTITY_RUNTIME_VIEW_HPP
 #define ENTT_ENTITY_RUNTIME_VIEW_HPP
 
-#include <algorithm>
-#include <cstddef>
-#include <iterator>
-#include <utility>
-#include <vector>
-#include "entity.hpp"
-#include "fwd.hpp"
+#include "../config/module.h"
+
+#ifndef ENTT_MODULE
+#   include <algorithm>
+#   include <cstddef>
+#   include <iterator>
+#   include <utility>
+#   include <vector>
+#   include "entity.hpp"
+#   include "fwd.hpp"
+#endif // ENTT_MODULE
 
 namespace entt {
 
@@ -96,6 +100,8 @@ class runtime_view_iterator final {
 } // namespace internal
 /*! @endcond */
 
+ENTT_MODULE_EXPORT_BEGIN
+
 /**
  * @brief Generic runtime view.
  *
@@ -321,6 +327,8 @@ class basic_runtime_view {
     container_type filter;
 };
 
+ENTT_MODULE_EXPORT_END
+
 } // namespace entt
 
 #endif
diff --git a/src/entt/entity/snapshot.hpp b/src/entt/entity/snapshot.hpp
index 6ee54c304d..953d81009f 100644
--- a/src/entt/entity/snapshot.hpp
+++ b/src/entt/entity/snapshot.hpp
@@ -1,18 +1,22 @@
 #ifndef ENTT_ENTITY_SNAPSHOT_HPP
 #define ENTT_ENTITY_SNAPSHOT_HPP
 
-#include <cstddef>
-#include <iterator>
-#include <tuple>
-#include <type_traits>
-#include <utility>
-#include <vector>
-#include "../config/config.h"
-#include "../container/dense_map.hpp"
-#include "../core/type_traits.hpp"
-#include "entity.hpp"
-#include "fwd.hpp"
-#include "view.hpp"
+#include "../config/module.h"
+
+#ifndef ENTT_MODULE
+#   include <cstddef>
+#   include <iterator>
+#   include <tuple>
+#   include <type_traits>
+#   include <utility>
+#   include <vector>
+#   include "../config/config.h"
+#   include "../container/dense_map.hpp"
+#   include "../core/type_traits.hpp"
+#   include "entity.hpp"
+#   include "fwd.hpp"
+#   include "view.hpp"
+#endif // ENTT_MODULE
 
 namespace entt {
 
@@ -33,6 +37,8 @@ void orphans(Registry &registry) {
 } // namespace internal
 /*! @endcond */
 
+ENTT_MODULE_EXPORT_BEGIN
+
 /**
  * @brief Utility class to create snapshots from a registry.
  *
@@ -507,6 +513,8 @@ class basic_continuous_loader {
     registry_type *reg;
 };
 
+ENTT_MODULE_EXPORT_END
+
 } // namespace entt
 
 #endif
diff --git a/src/entt/entity/sparse_set.hpp b/src/entt/entity/sparse_set.hpp
index 3d71cf3bb8..65129a824e 100644
--- a/src/entt/entity/sparse_set.hpp
+++ b/src/entt/entity/sparse_set.hpp
@@ -1,19 +1,23 @@
 #ifndef ENTT_ENTITY_SPARSE_SET_HPP
 #define ENTT_ENTITY_SPARSE_SET_HPP
 
-#include <cstddef>
-#include <iterator>
-#include <memory>
-#include <type_traits>
-#include <utility>
-#include <vector>
-#include "../config/config.h"
-#include "../core/algorithm.hpp"
-#include "../core/any.hpp"
-#include "../core/bit.hpp"
-#include "../core/type_info.hpp"
-#include "entity.hpp"
-#include "fwd.hpp"
+#include "../config/module.h"
+
+#ifndef ENTT_MODULE
+#   include <cstddef>
+#   include <iterator>
+#   include <memory>
+#   include <type_traits>
+#   include <utility>
+#   include <vector>
+#   include "../config/config.h"
+#   include "../core/algorithm.hpp"
+#   include "../core/any.hpp"
+#   include "../core/bit.hpp"
+#   include "../core/type_info.hpp"
+#   include "entity.hpp"
+#   include "fwd.hpp"
+#endif // ENTT_MODULE
 
 namespace entt {
 
@@ -97,6 +101,8 @@ struct sparse_set_iterator final {
     difference_type offset;
 };
 
+ENTT_MODULE_EXPORT_BEGIN
+
 template<typename Container>
 [[nodiscard]] constexpr std::ptrdiff_t operator-(const sparse_set_iterator<Container> &lhs, const sparse_set_iterator<Container> &rhs) noexcept {
     return rhs.index() - lhs.index();
@@ -132,9 +138,13 @@ template<typename Container>
     return !(lhs < rhs);
 }
 
+ENTT_MODULE_EXPORT_END
+
 } // namespace internal
 /*! @endcond */
 
+ENTT_MODULE_EXPORT_BEGIN
+
 /**
  * @brief Sparse set implementation.
  *
@@ -1109,6 +1119,8 @@ class basic_sparse_set {
     size_type head;
 };
 
+ENTT_MODULE_EXPORT_END
+
 } // namespace entt
 
 #endif
diff --git a/src/entt/entity/storage.hpp b/src/entt/entity/storage.hpp
index f7bda8c86e..427144c7f9 100644
--- a/src/entt/entity/storage.hpp
+++ b/src/entt/entity/storage.hpp
@@ -1,22 +1,26 @@
 #ifndef ENTT_ENTITY_STORAGE_HPP
 #define ENTT_ENTITY_STORAGE_HPP
 
-#include <cstddef>
-#include <iterator>
-#include <memory>
-#include <tuple>
-#include <type_traits>
-#include <utility>
-#include <vector>
-#include "../config/config.h"
-#include "../core/bit.hpp"
-#include "../core/iterator.hpp"
-#include "../core/memory.hpp"
-#include "../core/type_info.hpp"
-#include "component.hpp"
-#include "entity.hpp"
-#include "fwd.hpp"
-#include "sparse_set.hpp"
+#include "../config/module.h"
+
+#ifndef ENTT_MODULE
+#   include <cstddef>
+#   include <iterator>
+#   include <memory>
+#   include <tuple>
+#   include <type_traits>
+#   include <utility>
+#   include <vector>
+#   include "../config/config.h"
+#   include "../core/bit.hpp"
+#   include "../core/iterator.hpp"
+#   include "../core/memory.hpp"
+#   include "../core/type_info.hpp"
+#   include "component.hpp"
+#   include "entity.hpp"
+#   include "fwd.hpp"
+#   include "sparse_set.hpp"
+#endif // ENTT_MODULE
 
 namespace entt {
 
@@ -110,6 +114,8 @@ class storage_iterator final {
     difference_type offset;
 };
 
+ENTT_MODULE_EXPORT_BEGIN
+
 template<typename Lhs, typename Rhs, auto Page>
 [[nodiscard]] constexpr std::ptrdiff_t operator-(const storage_iterator<Lhs, Page> &lhs, const storage_iterator<Rhs, Page> &rhs) noexcept {
     return rhs.index() - lhs.index();
@@ -145,10 +151,12 @@ template<typename Lhs, typename Rhs, auto Page>
     return !(lhs < rhs);
 }
 
+ENTT_MODULE_EXPORT_END
+
 template<typename It, typename... Other>
 class extended_storage_iterator final {
     template<typename Iter, typename... Args>
-    friend class extended_storage_iterator;
+    friend class internal::extended_storage_iterator;
 
 public:
     using iterator_type = It;
@@ -197,6 +205,8 @@ class extended_storage_iterator final {
     std::tuple<It, Other...> it;
 };
 
+ENTT_MODULE_EXPORT_BEGIN
+
 template<typename... Lhs, typename... Rhs>
 [[nodiscard]] constexpr bool operator==(const extended_storage_iterator<Lhs...> &lhs, const extended_storage_iterator<Rhs...> &rhs) noexcept {
     return std::get<0>(lhs.it) == std::get<0>(rhs.it);
@@ -207,9 +217,13 @@ template<typename... Lhs, typename... Rhs>
     return !(lhs == rhs);
 }
 
+ENTT_MODULE_EXPORT_END
+
 } // namespace internal
 /*! @endcond */
 
+ENTT_MODULE_EXPORT_BEGIN
+
 /**
  * @brief Storage implementation.
  *
@@ -1243,6 +1257,8 @@ class basic_storage<Entity, Entity, Allocator>
     size_type placeholder{};
 };
 
+ENTT_MODULE_EXPORT_END
+
 } // namespace entt
 
 #endif
diff --git a/src/entt/entity/view.hpp b/src/entt/entity/view.hpp
index 42cc77ad1e..3386301d86 100644
--- a/src/entt/entity/view.hpp
+++ b/src/entt/entity/view.hpp
@@ -1,17 +1,21 @@
 #ifndef ENTT_ENTITY_VIEW_HPP
 #define ENTT_ENTITY_VIEW_HPP
 
-#include <array>
-#include <cstddef>
-#include <iterator>
-#include <tuple>
-#include <type_traits>
-#include <utility>
-#include "../config/config.h"
-#include "../core/iterator.hpp"
-#include "../core/type_traits.hpp"
-#include "entity.hpp"
-#include "fwd.hpp"
+#include "../config/module.h"
+
+#ifndef ENTT_MODULE
+#   include <array>
+#   include <cstddef>
+#   include <iterator>
+#   include <tuple>
+#   include <type_traits>
+#   include <utility>
+#   include "../config/config.h"
+#   include "../core/iterator.hpp"
+#   include "../core/type_traits.hpp"
+#   include "entity.hpp"
+#   include "fwd.hpp"
+#endif // ENTT_MODULE
 
 namespace entt {
 
@@ -20,7 +24,7 @@ namespace internal {
 
 template<typename... Type>
 // NOLINTNEXTLINE(misc-redundant-expression)
-static constexpr bool tombstone_check_v = ((sizeof...(Type) == 1u) && ... && (Type::storage_policy == deletion_policy::in_place));
+inline constexpr bool tombstone_check_v = ((sizeof...(Type) == 1u) && ... && (Type::storage_policy == deletion_policy::in_place));
 
 template<typename Type>
 const Type *view_placeholder() {
@@ -58,10 +62,13 @@ template<typename Result, typename View, typename Other, std::size_t... GLhs, st
     return elem;
 }
 
+template<typename, typename...>
+class extended_view_iterator;
+
 template<typename Type, bool Checked, std::size_t Get, std::size_t Exclude>
 class view_iterator final {
     template<typename, typename...>
-    friend class extended_view_iterator;
+    friend class internal::extended_view_iterator;
 
     using iterator_type = typename Type::const_iterator;
     using iterator_traits = std::iterator_traits<iterator_type>;
@@ -127,6 +134,8 @@ class view_iterator final {
     difference_type index;
 };
 
+ENTT_MODULE_EXPORT_BEGIN
+
 template<typename LhsType, auto... LhsArgs, typename RhsType, auto... RhsArgs>
 [[nodiscard]] constexpr bool operator==(const view_iterator<LhsType, LhsArgs...> &lhs, const view_iterator<RhsType, RhsArgs...> &rhs) noexcept {
     return lhs.it == rhs.it;
@@ -137,6 +146,8 @@ template<typename LhsType, auto... LhsArgs, typename RhsType, auto... RhsArgs>
     return !(lhs == rhs);
 }
 
+ENTT_MODULE_EXPORT_END
+
 template<typename It, typename... Get>
 class extended_view_iterator final {
     template<std::size_t... Index>
@@ -187,6 +198,8 @@ class extended_view_iterator final {
     It it;
 };
 
+ENTT_MODULE_EXPORT_BEGIN
+
 template<typename... Lhs, typename... Rhs>
 [[nodiscard]] constexpr bool operator==(const extended_view_iterator<Lhs...> &lhs, const extended_view_iterator<Rhs...> &rhs) noexcept {
     return lhs.it == rhs.it;
@@ -197,9 +210,13 @@ template<typename... Lhs, typename... Rhs>
     return !(lhs == rhs);
 }
 
+ENTT_MODULE_EXPORT_END
+
 } // namespace internal
 /*! @endcond */
 
+ENTT_MODULE_EXPORT_BEGIN
+
 /**
  * @brief View implementation.
  *
@@ -1134,6 +1151,8 @@ basic_view(Type &...storage) -> basic_view<get_t<Type...>, exclude_t<>>;
 template<typename... Get, typename... Exclude>
 basic_view(std::tuple<Get &...>, std::tuple<Exclude &...> = {}) -> basic_view<get_t<Get...>, exclude_t<Exclude...>>;
 
+ENTT_MODULE_EXPORT_END
+
 } // namespace entt
 
 #endif
diff --git a/src/entt/entt.ixx b/src/entt/entt.ixx
new file mode 100644
index 0000000000..fec60f5116
--- /dev/null
+++ b/src/entt/entt.ixx
@@ -0,0 +1,109 @@
+module;
+
+#define ENTT_MODULE
+#define ENTT_MODULE_EXPORT export
+#define ENTT_MODULE_EXPORT_BEGIN export {
+#define ENTT_MODULE_EXPORT_END }
+
+#include <algorithm>
+#include <cmath>
+#include <deque>
+#include <functional>
+#include <limits>
+#include <list>
+#include <map>
+#include <memory>
+#include <set>
+#include <string_view>
+#include <unordered_set>
+#include <utility>
+
+#ifdef ENTT_USER_CONFIG
+#   include ENTT_USER_CONFIG
+#endif // ENTT_USER_CONFIG
+
+#include "config/config.h"
+#include "config/macro.h"
+#include "config/version.h"
+#include "core/attribute.h"
+
+export module entt;
+
+#include "core/fwd.hpp"
+#include "core/utility.hpp"
+#include "core/algorithm.hpp"
+#include "core/hashed_string.hpp"
+#include "core/type_info.hpp"
+#include "core/type_traits.hpp"
+#include "core/any.hpp"
+#include "core/bit.hpp"
+#include "core/compressed_pair.hpp"
+#include "core/enum.hpp"
+#include "core/family.hpp"
+#include "core/ident.hpp"
+#include "core/iterator.hpp"
+#include "core/memory.hpp"
+#include "core/monostate.hpp"
+#include "core/ranges.hpp"
+#include "core/tuple.hpp"
+
+#include "container/fwd.hpp"
+#include "container/dense_map.hpp"
+#include "container/dense_set.hpp"
+#include "container/table.hpp"
+
+#include "signal/fwd.hpp"
+#include "signal/delegate.hpp"
+#include "signal/dispatcher.hpp"
+#include "signal/emitter.hpp"
+#include "signal/sigh.hpp"
+
+#include "graph/fwd.hpp"
+#include "graph/adjacency_matrix.hpp"
+#include "graph/dot.hpp"
+#include "graph/flow.hpp"
+
+#include "entity/fwd.hpp"
+#include "entity/component.hpp"
+#include "entity/entity.hpp"
+#include "entity/group.hpp"
+#include "entity/handle.hpp"
+#include "entity/helper.hpp"
+#include "entity/mixin.hpp"
+#include "entity/organizer.hpp"
+#include "entity/ranges.hpp"
+#include "entity/registry.hpp"
+#include "entity/runtime_view.hpp"
+#include "entity/snapshot.hpp"
+#include "entity/sparse_set.hpp"
+#include "entity/storage.hpp"
+#include "entity/view.hpp"
+
+#include "locator/locator.hpp"
+
+#include "meta/fwd.hpp"
+#include "meta/adl_pointer.hpp"
+#include "meta/context.hpp"
+#include "meta/type_traits.hpp"
+#include "meta/node.hpp"
+#include "meta/range.hpp"
+#include "meta/meta.hpp"
+#include "meta/container.hpp"
+#include "meta/resolve.hpp"
+#include "meta/policy.hpp"
+#include "meta/utility.hpp"
+#include "meta/factory.hpp"
+#include "meta/pointer.hpp"
+#include "meta/template.hpp"
+
+#include "poly/fwd.hpp"
+#include "poly/poly.hpp"
+
+#include "process/fwd.hpp"
+#include "process/process.hpp"
+#include "process/scheduler.hpp"
+
+#include "resource/fwd.hpp"
+#include "resource/cache.hpp"
+#include "resource/loader.hpp"
+#include "resource/resource.hpp"
\ No newline at end of file
diff --git a/src/entt/graph/adjacency_matrix.hpp b/src/entt/graph/adjacency_matrix.hpp
index ac72e8d98c..db35f4bf77 100644
--- a/src/entt/graph/adjacency_matrix.hpp
+++ b/src/entt/graph/adjacency_matrix.hpp
@@ -1,15 +1,19 @@
 #ifndef ENTT_GRAPH_ADJACENCY_MATRIX_HPP
 #define ENTT_GRAPH_ADJACENCY_MATRIX_HPP
 
-#include <cstddef>
-#include <iterator>
-#include <memory>
-#include <type_traits>
-#include <utility>
-#include <vector>
-#include "../config/config.h"
-#include "../core/iterator.hpp"
-#include "fwd.hpp"
+#include "../config/module.h"
+
+#ifndef ENTT_MODULE
+#   include <cstddef>
+#   include <iterator>
+#   include <memory>
+#   include <type_traits>
+#   include <utility>
+#   include <vector>
+#   include "../config/config.h"
+#   include "../core/iterator.hpp"
+#   include "fwd.hpp"
+#endif // ENTT_MODULE
 
 namespace entt {
 
@@ -74,6 +78,8 @@ class edge_iterator {
     size_type offset{};
 };
 
+ENTT_MODULE_EXPORT_BEGIN
+
 template<typename Container>
 [[nodiscard]] constexpr bool operator==(const edge_iterator<Container> &lhs, const edge_iterator<Container> &rhs) noexcept {
     return lhs.pos == rhs.pos;
@@ -84,9 +90,13 @@ template<typename Container>
     return !(lhs == rhs);
 }
 
+ENTT_MODULE_EXPORT_END
+
 } // namespace internal
 /*! @endcond */
 
+ENTT_MODULE_EXPORT_BEGIN
+
 /**
  * @brief Basic implementation of a directed adjacency matrix.
  * @tparam Category Either a directed or undirected category tag.
@@ -336,6 +346,8 @@ class adjacency_matrix {
     size_type vert;
 };
 
+ENTT_MODULE_EXPORT_END
+
 } // namespace entt
 
 #endif
diff --git a/src/entt/graph/dot.hpp b/src/entt/graph/dot.hpp
index 1da13e823c..d7ef3d04a1 100644
--- a/src/entt/graph/dot.hpp
+++ b/src/entt/graph/dot.hpp
@@ -1,11 +1,15 @@
 #ifndef ENTT_GRAPH_DOT_HPP
 #define ENTT_GRAPH_DOT_HPP
 
-#include <ostream>
-#include <type_traits>
-#include "fwd.hpp"
+#include "../config/module.h"
 
-namespace entt {
+#ifndef ENTT_MODULE
+#   include <ostream>
+#   include <type_traits>
+#   include "fwd.hpp"
+#endif // ENTT_MODULE
+
+ENTT_MODULE_EXPORT namespace entt {
 
 /**
  * @brief Outputs a graph in dot format.
diff --git a/src/entt/graph/flow.hpp b/src/entt/graph/flow.hpp
index c90427158e..3f2fb5f434 100644
--- a/src/entt/graph/flow.hpp
+++ b/src/entt/graph/flow.hpp
@@ -1,25 +1,29 @@
 #ifndef ENTT_GRAPH_FLOW_HPP
 #define ENTT_GRAPH_FLOW_HPP
 
-#include <algorithm>
-#include <cstddef>
-#include <functional>
-#include <iterator>
-#include <memory>
-#include <type_traits>
-#include <utility>
-#include <vector>
-#include "../config/config.h"
-#include "../container/dense_map.hpp"
-#include "../container/dense_set.hpp"
-#include "../core/compressed_pair.hpp"
-#include "../core/fwd.hpp"
-#include "../core/iterator.hpp"
-#include "../core/utility.hpp"
-#include "adjacency_matrix.hpp"
-#include "fwd.hpp"
-
-namespace entt {
+#include "../config/module.h"
+
+#ifndef ENTT_MODULE
+#   include <algorithm>
+#   include <cstddef>
+#   include <functional>
+#   include <iterator>
+#   include <memory>
+#   include <type_traits>
+#   include <utility>
+#   include <vector>
+#   include "../config/config.h"
+#   include "../container/dense_map.hpp"
+#   include "../container/dense_set.hpp"
+#   include "../core/compressed_pair.hpp"
+#   include "../core/fwd.hpp"
+#   include "../core/iterator.hpp"
+#   include "../core/utility.hpp"
+#   include "adjacency_matrix.hpp"
+#   include "fwd.hpp"
+#endif // ENTT_MODULE
+
+ENTT_MODULE_EXPORT namespace entt {
 
 /**
  * @brief Utility class for creating task graphs.
diff --git a/src/entt/graph/fwd.hpp b/src/entt/graph/fwd.hpp
index 963082fc23..b385f33e80 100644
--- a/src/entt/graph/fwd.hpp
+++ b/src/entt/graph/fwd.hpp
@@ -1,11 +1,15 @@
 #ifndef ENTT_GRAPH_FWD_HPP
 #define ENTT_GRAPH_FWD_HPP
 
-#include <cstddef>
-#include <memory>
-#include "../core/fwd.hpp"
+#include "../config/module.h"
 
-namespace entt {
+#ifndef ENTT_MODULE
+#   include <cstddef>
+#   include <memory>
+#   include "../core/fwd.hpp"
+#endif // ENTT_MODULE
+
+ENTT_MODULE_EXPORT namespace entt {
 
 /*! @brief Undirected graph category tag. */
 struct directed_tag {};
diff --git a/src/entt/locator/locator.hpp b/src/entt/locator/locator.hpp
index 045adff6f3..df87b90f14 100644
--- a/src/entt/locator/locator.hpp
+++ b/src/entt/locator/locator.hpp
@@ -1,11 +1,15 @@
 #ifndef ENTT_LOCATOR_LOCATOR_HPP
 #define ENTT_LOCATOR_LOCATOR_HPP
 
-#include <memory>
-#include <utility>
-#include "../config/config.h"
+#include "../config/module.h"
 
-namespace entt {
+#ifndef ENTT_MODULE
+#   include <memory>
+#   include <utility>
+#   include "../config/config.h"
+#endif // ENTT_MODULE
+
+ENTT_MODULE_EXPORT namespace entt {
 
 /**
  * @brief Service locator, nothing more.
@@ -26,7 +30,7 @@ namespace entt {
 template<typename Service>
 class locator final {
     class service_handle {
-        friend class locator<Service>;
+        friend class entt::locator<Service>;
         std::shared_ptr<Service> value{};
     };
 
diff --git a/src/entt/meta/adl_pointer.hpp b/src/entt/meta/adl_pointer.hpp
index 5bb768ac70..de086c3be1 100644
--- a/src/entt/meta/adl_pointer.hpp
+++ b/src/entt/meta/adl_pointer.hpp
@@ -1,7 +1,9 @@
 #ifndef ENTT_META_ADL_POINTER_HPP
 #define ENTT_META_ADL_POINTER_HPP
 
-namespace entt {
+#include "../config/module.h"
+
+ENTT_MODULE_EXPORT namespace entt {
 
 /**
  * @brief ADL based lookup function for dereferencing meta pointer-like types.
diff --git a/src/entt/meta/container.hpp b/src/entt/meta/container.hpp
index 7ccfc7bad5..22d98a71a4 100644
--- a/src/entt/meta/container.hpp
+++ b/src/entt/meta/container.hpp
@@ -3,24 +3,28 @@
 #ifndef ENTT_META_CONTAINER_HPP
 #define ENTT_META_CONTAINER_HPP
 
-#include <array>
-#include <cstddef>
-#include <deque>
-#include <iterator>
-#include <list>
-#include <map>
-#include <set>
-#include <type_traits>
-#include <unordered_map>
-#include <unordered_set>
-#include <vector>
-#include "../container/dense_map.hpp"
-#include "../container/dense_set.hpp"
-#include "../core/type_traits.hpp"
-#include "context.hpp"
-#include "fwd.hpp"
-#include "meta.hpp"
-#include "type_traits.hpp"
+#include "../config/module.h"
+
+#ifndef ENTT_MODULE
+#   include <array>
+#   include <cstddef>
+#   include <deque>
+#   include <iterator>
+#   include <list>
+#   include <map>
+#   include <set>
+#   include <type_traits>
+#   include <unordered_map>
+#   include <unordered_set>
+#   include <vector>
+#   include "../container/dense_map.hpp"
+#   include "../container/dense_set.hpp"
+#   include "../core/type_traits.hpp"
+#   include "context.hpp"
+#   include "fwd.hpp"
+#   include "meta.hpp"
+#   include "type_traits.hpp"
+#endif // ENTT_MODULE
 
 namespace entt {
 
@@ -57,6 +61,8 @@ inline constexpr bool reserve_aware_container_v = reserve_aware_container<Type>:
 } // namespace internal
 /*! @endcond */
 
+ENTT_MODULE_EXPORT_BEGIN
+
 /**
  * @brief General purpose implementation of meta sequence container traits.
  * @tparam Type Type of underlying sequence container.
@@ -370,6 +376,8 @@ template<typename... Args>
 struct meta_associative_container_traits<dense_set<Args...>>
     : basic_meta_associative_container_traits<dense_set<Args...>> {};
 
+ENTT_MODULE_EXPORT_END
+
 } // namespace entt
 
 #endif
diff --git a/src/entt/meta/context.hpp b/src/entt/meta/context.hpp
index e9ae353cd4..9e56aba3b4 100644
--- a/src/entt/meta/context.hpp
+++ b/src/entt/meta/context.hpp
@@ -1,11 +1,15 @@
 #ifndef ENTT_META_CTX_HPP
 #define ENTT_META_CTX_HPP
 
-#include <memory>
-#include "../container/dense_map.hpp"
-#include "../core/fwd.hpp"
-#include "../core/utility.hpp"
-#include "fwd.hpp"
+#include "../config/module.h"
+
+#ifndef ENTT_MODULE
+#   include <memory>
+#   include "../container/dense_map.hpp"
+#   include "../core/fwd.hpp"
+#   include "../core/utility.hpp"
+#   include "fwd.hpp"
+#endif // ENTT_MODULE
 
 namespace entt {
 
@@ -24,6 +28,8 @@ struct meta_context {
 } // namespace internal
 /*! @endcond */
 
+ENTT_MODULE_EXPORT_BEGIN
+
 /*! @brief Disambiguation tag for constructors and the like. */
 class meta_ctx_arg_t final {};
 
@@ -36,6 +42,8 @@ class meta_ctx: private internal::meta_context {
     friend struct internal::meta_context;
 };
 
+ENTT_MODULE_EXPORT_END
+
 /*! @cond TURN_OFF_DOXYGEN */
 [[nodiscard]] inline internal::meta_context &internal::meta_context::from(meta_ctx &ctx) {
     return ctx;
diff --git a/src/entt/meta/factory.hpp b/src/entt/meta/factory.hpp
index 9275b7f833..31131338da 100644
--- a/src/entt/meta/factory.hpp
+++ b/src/entt/meta/factory.hpp
@@ -1,28 +1,32 @@
 #ifndef ENTT_META_FACTORY_HPP
 #define ENTT_META_FACTORY_HPP
 
-#include <cstddef>
-#include <cstdint>
-#include <functional>
-#include <memory>
-#include <tuple>
-#include <type_traits>
-#include <utility>
-#include "../config/config.h"
-#include "../core/bit.hpp"
-#include "../core/fwd.hpp"
-#include "../core/hashed_string.hpp"
-#include "../core/type_info.hpp"
-#include "../core/type_traits.hpp"
-#include "../locator/locator.hpp"
-#include "context.hpp"
-#include "fwd.hpp"
-#include "meta.hpp"
-#include "node.hpp"
-#include "policy.hpp"
-#include "range.hpp"
-#include "resolve.hpp"
-#include "utility.hpp"
+#include "../config/module.h"
+
+#ifndef ENTT_MODULE
+#   include <cstddef>
+#   include <cstdint>
+#   include <functional>
+#   include <memory>
+#   include <tuple>
+#   include <type_traits>
+#   include <utility>
+#   include "../config/config.h"
+#   include "../core/bit.hpp"
+#   include "../core/fwd.hpp"
+#   include "../core/hashed_string.hpp"
+#   include "../core/type_info.hpp"
+#   include "../core/type_traits.hpp"
+#   include "../locator/locator.hpp"
+#   include "context.hpp"
+#   include "fwd.hpp"
+#   include "meta.hpp"
+#   include "node.hpp"
+#   include "policy.hpp"
+#   include "range.hpp"
+#   include "resolve.hpp"
+#   include "utility.hpp"
+#endif // ENTT_MODULE
 
 namespace entt {
 
@@ -146,6 +150,8 @@ class basic_meta_factory {
 } // namespace internal
 /*! @endcond */
 
+ENTT_MODULE_EXPORT_BEGIN
+
 /**
  * @brief Meta factory to be used for reflection purposes.
  * @tparam Type Type for which the factory was created.
@@ -581,6 +587,8 @@ inline void meta_reset() noexcept {
     meta_reset(locator<meta_ctx>::value_or());
 }
 
+ENTT_MODULE_EXPORT_END
+
 } // namespace entt
 
 #endif
diff --git a/src/entt/meta/fwd.hpp b/src/entt/meta/fwd.hpp
index 79e0ab4877..d76928c12f 100644
--- a/src/entt/meta/fwd.hpp
+++ b/src/entt/meta/fwd.hpp
@@ -1,10 +1,14 @@
 #ifndef ENTT_META_FWD_HPP
 #define ENTT_META_FWD_HPP
 
-#include <cstddef>
-#include <limits>
+#include "../config/module.h"
 
-namespace entt {
+#ifndef ENTT_MODULE
+#   include <cstddef>
+#   include <limits>
+#endif // ENTT_MODULE
+
+ENTT_MODULE_EXPORT namespace entt {
 
 class meta_ctx;
 
diff --git a/src/entt/meta/meta.hpp b/src/entt/meta/meta.hpp
index e675d9c5e0..058fc9255d 100644
--- a/src/entt/meta/meta.hpp
+++ b/src/entt/meta/meta.hpp
@@ -1,28 +1,32 @@
 #ifndef ENTT_META_META_HPP
 #define ENTT_META_META_HPP
 
-#include <array>
-#include <cstddef>
-#include <iterator>
-#include <memory>
-#include <type_traits>
-#include <utility>
-#include "../config/config.h"
-#include "../core/any.hpp"
-#include "../core/fwd.hpp"
-#include "../core/iterator.hpp"
-#include "../core/type_info.hpp"
-#include "../core/type_traits.hpp"
-#include "../core/utility.hpp"
-#include "../locator/locator.hpp"
-#include "adl_pointer.hpp"
-#include "context.hpp"
-#include "fwd.hpp"
-#include "node.hpp"
-#include "range.hpp"
-#include "type_traits.hpp"
-
-namespace entt {
+#include "../config/module.h"
+
+#ifndef ENTT_MODULE
+#   include <array>
+#   include <cstddef>
+#   include <iterator>
+#   include <memory>
+#   include <type_traits>
+#   include <utility>
+#   include "../config/config.h"
+#   include "../core/any.hpp"
+#   include "../core/fwd.hpp"
+#   include "../core/iterator.hpp"
+#   include "../core/type_info.hpp"
+#   include "../core/type_traits.hpp"
+#   include "../core/utility.hpp"
+#   include "../locator/locator.hpp"
+#   include "adl_pointer.hpp"
+#   include "context.hpp"
+#   include "fwd.hpp"
+#   include "node.hpp"
+#   include "range.hpp"
+#   include "type_traits.hpp"
+#endif // ENTT_MODULE
+
+ENTT_MODULE_EXPORT namespace entt {
 
 class meta_any;
 class meta_type;
diff --git a/src/entt/meta/node.hpp b/src/entt/meta/node.hpp
index 6bd0b335a2..43c6694830 100644
--- a/src/entt/meta/node.hpp
+++ b/src/entt/meta/node.hpp
@@ -1,22 +1,26 @@
 #ifndef ENTT_META_NODE_HPP
 #define ENTT_META_NODE_HPP
 
-#include <array>
-#include <cstddef>
-#include <memory>
-#include <type_traits>
-#include <utility>
-#include <vector>
-#include "../config/config.h"
-#include "../core/attribute.h"
-#include "../core/bit.hpp"
-#include "../core/enum.hpp"
-#include "../core/fwd.hpp"
-#include "../core/type_info.hpp"
-#include "../core/type_traits.hpp"
-#include "../core/utility.hpp"
-#include "context.hpp"
-#include "type_traits.hpp"
+#include "../config/module.h"
+
+#ifndef ENTT_MODULE
+#   include <array>
+#   include <cstddef>
+#   include <memory>
+#   include <type_traits>
+#   include <utility>
+#   include <vector>
+#   include "../config/config.h"
+#   include "../core/attribute.h"
+#   include "../core/bit.hpp"
+#   include "../core/enum.hpp"
+#   include "../core/fwd.hpp"
+#   include "../core/type_info.hpp"
+#   include "../core/type_traits.hpp"
+#   include "../core/utility.hpp"
+#   include "context.hpp"
+#   include "type_traits.hpp"
+#endif // ENTT_MODULE
 
 namespace entt {
 
diff --git a/src/entt/meta/pointer.hpp b/src/entt/meta/pointer.hpp
index d381c5e5f4..0f51c03d76 100644
--- a/src/entt/meta/pointer.hpp
+++ b/src/entt/meta/pointer.hpp
@@ -3,11 +3,15 @@
 #ifndef ENTT_META_POINTER_HPP
 #define ENTT_META_POINTER_HPP
 
-#include <memory>
-#include <type_traits>
-#include "type_traits.hpp"
+#include "../config/module.h"
 
-namespace entt {
+#ifndef ENTT_MODULE
+#   include <memory>
+#   include <type_traits>
+#   include "type_traits.hpp"
+#endif // ENTT_MODULE
+
+ENTT_MODULE_EXPORT namespace entt {
 
 /**
  * @brief Makes plain pointers pointer-like types for the meta system.
diff --git a/src/entt/meta/policy.hpp b/src/entt/meta/policy.hpp
index b939599de1..ec4483c683 100644
--- a/src/entt/meta/policy.hpp
+++ b/src/entt/meta/policy.hpp
@@ -1,9 +1,13 @@
 #ifndef ENTT_META_POLICY_HPP
 #define ENTT_META_POLICY_HPP
 
-#include <type_traits>
+#include "../config/module.h"
 
-namespace entt {
+#ifndef ENTT_MODULE
+#    include <type_traits>
+#endif // ENTT_MODULE
+
+ENTT_MODULE_EXPORT namespace entt {
 
 /*! @brief Empty class type used to request the _as ref_ policy. */
 struct as_ref_t final {
diff --git a/src/entt/meta/range.hpp b/src/entt/meta/range.hpp
index a63bbf66e2..2f9cbf322b 100644
--- a/src/entt/meta/range.hpp
+++ b/src/entt/meta/range.hpp
@@ -1,12 +1,16 @@
 #ifndef ENTT_META_RANGE_HPP
 #define ENTT_META_RANGE_HPP
 
-#include <cstddef>
-#include <iterator>
-#include <utility>
-#include "../core/fwd.hpp"
-#include "../core/iterator.hpp"
-#include "context.hpp"
+#include "../config/module.h"
+
+#ifndef ENTT_MODULE
+#   include <cstddef>
+#   include <iterator>
+#   include <utility>
+#   include "../core/fwd.hpp"
+#   include "../core/iterator.hpp"
+#   include "context.hpp"
+#endif // ENTT_MODULE
 
 namespace entt {
 
@@ -100,6 +104,8 @@ struct meta_range_iterator final {
     const meta_ctx *ctx;
 };
 
+ENTT_MODULE_EXPORT_BEGIN
+
 template<typename... Args>
 [[nodiscard]] constexpr std::ptrdiff_t operator-(const meta_range_iterator<Args...> &lhs, const meta_range_iterator<Args...> &rhs) noexcept {
     return lhs.it - rhs.it;
@@ -135,9 +141,13 @@ template<typename... Args>
     return !(lhs < rhs);
 }
 
+ENTT_MODULE_EXPORT_END
+
 } // namespace internal
 /*! @endcond */
 
+ENTT_MODULE_EXPORT_BEGIN
+
 /**
  * @brief Iterable range to use to iterate all types of meta objects.
  * @tparam Type Type of meta objects returned.
@@ -146,6 +156,8 @@ template<typename... Args>
 template<typename Type, typename It>
 using meta_range = iterable_adaptor<internal::meta_range_iterator<Type, It>>;
 
+ENTT_MODULE_EXPORT_END
+
 } // namespace entt
 
 #endif
diff --git a/src/entt/meta/resolve.hpp b/src/entt/meta/resolve.hpp
index 174929e12c..c1dd652624 100644
--- a/src/entt/meta/resolve.hpp
+++ b/src/entt/meta/resolve.hpp
@@ -1,15 +1,19 @@
 #ifndef ENTT_META_RESOLVE_HPP
 #define ENTT_META_RESOLVE_HPP
 
-#include <type_traits>
-#include "../core/type_info.hpp"
-#include "../locator/locator.hpp"
-#include "context.hpp"
-#include "meta.hpp"
-#include "node.hpp"
-#include "range.hpp"
+#include "../config/module.h"
 
-namespace entt {
+#ifndef ENTT_MODULE
+#   include <type_traits>
+#   include "../core/type_info.hpp"
+#   include "../locator/locator.hpp"
+#   include "context.hpp"
+#   include "meta.hpp"
+#   include "node.hpp"
+#   include "range.hpp"
+#endif // ENTT_MODULE
+
+ENTT_MODULE_EXPORT namespace entt {
 
 /**
  * @brief Returns the meta type associated with a given type.
diff --git a/src/entt/meta/template.hpp b/src/entt/meta/template.hpp
index 5eab2afcd8..ba402db238 100644
--- a/src/entt/meta/template.hpp
+++ b/src/entt/meta/template.hpp
@@ -3,9 +3,13 @@
 #ifndef ENTT_META_TEMPLATE_HPP
 #define ENTT_META_TEMPLATE_HPP
 
-#include "../core/type_traits.hpp"
+#include "../config/module.h"
 
-namespace entt {
+#ifndef ENTT_MODULE
+#    include "../core/type_traits.hpp"
+#endif // ENTT_MODULE
+
+ENTT_MODULE_EXPORT namespace entt {
 
 /*! @brief Utility class to disambiguate class templates. */
 template<template<typename...> class>
diff --git a/src/entt/meta/type_traits.hpp b/src/entt/meta/type_traits.hpp
index cb684b42c0..8d0fba94f8 100644
--- a/src/entt/meta/type_traits.hpp
+++ b/src/entt/meta/type_traits.hpp
@@ -1,10 +1,14 @@
 #ifndef ENTT_META_TYPE_TRAITS_HPP
 #define ENTT_META_TYPE_TRAITS_HPP
 
-#include <type_traits>
-#include <utility>
+#include "../config/module.h"
 
-namespace entt {
+#ifndef ENTT_MODULE
+#   include <type_traits>
+#   include <utility>
+#endif // ENTT_MODULE
+
+ENTT_MODULE_EXPORT namespace entt {
 
 /**
  * @brief Traits class template to be specialized to enable support for meta
diff --git a/src/entt/meta/utility.hpp b/src/entt/meta/utility.hpp
index 35f90dd777..400c5c664e 100644
--- a/src/entt/meta/utility.hpp
+++ b/src/entt/meta/utility.hpp
@@ -1,18 +1,24 @@
 #ifndef ENTT_META_UTILITY_HPP
 #define ENTT_META_UTILITY_HPP
 
-#include <cstddef>
-#include <functional>
-#include <type_traits>
-#include <utility>
-#include "../core/type_traits.hpp"
-#include "../locator/locator.hpp"
-#include "meta.hpp"
-#include "node.hpp"
-#include "policy.hpp"
+#include "../config/module.h"
+
+#ifndef ENTT_MODULE
+#   include <cstddef>
+#   include <functional>
+#   include <type_traits>
+#   include <utility>
+#   include "../core/type_traits.hpp"
+#   include "../locator/locator.hpp"
+#   include "meta.hpp"
+#   include "node.hpp"
+#   include "policy.hpp"
+#endif // ENTT_MODULE
 
 namespace entt {
 
+ENTT_MODULE_EXPORT_BEGIN
+
 /**
  * @brief Meta function descriptor traits.
  * @tparam Ret Function return type.
@@ -190,6 +196,8 @@ template<typename Policy = as_is_t, typename Type>
     return meta_dispatch<Policy, Type>(locator<meta_ctx>::value_or(), std::forward<Type>(value));
 }
 
+ENTT_MODULE_EXPORT_END
+
 /*! @cond TURN_OFF_DOXYGEN */
 namespace internal {
 
@@ -240,6 +248,8 @@ template<typename Type, typename... Args, std::size_t... Index>
 } // namespace internal
 /*! @endcond */
 
+ENTT_MODULE_EXPORT_BEGIN
+
 /**
  * @brief Returns the meta type of the i-th element of a list of arguments.
  * @tparam Type Type list of the actual types of arguments.
@@ -473,6 +483,8 @@ template<typename Type, auto Candidate, typename Policy = as_is_t>
     return meta_construct<Type, Candidate, Policy>(locator<meta_ctx>::value_or(), args);
 }
 
+ENTT_MODULE_EXPORT_END
+
 } // namespace entt
 
 #endif
diff --git a/src/entt/poly/fwd.hpp b/src/entt/poly/fwd.hpp
index 34b096de06..336e2537e1 100644
--- a/src/entt/poly/fwd.hpp
+++ b/src/entt/poly/fwd.hpp
@@ -1,9 +1,13 @@
 #ifndef ENTT_POLY_FWD_HPP
 #define ENTT_POLY_FWD_HPP
 
-#include <cstddef>
+#include "../config/module.h"
 
-namespace entt {
+#ifndef ENTT_MODULE
+#    include <cstddef>
+#endif // ENTT_MODULE
+
+ENTT_MODULE_EXPORT namespace entt {
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays, modernize-avoid-c-arrays)
 template<typename, std::size_t Len = sizeof(double[2]), std::size_t = alignof(double[2])>
diff --git a/src/entt/poly/poly.hpp b/src/entt/poly/poly.hpp
index 864bede1fb..22e41844b2 100644
--- a/src/entt/poly/poly.hpp
+++ b/src/entt/poly/poly.hpp
@@ -1,17 +1,21 @@
 #ifndef ENTT_POLY_POLY_HPP
 #define ENTT_POLY_POLY_HPP
 
-#include <cstddef>
-#include <functional>
-#include <tuple>
-#include <type_traits>
-#include <utility>
-#include "../core/any.hpp"
-#include "../core/type_info.hpp"
-#include "../core/type_traits.hpp"
-#include "fwd.hpp"
-
-namespace entt {
+#include "../config/module.h"
+
+#ifndef ENTT_MODULE
+#   include <cstddef>
+#   include <functional>
+#   include <tuple>
+#   include <type_traits>
+#   include <utility>
+#   include "../core/any.hpp"
+#   include "../core/type_info.hpp"
+#   include "../core/type_traits.hpp"
+#   include "fwd.hpp"
+#endif // ENTT_MODULE
+
+ENTT_MODULE_EXPORT namespace entt {
 
 /*! @brief Inspector class used to infer the type of the virtual table. */
 struct poly_inspector {
diff --git a/src/entt/process/fwd.hpp b/src/entt/process/fwd.hpp
index ff8872e674..ac60714795 100644
--- a/src/entt/process/fwd.hpp
+++ b/src/entt/process/fwd.hpp
@@ -1,10 +1,14 @@
 #ifndef ENTT_PROCESS_FWD_HPP
 #define ENTT_PROCESS_FWD_HPP
 
-#include <cstdint>
-#include <memory>
+#include "../config/module.h"
 
-namespace entt {
+#ifndef ENTT_MODULE
+#   include <cstdint>
+#   include <memory>
+#endif // ENTT_MODULE
+
+ENTT_MODULE_EXPORT namespace entt {
 
 template<typename, typename = std::allocator<void>>
 class basic_process;
diff --git a/src/entt/process/process.hpp b/src/entt/process/process.hpp
index ec642500ec..655c57f451 100644
--- a/src/entt/process/process.hpp
+++ b/src/entt/process/process.hpp
@@ -1,13 +1,17 @@
 #ifndef ENTT_PROCESS_PROCESS_HPP
 #define ENTT_PROCESS_PROCESS_HPP
 
-#include <cstdint>
-#include <memory>
-#include <type_traits>
-#include <utility>
-#include "../core/compressed_pair.hpp"
-#include "../core/type_traits.hpp"
-#include "fwd.hpp"
+#include "../config/module.h"
+
+#ifndef ENTT_MODULE
+#   include <cstdint>
+#   include <memory>
+#   include <type_traits>
+#   include <utility>
+#   include "../core/compressed_pair.hpp"
+#   include "../core/type_traits.hpp"
+#   include "fwd.hpp"
+#endif // ENTT_MODULE
 
 namespace entt {
 
@@ -20,6 +24,8 @@ struct process_adaptor;
 } // namespace internal
 /*! @endcond */
 
+ENTT_MODULE_EXPORT_BEGIN
+
 /**
  * @brief Base class for processes.
  *
@@ -287,6 +293,8 @@ class basic_process: public std::enable_shared_from_this<basic_process<Delta, Al
     state current;
 };
 
+ENTT_MODULE_EXPORT_END
+
 /*! @cond TURN_OFF_DOXYGEN */
 namespace internal {
 
diff --git a/src/entt/process/scheduler.hpp b/src/entt/process/scheduler.hpp
index 4e3aaaefd5..d71dd68758 100644
--- a/src/entt/process/scheduler.hpp
+++ b/src/entt/process/scheduler.hpp
@@ -1,17 +1,21 @@
 #ifndef ENTT_PROCESS_SCHEDULER_HPP
 #define ENTT_PROCESS_SCHEDULER_HPP
 
-#include <cstddef>
-#include <memory>
-#include <type_traits>
-#include <utility>
-#include <vector>
-#include "../config/config.h"
-#include "../core/compressed_pair.hpp"
-#include "fwd.hpp"
-#include "process.hpp"
-
-namespace entt {
+#include "../config/module.h"
+
+#ifndef ENTT_MODULE
+#   include <cstddef>
+#   include <memory>
+#   include <type_traits>
+#   include <utility>
+#   include <vector>
+#   include "../config/config.h"
+#   include "../core/compressed_pair.hpp"
+#   include "fwd.hpp"
+#   include "process.hpp"
+#endif // ENTT_MODULE
+
+ENTT_MODULE_EXPORT namespace entt {
 
 /**
  * @brief Cooperative scheduler for processes.
diff --git a/src/entt/resource/cache.hpp b/src/entt/resource/cache.hpp
index 8c5efcda42..ab59d3ff98 100644
--- a/src/entt/resource/cache.hpp
+++ b/src/entt/resource/cache.hpp
@@ -1,21 +1,25 @@
 #ifndef ENTT_RESOURCE_RESOURCE_CACHE_HPP
 #define ENTT_RESOURCE_RESOURCE_CACHE_HPP
 
-#include <cstddef>
-#include <functional>
-#include <iterator>
-#include <memory>
-#include <tuple>
-#include <type_traits>
-#include <utility>
-#include "../container/dense_map.hpp"
-#include "../core/compressed_pair.hpp"
-#include "../core/fwd.hpp"
-#include "../core/iterator.hpp"
-#include "../core/utility.hpp"
-#include "fwd.hpp"
-#include "loader.hpp"
-#include "resource.hpp"
+#include "../config/module.h"
+
+#ifndef ENTT_MODULE
+#   include <cstddef>
+#   include <functional>
+#   include <iterator>
+#   include <memory>
+#   include <tuple>
+#   include <type_traits>
+#   include <utility>
+#   include "../container/dense_map.hpp"
+#   include "../core/compressed_pair.hpp"
+#   include "../core/fwd.hpp"
+#   include "../core/iterator.hpp"
+#   include "../core/utility.hpp"
+#   include "fwd.hpp"
+#   include "loader.hpp"
+#   include "resource.hpp"
+#endif // ENTT_MODULE
 
 namespace entt {
 
@@ -25,7 +29,7 @@ namespace internal {
 template<typename Type, typename It>
 class resource_cache_iterator final {
     template<typename, typename>
-    friend class resource_cache_iterator;
+    friend class internal::resource_cache_iterator;
 
 public:
     using value_type = std::pair<id_type, resource<Type>>;
@@ -105,6 +109,8 @@ class resource_cache_iterator final {
     It it;
 };
 
+ENTT_MODULE_EXPORT_BEGIN
+
 template<typename... Lhs, typename... Rhs>
 [[nodiscard]] constexpr std::ptrdiff_t operator-(const resource_cache_iterator<Lhs...> &lhs, const resource_cache_iterator<Rhs...> &rhs) noexcept {
     return lhs.it - rhs.it;
@@ -140,9 +146,13 @@ template<typename... Lhs, typename... Rhs>
     return !(lhs < rhs);
 }
 
+ENTT_MODULE_EXPORT_END
+
 } // namespace internal
 /*! @endcond */
 
+ENTT_MODULE_EXPORT_BEGIN
+
 /**
  * @brief Basic cache for resources of any type.
  * @tparam Type Type of resources managed by a cache.
@@ -408,6 +418,8 @@ class resource_cache {
     compressed_pair<container_type, loader_type> pool;
 };
 
+ENTT_MODULE_EXPORT_END
+
 } // namespace entt
 
 #endif
diff --git a/src/entt/resource/fwd.hpp b/src/entt/resource/fwd.hpp
index ed63da5800..64bc2c4570 100644
--- a/src/entt/resource/fwd.hpp
+++ b/src/entt/resource/fwd.hpp
@@ -1,9 +1,13 @@
 #ifndef ENTT_RESOURCE_FWD_HPP
 #define ENTT_RESOURCE_FWD_HPP
 
-#include <memory>
+#include "../config/module.h"
 
-namespace entt {
+#ifndef ENTT_MODULE
+#    include <memory>
+#endif // ENTT_MODULE
+
+ENTT_MODULE_EXPORT namespace entt {
 
 template<typename>
 struct resource_loader;
diff --git a/src/entt/resource/loader.hpp b/src/entt/resource/loader.hpp
index f59d748911..182a3f3107 100644
--- a/src/entt/resource/loader.hpp
+++ b/src/entt/resource/loader.hpp
@@ -1,11 +1,15 @@
 #ifndef ENTT_RESOURCE_LOADER_HPP
 #define ENTT_RESOURCE_LOADER_HPP
 
-#include <memory>
-#include <utility>
-#include "fwd.hpp"
+#include "../config/module.h"
 
-namespace entt {
+#ifndef ENTT_MODULE
+#   include <memory>
+#   include <utility>
+#   include "fwd.hpp"
+#endif // ENTT_MODULE
+
+ENTT_MODULE_EXPORT namespace entt {
 
 /**
  * @brief Transparent loader for shared resources.
diff --git a/src/entt/resource/resource.hpp b/src/entt/resource/resource.hpp
index a131001900..088cb50442 100644
--- a/src/entt/resource/resource.hpp
+++ b/src/entt/resource/resource.hpp
@@ -1,12 +1,16 @@
 #ifndef ENTT_RESOURCE_RESOURCE_HPP
 #define ENTT_RESOURCE_RESOURCE_HPP
 
-#include <memory>
-#include <type_traits>
-#include <utility>
-#include "fwd.hpp"
+#include "../config/module.h"
 
-namespace entt {
+#ifndef ENTT_MODULE
+#   include <memory>
+#   include <type_traits>
+#   include <utility>
+#   include "fwd.hpp"
+#endif // ENTT_MODULE
+
+ENTT_MODULE_EXPORT namespace entt {
 
 /**
  * @brief Basic resource handle.
@@ -21,7 +25,7 @@ namespace entt {
 template<typename Type>
 class resource {
     template<typename>
-    friend class resource;
+    friend class entt::resource;
 
     template<typename Other>
     static constexpr bool is_acceptable = !std::is_same_v<Type, Other> && std::is_constructible_v<Type &, Other &>;
diff --git a/src/entt/signal/delegate.hpp b/src/entt/signal/delegate.hpp
index 730f4dcd1c..dd97399073 100644
--- a/src/entt/signal/delegate.hpp
+++ b/src/entt/signal/delegate.hpp
@@ -1,14 +1,18 @@
 #ifndef ENTT_SIGNAL_DELEGATE_HPP
 #define ENTT_SIGNAL_DELEGATE_HPP
 
-#include <cstddef>
-#include <functional>
-#include <tuple>
-#include <type_traits>
-#include <utility>
-#include "../config/config.h"
-#include "../core/type_traits.hpp"
-#include "fwd.hpp"
+#include "../config/module.h"
+
+#ifndef ENTT_MODULE
+#   include <cstddef>
+#   include <functional>
+#   include <tuple>
+#   include <type_traits>
+#   include <utility>
+#   include "../config/config.h"
+#   include "../core/type_traits.hpp"
+#   include "fwd.hpp"
+#endif // ENTT_MODULE
 
 namespace entt {
 
@@ -41,6 +45,8 @@ template<typename... Class, typename Ret, typename... Args>
 } // namespace internal
 /*! @endcond */
 
+ENTT_MODULE_EXPORT_BEGIN
+
 /**
  * @brief Basic delegate implementation.
  *
@@ -321,6 +327,8 @@ delegate(connect_arg_t<Candidate>, Type &&) -> delegate<std::remove_pointer_t<in
 template<typename Ret, typename... Args>
 delegate(Ret (*)(const void *, Args...), const void * = nullptr) -> delegate<Ret(Args...)>;
 
+ENTT_MODULE_EXPORT_END
+
 } // namespace entt
 
 #endif
diff --git a/src/entt/signal/dispatcher.hpp b/src/entt/signal/dispatcher.hpp
index 42a89481a7..77cf94301b 100644
--- a/src/entt/signal/dispatcher.hpp
+++ b/src/entt/signal/dispatcher.hpp
@@ -1,19 +1,23 @@
 #ifndef ENTT_SIGNAL_DISPATCHER_HPP
 #define ENTT_SIGNAL_DISPATCHER_HPP
 
-#include <cstddef>
-#include <functional>
-#include <memory>
-#include <type_traits>
-#include <utility>
-#include <vector>
-#include "../container/dense_map.hpp"
-#include "../core/compressed_pair.hpp"
-#include "../core/fwd.hpp"
-#include "../core/type_info.hpp"
-#include "../core/utility.hpp"
-#include "fwd.hpp"
-#include "sigh.hpp"
+#include "../config/module.h"
+
+#ifndef ENTT_MODULE
+#   include <cstddef>
+#   include <functional>
+#   include <memory>
+#   include <type_traits>
+#   include <utility>
+#   include <vector>
+#   include "../container/dense_map.hpp"
+#   include "../core/compressed_pair.hpp"
+#   include "../core/fwd.hpp"
+#   include "../core/type_info.hpp"
+#   include "../core/utility.hpp"
+#   include "fwd.hpp"
+#   include "sigh.hpp"
+#endif // ENTT_MODULE
 
 namespace entt {
 
@@ -90,6 +94,8 @@ class dispatcher_handler final: public basic_dispatcher_handler {
 } // namespace internal
 /*! @endcond */
 
+ENTT_MODULE_EXPORT_BEGIN
+
 /**
  * @brief Basic dispatcher implementation.
  *
@@ -392,6 +398,8 @@ class basic_dispatcher {
     compressed_pair<container_type, allocator_type> pools;
 };
 
+ENTT_MODULE_EXPORT_END
+
 } // namespace entt
 
 #endif
diff --git a/src/entt/signal/emitter.hpp b/src/entt/signal/emitter.hpp
index e362b357be..18a6849c6d 100644
--- a/src/entt/signal/emitter.hpp
+++ b/src/entt/signal/emitter.hpp
@@ -1,17 +1,21 @@
 #ifndef ENTT_SIGNAL_EMITTER_HPP
 #define ENTT_SIGNAL_EMITTER_HPP
 
-#include <functional>
-#include <type_traits>
-#include <utility>
-#include "../container/dense_map.hpp"
-#include "../core/compressed_pair.hpp"
-#include "../core/fwd.hpp"
-#include "../core/type_info.hpp"
-#include "../core/utility.hpp"
-#include "fwd.hpp"
-
-namespace entt {
+#include "../config/module.h"
+
+#ifndef ENTT_MODULE
+#   include <functional>
+#   include <type_traits>
+#   include <utility>
+#   include "../container/dense_map.hpp"
+#   include "../core/compressed_pair.hpp"
+#   include "../core/fwd.hpp"
+#   include "../core/type_info.hpp"
+#   include "../core/utility.hpp"
+#   include "fwd.hpp"
+#endif // ENTT_MODULE
+
+ENTT_MODULE_EXPORT namespace entt {
 
 /**
  * @brief General purpose event emitter.
diff --git a/src/entt/signal/fwd.hpp b/src/entt/signal/fwd.hpp
index b0964b6810..130c610ba6 100644
--- a/src/entt/signal/fwd.hpp
+++ b/src/entt/signal/fwd.hpp
@@ -1,9 +1,13 @@
 #ifndef ENTT_SIGNAL_FWD_HPP
 #define ENTT_SIGNAL_FWD_HPP
 
-#include <memory>
+#include "../config/module.h"
 
-namespace entt {
+#ifndef ENTT_MODULE
+#    include <memory>
+#endif // ENTT_MODULE
+
+ENTT_MODULE_EXPORT namespace entt {
 
 template<typename>
 class delegate;
diff --git a/src/entt/signal/sigh.hpp b/src/entt/signal/sigh.hpp
index 732f63be1d..0f839ee326 100644
--- a/src/entt/signal/sigh.hpp
+++ b/src/entt/signal/sigh.hpp
@@ -1,15 +1,19 @@
 #ifndef ENTT_SIGNAL_SIGH_HPP
 #define ENTT_SIGNAL_SIGH_HPP
 
-#include <cstddef>
-#include <memory>
-#include <type_traits>
-#include <utility>
-#include <vector>
-#include "delegate.hpp"
-#include "fwd.hpp"
+#include "../config/module.h"
 
-namespace entt {
+#ifndef ENTT_MODULE
+#   include <cstddef>
+#   include <memory>
+#   include <type_traits>
+#   include <utility>
+#   include <vector>
+#   include "delegate.hpp"
+#   include "fwd.hpp"
+#endif // ENTT_MODULE
+
+ENTT_MODULE_EXPORT namespace entt {
 
 /**
  * @brief Sink class.
@@ -52,7 +56,7 @@ class sigh;
  */
 template<typename Ret, typename... Args, typename Allocator>
 class sigh<Ret(Args...), Allocator> {
-    friend class sink<sigh<Ret(Args...), Allocator>>;
+    friend class entt::sink<sigh<Ret(Args...), Allocator>>;
 
     using alloc_traits = std::allocator_traits<Allocator>;
     using delegate_type = delegate<Ret(Args...)>;
@@ -228,7 +232,7 @@ class sigh<Ret(Args...), Allocator> {
  */
 class connection {
     template<typename>
-    friend class sink;
+    friend class entt::sink;
 
     connection(delegate<void(void *)> fn, void *ref)
         : disconnect{fn}, signal{ref} {}