diff --git a/.idea/editor.xml b/.idea/editor.xml
index fde53486..373c50fc 100644
--- a/.idea/editor.xml
+++ b/.idea/editor.xml
@@ -201,7 +201,7 @@
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppStaticDataMemberInUnnamedStruct/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppStaticSpecifierOnAnonymousNamespaceMember/@EntryIndexedValue" value="SUGGESTION" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppStringLiteralToCharPointerConversion/@EntryIndexedValue" value="WARNING" type="string" />
-    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppTabsAreDisallowed/@EntryIndexedValue" value="WARNING" type="string" />
+    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppTabsAreDisallowed/@EntryIndexedValue" value="DO_NOT_SHOW" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppTemplateArgumentsCanBeDeduced/@EntryIndexedValue" value="HINT" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppTemplateParameterNeverUsed/@EntryIndexedValue" value="HINT" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppTemplateParameterShadowing/@EntryIndexedValue" value="WARNING" type="string" />
@@ -215,7 +215,7 @@
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUnmatchedPragmaEndRegionDirective/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUnmatchedPragmaRegionDirective/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUnnamedNamespaceInHeaderFile/@EntryIndexedValue" value="WARNING" type="string" />
-    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUnnecessaryWhitespace/@EntryIndexedValue" value="WARNING" type="string" />
+    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUnnecessaryWhitespace/@EntryIndexedValue" value="DO_NOT_SHOW" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUnsignedZeroComparison/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUnusedIncludeDirective/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUseAlgorithmWithCount/@EntryIndexedValue" value="SUGGESTION" type="string" />
diff --git a/CMakeLists.txt b/CMakeLists.txt
index f2ebbed8..4758a70a 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,9 +1,9 @@
-cmake_minimum_required(VERSION 3.26)
+cmake_minimum_required(VERSION 3.31)
 
 project(omath VERSION 3.5.0 LANGUAGES CXX)
 
 include(CMakePackageConfigHelpers)
-
+include(GNUInstallDirs)
 
 option(OMATH_BUILD_TESTS "Build unit tests" ${PROJECT_IS_TOP_LEVEL})
 option(OMATH_THREAT_WARNING_AS_ERROR "Set highest level of warnings and force compiler to treat them as errors" ON)
@@ -13,7 +13,7 @@ option(OMATH_IMGUI_INTEGRATION "Omath will define method to convert omath types
 option(OMATH_BUILD_EXAMPLES "Build example projects with you can learn & play" OFF)
 option(OMATH_STATIC_MSVC_RUNTIME_LIBRARY "Force Omath to link static runtime" OFF)
 option(OMATH_SUPRESS_SAFETY_CHECKS "Supress some safety checks in release build to improve general performance" ON)
-option(OMATH_USE_UNITY_BUILD "Will enable unity build to speed up compilation" ON)
+option(OMATH_USE_UNITY_BUILD "Will enable unity build to speed up compilation" OFF)
 option(OMATH_ENABLE_LEGACY "Will enable legacy classes that MUST be used ONLY for backward compatibility" OFF)
 
 message(STATUS "[${PROJECT_NAME}]: Building on ${CMAKE_HOST_SYSTEM_NAME}")
@@ -27,16 +27,21 @@ message(STATUS "[${PROJECT_NAME}]: AVX2 feature status ${OMATH_USE_AVX2}")
 message(STATUS "[${PROJECT_NAME}]: ImGUI integration feature status ${OMATH_IMGUI_INTEGRATION}")
 message(STATUS "[${PROJECT_NAME}]: Legacy features support ${OMATH_ENABLE_LEGACY}")
 
-file(GLOB_RECURSE OMATH_SOURCES CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/source/*.cpp")
-file(GLOB_RECURSE OMATH_HEADERS CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/include/*.hpp")
+file(GLOB_RECURSE OMATH_MODULES CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/modules/*.ixx")
 
 
 if (OMATH_BUILD_AS_SHARED_LIBRARY)
-    add_library(${PROJECT_NAME} SHARED ${OMATH_SOURCES} ${OMATH_HEADERS})
+    add_library(${PROJECT_NAME} SHARED)
 else ()
-    add_library(${PROJECT_NAME} STATIC ${OMATH_SOURCES} ${OMATH_HEADERS})
+    add_library(${PROJECT_NAME} STATIC)
 endif ()
 
+target_sources(${PROJECT_NAME}
+        PUBLIC
+        FILE_SET cxx_modules TYPE CXX_MODULES
+        BASE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/modules
+        FILES ${OMATH_MODULES}
+)
 add_library(${PROJECT_NAME}::${PROJECT_NAME} ALIAS ${PROJECT_NAME})
 
 target_compile_definitions(${PROJECT_NAME} PUBLIC OMATH_VERSION="${PROJECT_VERSION}")
@@ -132,6 +137,8 @@ install(TARGETS ${PROJECT_NAME}
         ARCHIVE DESTINATION lib COMPONENT ${PROJECT_NAME}   # For static libraries
         LIBRARY DESTINATION lib COMPONENT ${PROJECT_NAME}   # For shared libraries
         RUNTIME DESTINATION bin COMPONENT ${PROJECT_NAME}   # For executables (on Windows)
+        FILE_SET cxx_modules DESTINATION ${CMAKE_INSTALL_DATADIR}/${PROJECT_NAME}/modules
+        CXX_MODULES_BMI DESTINATION ${CMAKE_INSTALL_LIBDIR}/cxx/bmi
 )
 
 # Install headers as part of omath_component
@@ -142,6 +149,7 @@ install(EXPORT ${PROJECT_NAME}Targets
         FILE ${PROJECT_NAME}Targets.cmake
         NAMESPACE ${PROJECT_NAME}::
         DESTINATION lib/cmake/${PROJECT_NAME} COMPONENT ${PROJECT_NAME}
+        CXX_MODULES_DIRECTORY ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}/cxx-modules
 )
 
 
diff --git a/examples/example_proj_mat_builder.cpp b/examples/example_proj_mat_builder.cpp
index 5857e373..172efcea 100644
--- a/examples/example_proj_mat_builder.cpp
+++ b/examples/example_proj_mat_builder.cpp
@@ -5,7 +5,8 @@
 
 #include <iostream>
 #include <print>
-#include <omath/engines/opengl_engine/formulas.hpp>
+#include <sstream>
+import omath.opengl_engine.formulas;
 
 
 int main()
@@ -36,5 +37,5 @@ int main()
     const auto mat =
             omath::opengl_engine::calc_perspective_projection_matrix(fov, view_port_width / view_port_height, near, far);
 
-    std::print("{}", mat.to_string());
+    std::print("{}", mat);
 };
diff --git a/include/omath/3d_primitives/box.hpp b/include/omath/3d_primitives/box.hpp
deleted file mode 100644
index 3abb9a44..00000000
--- a/include/omath/3d_primitives/box.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-//
-// Created by Vlad on 4/18/2025.
-//
-
-#pragma once
-#include "omath/linear_algebra/vector3.hpp"
-#include "omath/triangle.hpp"
-#include <array>
-
-namespace omath::primitives
-{
-    [[nodiscard]]
-    std::array<Triangle<Vector3<float>>, 12> create_box(const Vector3<float>& top, const Vector3<float>& bottom,
-                                             const Vector3<float>& dir_forward, const Vector3<float>& dir_right,
-                                             float ratio = 4.f) noexcept;
-}
diff --git a/include/omath/3d_primitives/plane.hpp b/include/omath/3d_primitives/plane.hpp
deleted file mode 100644
index 39c0f2c4..00000000
--- a/include/omath/3d_primitives/plane.hpp
+++ /dev/null
@@ -1,16 +0,0 @@
-//
-// Created by Vlad on 8/28/2025.
-//
-
-#pragma once
-#include "omath/linear_algebra/vector3.hpp"
-#include "omath/triangle.hpp"
-#include <array>
-
-namespace omath::primitives
-{
-    [[nodiscard]]
-    std::array<Triangle<Vector3<float>>, 2> create_plane(const Vector3<float>& vertex_a,
-                                                          const Vector3<float>& vertex_b,
-                                                          const Vector3<float>& direction, float size) noexcept;
-}
diff --git a/include/omath/angles.hpp b/include/omath/angles.hpp
deleted file mode 100644
index ce07dd83..00000000
--- a/include/omath/angles.hpp
+++ /dev/null
@@ -1,64 +0,0 @@
-//
-// Created by vlad on 11/6/23.
-//
-
-#pragma once
-#include <cmath>
-#include <numbers>
-
-namespace omath::angles
-{
-    template<class Type>
-    requires std::is_floating_point_v<Type>
-    [[nodiscard]] constexpr Type radians_to_degrees(const Type& radians) noexcept
-    {
-        return radians * (static_cast<Type>(180) / std::numbers::pi_v<Type>);
-    }
-
-    template<class Type>
-    requires std::is_floating_point_v<Type>
-    [[nodiscard]] constexpr Type degrees_to_radians(const Type& degrees) noexcept
-    {
-        return degrees * (std::numbers::pi_v<Type> / static_cast<Type>(180));
-    }
-
-    template<class Type>
-    requires std::is_floating_point_v<Type>
-    [[nodiscard]] Type horizontal_fov_to_vertical(const Type& horizontal_fov, const Type& aspect) noexcept
-    {
-        const auto fov_rad = degrees_to_radians(horizontal_fov);
-
-        const auto vert_fov = static_cast<Type>(2) * std::atan(std::tan(fov_rad / static_cast<Type>(2)) / aspect);
-
-        return radians_to_degrees(vert_fov);
-    }
-
-    template<class Type>
-    requires std::is_floating_point_v<Type>
-    [[nodiscard]] Type vertical_fov_to_horizontal(const Type& vertical_fov, const Type& aspect) noexcept
-    {
-        const auto fov_as_radians = degrees_to_radians(vertical_fov);
-
-        const auto horizontal_fov =
-                static_cast<Type>(2) * std::atan(std::tan(fov_as_radians / static_cast<Type>(2)) * aspect);
-
-        return radians_to_degrees(horizontal_fov);
-    }
-
-    template<class Type>
-    requires std::is_arithmetic_v<Type>
-    [[nodiscard]] Type wrap_angle(const Type& angle, const Type& min, const Type& max) noexcept
-    {
-        if (angle <= max && angle >= min)
-            return angle;
-
-        const Type range = max - min;
-
-        Type wrapped_angle = std::fmod(angle - min, range);
-
-        if (wrapped_angle < 0)
-            wrapped_angle += range;
-
-        return wrapped_angle + min;
-    }
-} // namespace omath::angles
diff --git a/include/omath/collision/line_tracer.hpp b/include/omath/collision/line_tracer.hpp
deleted file mode 100644
index f2c16275..00000000
--- a/include/omath/collision/line_tracer.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-//
-// Created by Orange on 11/13/2024.
-//
-#pragma once
-
-#include "omath/linear_algebra/vector3.hpp"
-#include "omath/triangle.hpp"
-
-namespace omath::collision
-{
-    class Ray
-    {
-    public:
-        Vector3<float> start;
-        Vector3<float> end;
-        bool infinite_length = false;
-
-        [[nodiscard]]
-        Vector3<float> direction_vector() const noexcept;
-
-        [[nodiscard]]
-        Vector3<float> direction_vector_normalized() const noexcept;
-    };
-    class LineTracer
-    {
-    public:
-        LineTracer() = delete;
-
-        [[nodiscard]]
-        static bool can_trace_line(const Ray& ray, const Triangle<Vector3<float>>& triangle) noexcept;
-
-        // Realization of Möller–Trumbore intersection algorithm
-        // https://en.wikipedia.org/wiki/M%C3%B6ller%E2%80%93Trumbore_intersection_algorithm
-        [[nodiscard]]
-        static Vector3<float> get_ray_hit_point(const Ray& ray, const Triangle<Vector3<float>>& triangle) noexcept;
-    };
-} // namespace omath::collision
diff --git a/include/omath/engines/iw_engine/camera.hpp b/include/omath/engines/iw_engine/camera.hpp
deleted file mode 100644
index 2efe29b1..00000000
--- a/include/omath/engines/iw_engine/camera.hpp
+++ /dev/null
@@ -1,13 +0,0 @@
-//
-// Created by Vlad on 3/17/2025.
-//
-
-#pragma once
-#include "omath/engines/iw_engine/constants.hpp"
-#include "omath/projection/camera.hpp"
-#include "traits/camera_trait.hpp"
-
-namespace omath::iw_engine
-{
-    using Camera =  projection::Camera<Mat4X4, ViewAngles, CameraTrait>;
-} // namespace omath::iw_engine
\ No newline at end of file
diff --git a/include/omath/engines/iw_engine/formulas.hpp b/include/omath/engines/iw_engine/formulas.hpp
deleted file mode 100644
index 433987da..00000000
--- a/include/omath/engines/iw_engine/formulas.hpp
+++ /dev/null
@@ -1,26 +0,0 @@
-//
-// Created by Vlad on 3/17/2025.
-//
-
-#pragma once
-#include "omath/engines/iw_engine/constants.hpp"
-
-namespace omath::iw_engine
-{
-    [[nodiscard]]
-    Vector3<float> forward_vector(const ViewAngles& angles) noexcept;
-
-    [[nodiscard]]
-    Vector3<float> right_vector(const ViewAngles& angles) noexcept;
-
-    [[nodiscard]]
-    Vector3<float> up_vector(const ViewAngles& angles) noexcept;
-
-    [[nodiscard]]
-    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept;
-
-    [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
-
-    [[nodiscard]]
-    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far) noexcept;
-} // namespace omath::iw_engine
diff --git a/include/omath/engines/iw_engine/traits/camera_trait.hpp b/include/omath/engines/iw_engine/traits/camera_trait.hpp
deleted file mode 100644
index 88c21569..00000000
--- a/include/omath/engines/iw_engine/traits/camera_trait.hpp
+++ /dev/null
@@ -1,24 +0,0 @@
-//
-// Created by Vlad on 8/10/2025.
-//
-
-#pragma once
-#include "omath/engines/iw_engine/constants.hpp"
-#include "omath/projection/camera.hpp"
-
-namespace omath::iw_engine
-{
-    class CameraTrait final
-    {
-    public:
-        [[nodiscard]]
-        static ViewAngles calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept;
-
-        [[nodiscard]]
-        static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
-        [[nodiscard]]
-        static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port,
-                                             float near, float far) noexcept;
-    };
-
-} // namespace omath::iw_engine
\ No newline at end of file
diff --git a/include/omath/engines/opengl_engine/camera.hpp b/include/omath/engines/opengl_engine/camera.hpp
deleted file mode 100644
index e69ee340..00000000
--- a/include/omath/engines/opengl_engine/camera.hpp
+++ /dev/null
@@ -1,12 +0,0 @@
-//
-// Created by Orange on 12/23/2024.
-//
-#pragma once
-#include "omath/engines/opengl_engine/constants.hpp"
-#include "omath/projection/camera.hpp"
-#include "traits/camera_trait.hpp"
-
-namespace omath::opengl_engine
-{
-    using Camera =  projection::Camera<Mat4X4, ViewAngles, CameraTrait>;
-} // namespace omath::opengl_engine
\ No newline at end of file
diff --git a/include/omath/engines/opengl_engine/formulas.hpp b/include/omath/engines/opengl_engine/formulas.hpp
deleted file mode 100644
index 31714f56..00000000
--- a/include/omath/engines/opengl_engine/formulas.hpp
+++ /dev/null
@@ -1,26 +0,0 @@
-//
-// Created by Orange on 12/23/2024.
-//
-#pragma once
-#include "omath/engines/opengl_engine/constants.hpp"
-
-
-namespace omath::opengl_engine
-{
-    [[nodiscard]]
-    Vector3<float> forward_vector(const ViewAngles& angles) noexcept;
-
-    [[nodiscard]]
-    Vector3<float> right_vector(const ViewAngles& angles) noexcept;
-
-    [[nodiscard]]
-    Vector3<float> up_vector(const ViewAngles& angles) noexcept;
-
-    [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
-
-    [[nodiscard]]
-    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept;
-
-    [[nodiscard]]
-    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far) noexcept;
-} // namespace omath::opengl_engine
diff --git a/include/omath/engines/opengl_engine/traits/camera_trait.hpp b/include/omath/engines/opengl_engine/traits/camera_trait.hpp
deleted file mode 100644
index 3fb57c07..00000000
--- a/include/omath/engines/opengl_engine/traits/camera_trait.hpp
+++ /dev/null
@@ -1,24 +0,0 @@
-//
-// Created by Vlad on 8/10/2025.
-//
-
-#pragma once
-#include "omath/engines/opengl_engine/constants.hpp"
-#include "omath/projection/camera.hpp"
-
-namespace omath::opengl_engine
-{
-    class CameraTrait final
-    {
-    public:
-        [[nodiscard]]
-        static ViewAngles calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept;
-
-        [[nodiscard]]
-        static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
-        [[nodiscard]]
-        static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port,
-                                             float near, float far) noexcept;
-    };
-
-} // namespace omath::opengl_engine
\ No newline at end of file
diff --git a/include/omath/engines/source_engine/camera.hpp b/include/omath/engines/source_engine/camera.hpp
deleted file mode 100644
index 6769d40d..00000000
--- a/include/omath/engines/source_engine/camera.hpp
+++ /dev/null
@@ -1,11 +0,0 @@
-//
-// Created by Orange on 12/4/2024.
-//
-#pragma once
-#include "omath/engines/source_engine/constants.hpp"
-#include "omath/projection/camera.hpp"
-#include "traits/camera_trait.hpp"
-namespace omath::source_engine
-{
-    using Camera =  projection::Camera<Mat4X4, ViewAngles, CameraTrait>;
-} // namespace omath::source_engine
\ No newline at end of file
diff --git a/include/omath/engines/source_engine/formulas.hpp b/include/omath/engines/source_engine/formulas.hpp
deleted file mode 100644
index a51a6333..00000000
--- a/include/omath/engines/source_engine/formulas.hpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-// Created by Orange on 12/4/2024.
-//
-#pragma once
-#include "omath/engines/source_engine/constants.hpp"
-
-namespace omath::source_engine
-{
-    [[nodiscard]]
-    Vector3<float> forward_vector(const ViewAngles& angles) noexcept;
-
-    [[nodiscard]]
-    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept;
-
-    [[nodiscard]]
-    Vector3<float> right_vector(const ViewAngles& angles) noexcept;
-
-    [[nodiscard]]
-    Vector3<float> up_vector(const ViewAngles& angles) noexcept;
-
-    [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
-
-    [[nodiscard]]
-    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far) noexcept;
-} // namespace omath::source_engine
diff --git a/include/omath/engines/source_engine/traits/camera_trait.hpp b/include/omath/engines/source_engine/traits/camera_trait.hpp
deleted file mode 100644
index d027d25e..00000000
--- a/include/omath/engines/source_engine/traits/camera_trait.hpp
+++ /dev/null
@@ -1,24 +0,0 @@
-//
-// Created by Vlad on 8/10/2025.
-//
-
-#pragma once
-#include "omath/engines/source_engine/constants.hpp"
-#include "omath/projection/camera.hpp"
-
-namespace omath::source_engine
-{
-    class CameraTrait final
-    {
-    public:
-        [[nodiscard]]
-        static ViewAngles calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept;
-
-        [[nodiscard]]
-        static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
-        [[nodiscard]]
-        static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port,
-                                             float near, float far) noexcept;
-    };
-
-} // namespace omath::source_engine
\ No newline at end of file
diff --git a/include/omath/engines/unity_engine/camera.hpp b/include/omath/engines/unity_engine/camera.hpp
deleted file mode 100644
index 642290a3..00000000
--- a/include/omath/engines/unity_engine/camera.hpp
+++ /dev/null
@@ -1,13 +0,0 @@
-//
-// Created by Vlad on 3/22/2025.
-//
-
-#pragma once
-#include "omath/engines/unity_engine/constants.hpp"
-#include "omath/projection/camera.hpp"
-#include "traits/camera_trait.hpp"
-
-namespace omath::unity_engine
-{
-    using Camera =  projection::Camera<Mat4X4, ViewAngles, CameraTrait>;
-} // namespace omath::unity_engine
\ No newline at end of file
diff --git a/include/omath/engines/unity_engine/formulas.hpp b/include/omath/engines/unity_engine/formulas.hpp
deleted file mode 100644
index be071367..00000000
--- a/include/omath/engines/unity_engine/formulas.hpp
+++ /dev/null
@@ -1,26 +0,0 @@
-//
-// Created by Vlad on 3/22/2025.
-//
-
-#pragma once
-#include "omath/engines/unity_engine/constants.hpp"
-
-namespace omath::unity_engine
-{
-    [[nodiscard]]
-    Vector3<float> forward_vector(const ViewAngles& angles) noexcept;
-
-    [[nodiscard]]
-    Vector3<float> right_vector(const ViewAngles& angles) noexcept;
-
-    [[nodiscard]]
-    Vector3<float> up_vector(const ViewAngles& angles) noexcept;
-
-    [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
-
-    [[nodiscard]]
-    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept;
-
-    [[nodiscard]]
-    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far) noexcept;
-} // namespace omath::unity_engine
diff --git a/include/omath/engines/unity_engine/traits/camera_trait.hpp b/include/omath/engines/unity_engine/traits/camera_trait.hpp
deleted file mode 100644
index 2d98b9db..00000000
--- a/include/omath/engines/unity_engine/traits/camera_trait.hpp
+++ /dev/null
@@ -1,24 +0,0 @@
-//
-// Created by Vlad on 8/10/2025.
-//
-
-#pragma once
-#include "omath/engines/unity_engine/formulas.hpp"
-#include "omath/projection/camera.hpp"
-
-namespace omath::unity_engine
-{
-    class CameraTrait final
-    {
-    public:
-        [[nodiscard]]
-        static ViewAngles calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept;
-
-        [[nodiscard]]
-        static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
-        [[nodiscard]]
-        static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port,
-                                             float near, float far) noexcept;
-    };
-
-} // namespace omath::unity_engine
\ No newline at end of file
diff --git a/include/omath/engines/unreal_engine/camera.hpp b/include/omath/engines/unreal_engine/camera.hpp
deleted file mode 100644
index 30d5daf5..00000000
--- a/include/omath/engines/unreal_engine/camera.hpp
+++ /dev/null
@@ -1,13 +0,0 @@
-//
-// Created by Vlad on 3/22/2025.
-//
-
-#pragma once
-#include "omath/engines/unreal_engine/constants.hpp"
-#include "omath/projection/camera.hpp"
-#include "traits/camera_trait.hpp"
-
-namespace omath::unreal_engine
-{
-    using Camera = projection::Camera<Mat4X4, ViewAngles, CameraTrait>;
-} // namespace omath::unreal_engine
\ No newline at end of file
diff --git a/include/omath/engines/unreal_engine/formulas.hpp b/include/omath/engines/unreal_engine/formulas.hpp
deleted file mode 100644
index 4e601ce8..00000000
--- a/include/omath/engines/unreal_engine/formulas.hpp
+++ /dev/null
@@ -1,26 +0,0 @@
-//
-// Created by Vlad on 3/22/2025.
-//
-
-#pragma once
-#include "omath/engines/unreal_engine/constants.hpp"
-
-namespace omath::unreal_engine
-{
-    [[nodiscard]]
-    Vector3<float> forward_vector(const ViewAngles& angles) noexcept;
-
-    [[nodiscard]]
-    Vector3<float> right_vector(const ViewAngles& angles) noexcept;
-
-    [[nodiscard]]
-    Vector3<float> up_vector(const ViewAngles& angles) noexcept;
-
-    [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
-
-    [[nodiscard]]
-    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept;
-
-    [[nodiscard]]
-    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far) noexcept;
-} // namespace omath::unreal_engine
diff --git a/include/omath/engines/unreal_engine/traits/camera_trait.hpp b/include/omath/engines/unreal_engine/traits/camera_trait.hpp
deleted file mode 100644
index f2de27e4..00000000
--- a/include/omath/engines/unreal_engine/traits/camera_trait.hpp
+++ /dev/null
@@ -1,24 +0,0 @@
-//
-// Created by Vlad on 8/10/2025.
-//
-
-#pragma once
-#include "omath/engines/unreal_engine/formulas.hpp"
-#include "omath/projection/camera.hpp"
-
-namespace omath::unreal_engine
-{
-    class CameraTrait final
-    {
-    public:
-        [[nodiscard]]
-        static ViewAngles calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept;
-
-        [[nodiscard]]
-        static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
-        [[nodiscard]]
-        static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port,
-                                             float near, float far) noexcept;
-    };
-
-} // namespace omath::unreal_engine
\ No newline at end of file
diff --git a/include/omath/linear_algebra/matrix.hpp b/include/omath/linear_algebra/matrix.hpp
deleted file mode 100644
index 32e9a87f..00000000
--- a/include/omath/linear_algebra/matrix.hpp
+++ /dev/null
@@ -1,127 +0,0 @@
-#pragma once
-
-/*
-THIS CODE IS DEPRECATED NEVER EVER USE Matrix CLASS
-AND VERY SLOW USE Mat INSTEAD!!!!!!!!!!!
-⠛⠛⣿⣿⣿⣿⣿⡷⢶⣦⣶⣶⣤⣤⣤⣀⠀⠀⠀
-⠀⠀⠀⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⡀⠀
-⠀⠀⠀⠉⠉⠉⠙⠻⣿⣿⠿⠿⠛⠛⠛⠻⣿⣿⣇⠀
-⠀⠀⢤⣀⣀⣀⠀⠀⢸⣷⡄⠀⣁⣀⣤⣴⣿⣿⣿⣆
-⠀⠀⠀⠀⠹⠏⠀⠀⠀⣿⣧⠀⠹⣿⣿⣿⣿⣿⡿⣿
-⠀⠀⠀⠀⠀⠀⠀⠀⠀⠛⠿⠇⢀⣼⣿⣿⠛⢯⡿⡟
-⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠦⠴⢿⢿⣿⡿⠷⠀⣿⠀
-⠀⠀⠀⠀⠀⠀⠀⠙⣷⣶⣶⣤⣤⣤⣤⣤⣶⣦⠃⠀
-⠀⠀⠀⠀⠀⠀⠀⢐⣿⣾⣿⣿⣿⣿⣿⣿⣿⣿⠀⠀
-⠀⠀⠀⠀⠀⠀⠀⠈⣿⣿⣿⣿⣿⣿⣿⣿⣿⡇⠀⠀
-⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⠻⢿⣿⣿⣿⣿⠟⠁
-*/
-
-#ifdef OMATH_ENABLE_LEGACY
-#include "omath/vector3.hpp"
-#include <initializer_list>
-#include <memory>
-#include <string>
-
-namespace omath
-{
-
-    class Matrix final
-    {
-    public:
-        Matrix();
-        Matrix(size_t rows, size_t columns);
-
-        Matrix(const std::initializer_list<std::initializer_list<float>>& rows);
-
-        [[nodiscard]]
-        static Matrix to_screen_matrix(float screen_width, float screen_height);
-
-        [[nodiscard]]
-        static Matrix translation_matrix(const Vector3<float>& diff);
-
-        [[nodiscard]]
-        static Matrix orientation_matrix(const Vector3<float>& forward, const Vector3<float>& right,
-                                         const Vector3<float>& up);
-
-        [[nodiscard]]
-        static Matrix projection_matrix(float field_of_view, float aspect_ratio, float near, float far);
-
-        Matrix(const Matrix& other);
-
-        Matrix(size_t rows, size_t columns, const float* raw_data);
-
-        Matrix(Matrix&& other) noexcept;
-
-        [[nodiscard]]
-        size_t row_count() const noexcept;
-
-        [[nodiscard]]
-        float& operator[](size_t row, size_t column);
-
-        [[nodiscard]]
-        size_t columns_count() const noexcept;
-
-        [[nodiscard]]
-        std::pair<size_t, size_t> size() const noexcept;
-
-        [[nodiscard]]
-        float& at(size_t row, size_t col);
-
-        [[nodiscard]]
-        float sum();
-
-        void set_data_from_raw(const float* raw_matrix);
-
-        [[nodiscard]]
-        Matrix transpose() const;
-
-        void set(float val);
-
-        [[nodiscard]]
-        const float& at(size_t row, size_t col) const;
-
-        Matrix operator*(const Matrix& other) const;
-
-        Matrix& operator*=(const Matrix& other);
-
-        Matrix operator*(float f) const;
-
-        Matrix& operator*=(float f);
-
-        Matrix& operator/=(float f);
-
-        void clear();
-
-        [[nodiscard]]
-        Matrix strip(size_t row, size_t column) const;
-
-        [[nodiscard]]
-        float minor(size_t i, size_t j) const;
-
-        [[nodiscard]]
-        float alg_complement(size_t i, size_t j) const;
-
-        [[nodiscard]]
-        float determinant() const;
-
-        [[nodiscard]]
-        const float* raw() const;
-
-        Matrix& operator=(const Matrix& other);
-
-        Matrix& operator=(Matrix&& other) noexcept;
-
-        Matrix operator/(float f) const;
-
-        [[nodiscard]]
-        std::string to_string() const;
-
-        ~Matrix();
-
-    private:
-        size_t m_rows;
-        size_t m_columns;
-        std::unique_ptr<float[]> m_data;
-    };
-} // namespace omath
-#endif
diff --git a/include/omath/omath.hpp b/include/omath/omath.hpp
deleted file mode 100644
index a867dd17..00000000
--- a/include/omath/omath.hpp
+++ /dev/null
@@ -1,84 +0,0 @@
-//
-// omath.hpp - Main header file that includes all omath library components
-// Created for the omath library
-//
-
-#pragma once
-
-// Basic math utilities
-#include "omath/angles.hpp"
-#include "omath/angle.hpp"
-
-// Vector classes (in dependency order)
-#include "omath/linear_algebra/vector2.hpp"
-#include "omath/linear_algebra/vector4.hpp"
-#include "omath/linear_algebra/vector3.hpp"
-
-// Matrix classes
-#include "linear_algebra/matrix.hpp"
-#include "omath/linear_algebra/mat.hpp"
-
-// Color functionality
-#include "omath/color.hpp"
-
-// Geometric primitives
-#include "omath/triangle.hpp"
-#include "omath/view_angles.hpp"
-
-// 3D primitives
-#include "omath/3d_primitives/box.hpp"
-
-// Collision detection
-#include "omath/collision/line_tracer.hpp"
-
-// Pathfinding algorithms
-#include "omath/pathfinding/a_star.hpp"
-#include "omath/pathfinding/navigation_mesh.hpp"
-
-// Projectile prediction
-#include "omath/projectile_prediction/projectile.hpp"
-#include "omath/projectile_prediction/target.hpp"
-#include "omath/projectile_prediction/proj_pred_engine.hpp"
-#include "omath/projectile_prediction/proj_pred_engine_legacy.hpp"
-#include "omath/projectile_prediction/proj_pred_engine_avx2.hpp"
-
-// Projection functionality
-#include "omath/projection/error_codes.hpp"
-#include "omath/projection/camera.hpp"
-
-// Engine-specific implementations
-
-// IW Engine
-#include "omath/engines/iw_engine/constants.hpp"
-#include "omath/engines/iw_engine/formulas.hpp"
-#include "omath/engines/iw_engine/camera.hpp"
-#include "omath/engines/iw_engine/traits/camera_trait.hpp"
-#include "omath/engines/iw_engine/traits/pred_engine_trait.hpp"
-
-// OpenGL Engine
-#include "omath/engines/opengl_engine/constants.hpp"
-#include "omath/engines/opengl_engine/formulas.hpp"
-#include "omath/engines/opengl_engine/camera.hpp"
-#include "omath/engines/opengl_engine/traits/camera_trait.hpp"
-#include "omath/engines/opengl_engine/traits/pred_engine_trait.hpp"
-
-// Source Engine
-#include "omath/engines/source_engine/constants.hpp"
-#include "omath/engines/source_engine/formulas.hpp"
-#include "omath/engines/source_engine/camera.hpp"
-#include "omath/engines/source_engine/traits/camera_trait.hpp"
-#include "omath/engines/source_engine/traits/pred_engine_trait.hpp"
-
-// Unity Engine
-#include "omath/engines/unity_engine/constants.hpp"
-#include "omath/engines/unity_engine/formulas.hpp"
-#include "omath/engines/unity_engine/camera.hpp"
-#include "omath/engines/unity_engine/traits/camera_trait.hpp"
-#include "omath/engines/unity_engine/traits/pred_engine_trait.hpp"
-
-// Unreal Engine
-#include "omath/engines/unreal_engine/constants.hpp"
-#include "omath/engines/unreal_engine/formulas.hpp"
-#include "omath/engines/unreal_engine/camera.hpp"
-#include "omath/engines/unreal_engine/traits/camera_trait.hpp"
-#include "omath/engines/unreal_engine/traits/pred_engine_trait.hpp"
\ No newline at end of file
diff --git a/include/omath/pathfinding/a_star.hpp b/include/omath/pathfinding/a_star.hpp
deleted file mode 100644
index 218a059c..00000000
--- a/include/omath/pathfinding/a_star.hpp
+++ /dev/null
@@ -1,30 +0,0 @@
-//
-// Created by Vlad on 28.07.2024.
-//
-
-#pragma once
-#include "omath/linear_algebra/vector3.hpp"
-#include "omath/pathfinding/navigation_mesh.hpp"
-#include <vector>
-
-namespace omath::pathfinding
-{
-    struct PathNode;
-    class Astar final
-    {
-    public:
-        [[nodiscard]]
-        static std::vector<Vector3<float>> find_path(const Vector3<float>& start, const Vector3<float>& end,
-                                                     const NavigationMesh& nav_mesh) noexcept;
-
-    private:
-        [[nodiscard]]
-        static std::vector<Vector3<float>>
-        reconstruct_final_path(const std::unordered_map<Vector3<float>, PathNode>& closed_list,
-                               const Vector3<float>& current) noexcept;
-
-        [[nodiscard]]
-        static auto get_perfect_node(const std::unordered_map<Vector3<float>, PathNode>& open_list,
-                                     const Vector3<float>& end_vertex) noexcept;
-    };
-} // namespace omath::pathfinding
diff --git a/include/omath/pathfinding/navigation_mesh.hpp b/include/omath/pathfinding/navigation_mesh.hpp
deleted file mode 100644
index 35cc6e6b..00000000
--- a/include/omath/pathfinding/navigation_mesh.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-//
-// Created by Vlad on 28.07.2024.
-//
-
-#pragma once
-
-#include "omath/linear_algebra/vector3.hpp"
-#include <expected>
-#include <string>
-#include <vector>
-
-namespace omath::pathfinding
-{
-
-    enum Error
-    {
-    };
-
-    class NavigationMesh final
-    {
-    public:
-        [[nodiscard]]
-        std::expected<Vector3<float>, std::string> get_closest_vertex(const Vector3<float>& point) const noexcept;
-
-        [[nodiscard]]
-        const std::vector<Vector3<float>>& get_neighbors(const Vector3<float>& vertex) const noexcept;
-
-        [[nodiscard]]
-        bool empty() const;
-
-        [[nodiscard]] std::vector<uint8_t> serialize() const noexcept;
-
-        void deserialize(const std::vector<uint8_t>& raw) noexcept;
-
-        std::unordered_map<Vector3<float>, std::vector<Vector3<float>>> m_vertex_map;
-    };
-} // namespace omath::pathfinding
diff --git a/include/omath/projectile_prediction/proj_pred_engine_avx2.hpp b/include/omath/projectile_prediction/proj_pred_engine_avx2.hpp
deleted file mode 100644
index e4a7dc51..00000000
--- a/include/omath/projectile_prediction/proj_pred_engine_avx2.hpp
+++ /dev/null
@@ -1,28 +0,0 @@
-//
-// Created by Vlad on 2/23/2025.
-//
-#pragma once
-#include "omath/projectile_prediction/proj_pred_engine.hpp"
-
-namespace omath::projectile_prediction
-{
-    class ProjPredEngineAvx2 final : public ProjPredEngineInterface
-    {
-    public:
-        [[nodiscard]] std::optional<Vector3<float>>
-        maybe_calculate_aim_point(const Projectile& projectile, const Target& target) const override;
-
-        ProjPredEngineAvx2(float gravity_constant, float simulation_time_step, float maximum_simulation_time);
-        ~ProjPredEngineAvx2() override = default;
-
-    private:
-        [[nodiscard]] static std::optional<float> calculate_pitch(const Vector3<float>& proj_origin,
-                                                                  const Vector3<float>& target_pos,
-                                                                  float bullet_gravity, float v0, float time) ;
-
-        // We use [[maybe_unused]] here since AVX2 is not available for ARM and ARM64 CPU
-        [[maybe_unused]] const float m_gravity_constant;
-        [[maybe_unused]] const float m_simulation_time_step;
-        [[maybe_unused]] const float m_maximum_simulation_time;
-    };
-} // namespace omath::projectile_prediction
diff --git a/source/3d_primitives/box.cpp b/modules/3d_primites/box.ixx
similarity index 76%
rename from source/3d_primitives/box.cpp
rename to modules/3d_primites/box.ixx
index 9c251b98..5b840698 100644
--- a/source/3d_primitives/box.cpp
+++ b/modules/3d_primites/box.ixx
@@ -1,13 +1,18 @@
 //
-// Created by Vlad on 4/18/2025.
+// Created by Vlad on 9/1/2025.
 //
-#include "omath/3d_primitives/box.hpp"
+module;
+#include <array>
 
-namespace omath::primitives
+export module omath.box;
+export import omath.triangle;
+
+export namespace omath::primitives
 {
-    std::array<Triangle<Vector3<float>>, 12> create_box(const Vector3<float>& top, const Vector3<float>& bottom,
-                                                        const Vector3<float>& dir_forward,
-                                                        const Vector3<float>& dir_right, const float ratio) noexcept
+    [[nodiscard]]
+    std::array<Triangle<>, 12> create_box(const Vector3<float>& top, const Vector3<float>& bottom,
+                                                    const Vector3<float>& dir_forward, const Vector3<float>& dir_right,
+                                                    const float ratio = 4.f) noexcept
     {
         const auto height = top.distance_to(bottom);
         const auto side_size = height / ratio;
@@ -51,4 +56,4 @@ namespace omath::primitives
 
         return poly;
     }
-} // namespace omath::primitives
+} // namespace omath::primitives
\ No newline at end of file
diff --git a/modules/3d_primites/plane.ixx b/modules/3d_primites/plane.ixx
new file mode 100644
index 00000000..ac9d6ef1
--- /dev/null
+++ b/modules/3d_primites/plane.ixx
@@ -0,0 +1,23 @@
+//
+// Created by Vlad on 9/1/2025.
+//
+module;
+#include <array>
+
+export module omath.plane;
+export import omath.triangle;
+
+export namespace omath::primitives
+{
+    [[nodiscard]]
+    std::array<Triangle<>, 2> create_plane(const Vector3<float>& vertex_a, const Vector3<float>& vertex_b,
+                                           const Vector3<float>& direction, const float size) noexcept
+    {
+        const auto second_vertex_a = vertex_a + direction * size;
+        return std::array
+        {
+            Triangle{second_vertex_a, vertex_a, vertex_b},
+            Triangle{second_vertex_a, vertex_b + direction * size, vertex_b}
+        };
+    }
+}
diff --git a/include/omath/triangle.hpp b/modules/3d_primites/triangle.ixx
similarity index 77%
rename from include/omath/triangle.hpp
rename to modules/3d_primites/triangle.ixx
index 519c48cb..ff1a6cd3 100644
--- a/include/omath/triangle.hpp
+++ b/modules/3d_primites/triangle.ixx
@@ -1,10 +1,13 @@
 //
-// Created by Orange on 11/13/2024.
+// Created by Vlad on 9/1/2025.
 //
-#pragma once
-#include "linear_algebra/vector3.hpp"
+module;
+#include <cmath>
 
-namespace omath
+export module omath.triangle;
+export import omath.vector3;
+
+export namespace omath
 {
     /*
     v1
@@ -16,7 +19,7 @@ namespace omath
       b
     */
 
-    template<class Vector>
+    template<class Vector = Vector3<float>>
     class Triangle final
     {
     public:
@@ -26,12 +29,12 @@ namespace omath
         {
         }
 
-        Vector3<float> m_vertex1;
-        Vector3<float> m_vertex2;
-        Vector3<float> m_vertex3;
+        Vector m_vertex1;
+        Vector m_vertex2;
+        Vector m_vertex3;
 
         [[nodiscard]]
-        constexpr Vector3<float> calculate_normal() const
+        constexpr Vector calculate_normal() const
         {
             const auto b = side_b_vector();
             const auto a = side_a_vector();
@@ -52,7 +55,7 @@ namespace omath
         }
 
         [[nodiscard]]
-        constexpr Vector3<float> side_a_vector() const
+        constexpr Vector side_a_vector() const
         {
             return m_vertex1 - m_vertex2;
         }
@@ -72,12 +75,12 @@ namespace omath
             return std::abs(side_a * side_a + side_b * side_b - hypot_value * hypot_value) <= 0.0001f;
         }
         [[nodiscard]]
-        constexpr Vector3<float> side_b_vector() const
+        constexpr Vector side_b_vector() const
         {
             return m_vertex3 - m_vertex2;
         }
         [[nodiscard]]
-        constexpr Vector3<float> mid_point() const
+        constexpr Vector mid_point() const
         {
             return (m_vertex1 + m_vertex2 + m_vertex3) / 3;
         }
diff --git a/modules/collision/line_tracer.ixx b/modules/collision/line_tracer.ixx
new file mode 100644
index 00000000..48d853a4
--- /dev/null
+++ b/modules/collision/line_tracer.ixx
@@ -0,0 +1,90 @@
+//
+// Created by Vlad on 9/1/2025.
+//
+module;
+
+#include <cmath>
+#include <limits>
+
+export module omath.line_tracer;
+export import omath.triangle;
+
+
+export namespace omath::collision
+{
+    class Ray
+    {
+    public:
+        Vector3<float> start;
+        Vector3<float> end;
+        bool infinite_length = false;
+
+        [[nodiscard]]
+        Vector3<float> direction_vector() const noexcept
+        {
+            return end - start;
+        }
+
+        [[nodiscard]]
+        Vector3<float> direction_vector_normalized() const noexcept
+        {
+            return direction_vector().normalized();
+        }
+    };
+    class LineTracer
+    {
+    public:
+        LineTracer() = delete;
+
+        [[nodiscard]]
+        static bool can_trace_line(const Ray& ray, const Triangle<>& triangle) noexcept
+        {
+            return get_ray_hit_point(ray, triangle) == ray.end;
+        }
+
+        // Realization of Möller–Trumbore intersection algorithm
+        // https://en.wikipedia.org/wiki/M%C3%B6ller%E2%80%93Trumbore_intersection_algorithm
+        [[nodiscard]]
+        static Vector3<float> get_ray_hit_point(const Ray& ray, const Triangle<>& triangle) noexcept
+        {
+            constexpr float k_epsilon = std::numeric_limits<float>::epsilon();
+
+            const auto side_a = triangle.side_a_vector();
+            const auto side_b = triangle.side_b_vector();
+
+            const auto ray_dir = ray.direction_vector();
+
+            const auto p = ray_dir.cross(side_b);
+            const auto det = side_a.dot(p);
+
+            if (std::abs(det) < k_epsilon)
+                return ray.end;
+
+            const auto inv_det = 1.0f / det;
+            const auto t = ray.start - triangle.m_vertex2;
+            const auto u = t.dot(p) * inv_det;
+
+            if ((u < 0 && std::abs(u) > k_epsilon) || (u > 1 && std::abs(u - 1) > k_epsilon))
+                return ray.end;
+
+            const auto q = t.cross(side_a);
+            // ReSharper disable once CppTooWideScopeInitStatement
+            const auto v = ray_dir.dot(q) * inv_det;
+
+            if ((v < 0 && std::abs(v) > k_epsilon) || (u + v > 1 && std::abs(u + v - 1) > k_epsilon))
+                return ray.end;
+
+            const auto t_hit = side_b.dot(q) * inv_det;
+
+            if (ray.infinite_length)
+            {
+                if (t_hit <= k_epsilon)
+                    return ray.end;
+            }
+            else if (t_hit <= k_epsilon || t_hit > 1.0f - k_epsilon)
+                return ray.end;
+
+            return ray.start + ray_dir * t_hit;
+        }
+    };
+} // namespace omath::collision
diff --git a/modules/game_engines/iw_engine/camera.ixx b/modules/game_engines/iw_engine/camera.ixx
new file mode 100644
index 00000000..2c6ac489
--- /dev/null
+++ b/modules/game_engines/iw_engine/camera.ixx
@@ -0,0 +1,15 @@
+//
+// Created by Vlad on 9/1/2025.
+//
+
+export module omath.iw_engine.camera;
+
+import omath.camera;
+import omath.iw_engine.constants;
+import omath.iw_engine.camera_trait;
+
+
+export namespace omath::iw_engine
+{
+    using Camera = projection::Camera<Mat4X4, ViewAngles, CameraTrait>;
+}
\ No newline at end of file
diff --git a/include/omath/engines/iw_engine/constants.hpp b/modules/game_engines/iw_engine/constants.ixx
similarity index 75%
rename from include/omath/engines/iw_engine/constants.hpp
rename to modules/game_engines/iw_engine/constants.ixx
index 63d1177d..a4672584 100644
--- a/include/omath/engines/iw_engine/constants.hpp
+++ b/modules/game_engines/iw_engine/constants.ixx
@@ -1,14 +1,16 @@
 //
-// Created by Vlad on 3/17/2025.
+// Created by Vlad on 9/1/2025.
 //
 
-#pragma once
-#include "omath/linear_algebra/mat.hpp"
-#include "omath/linear_algebra/vector3.hpp"
-#include <omath/angle.hpp>
-#include <omath/view_angles.hpp>
+export module omath.iw_engine.constants;
 
-namespace omath::iw_engine
+import omath.vector3;
+import omath.mat;
+import omath.angle;
+import omath.view_angles;
+
+
+export namespace omath::iw_engine
 {
     constexpr Vector3<float> k_abs_up = {0, 0, 1};
     constexpr Vector3<float> k_abs_right = {0, -1, 0};
diff --git a/source/engines/iw_engine/formulas.cpp b/modules/game_engines/iw_engine/formulas.ixx
similarity index 56%
rename from source/engines/iw_engine/formulas.cpp
rename to modules/game_engines/iw_engine/formulas.ixx
index c346d50c..91d7704a 100644
--- a/source/engines/iw_engine/formulas.cpp
+++ b/modules/game_engines/iw_engine/formulas.ixx
@@ -1,53 +1,70 @@
 //
-// Created by Vlad on 3/19/2025.
+// Created by Vlad on 9/1/2025.
 //
-#include "omath/engines/iw_engine/formulas.hpp"
+module;
 
-namespace omath::iw_engine
+#include <cmath>
+
+export module omath.iw_engine.formulas;
+
+import omath.vector3;
+import omath.iw_engine.constants;
+import omath.mat;
+import omath.angle;
+
+export namespace omath::iw_engine
 {
+    [[nodiscard]]
+    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept
+    {
+        return mat_rotation_axis_z(angles.yaw) * mat_rotation_axis_y(angles.pitch) * mat_rotation_axis_x(angles.roll);
+    }
 
+    [[nodiscard]]
     Vector3<float> forward_vector(const ViewAngles& angles) noexcept
     {
-        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward);
+        {
+            const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward);
 
-        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
+            return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
+        }
     }
 
+    [[nodiscard]]
     Vector3<float> right_vector(const ViewAngles& angles) noexcept
     {
         const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right);
 
         return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
     }
+
+    [[nodiscard]]
     Vector3<float> up_vector(const ViewAngles& angles) noexcept
     {
         const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up);
 
         return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
     }
-    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept
-    {
-        return mat_rotation_axis_z(angles.yaw) * mat_rotation_axis_y(angles.pitch) * mat_rotation_axis_x(angles.roll);
-    }
 
-    Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
+    [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
     {
         return mat_camera_view(forward_vector(angles), right_vector(angles), up_vector(angles), cam_origin);
     }
 
+    [[nodiscard]]
     Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
                                               const float far) noexcept
     {
         // NOTE: Need magic number to fix fov calculation, since IW engine inherit Quake proj matrix calculation
         constexpr auto k_multiply_factor = 0.75f;
 
-        const float fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / 2.f) * k_multiply_factor;
+        const float fov_half_tan = std::tan(degrees_to_radians(field_of_view) / 2.f) * k_multiply_factor;
 
         return {
-                {1.f / (aspect_ratio * fov_half_tan), 0, 0, 0},
-                {0, 1.f / (fov_half_tan), 0, 0},
-                {0, 0, (far + near) / (far - near), -(2.f * far * near) / (far - near)},
-                {0, 0, 1, 0},
-        };
+                    {1.f / (aspect_ratio * fov_half_tan), 0, 0, 0},
+                    {0, 1.f / (fov_half_tan), 0, 0},
+                    {0, 0, (far + near) / (far - near), -(2.f * far * near) / (far - near)},
+                    {0, 0, 1, 0},
+            };
     };
 } // namespace omath::iw_engine
diff --git a/modules/game_engines/iw_engine/traits/camera_trait.ixx b/modules/game_engines/iw_engine/traits/camera_trait.ixx
new file mode 100644
index 00000000..02940afc
--- /dev/null
+++ b/modules/game_engines/iw_engine/traits/camera_trait.ixx
@@ -0,0 +1,42 @@
+//
+// Created by Vlad on 9/1/2025.
+//
+module;
+#include <cmath>
+export module omath.iw_engine.camera_trait;
+
+import omath.iw_engine.constants;
+import omath.vector3;
+import omath.camera;
+import omath.iw_engine.formulas;
+
+export namespace omath::iw_engine
+{
+    class CameraTrait final
+    {
+    public:
+        [[nodiscard]]
+        static ViewAngles calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept
+        {
+            const auto distance = cam_origin.distance_to(look_at);
+            const auto delta = cam_origin - look_at;
+
+            return {PitchAngle::from_radians(-std::asin(delta.z / distance)),
+                    YawAngle::from_radians(std::atan2(delta.y, delta.x)), RollAngle::from_radians(0.f)};
+        }
+
+        [[nodiscard]]
+        static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
+        {
+            return iw_engine::calc_view_matrix(angles, cam_origin);
+        }
+
+        [[nodiscard]]
+        static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port,
+                                             const float near, const float far) noexcept
+        {
+            return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far);
+        }
+    };
+
+} // namespace omath::iw_engine
\ No newline at end of file
diff --git a/include/omath/engines/iw_engine/traits/pred_engine_trait.hpp b/modules/game_engines/iw_engine/traits/pred_engine_trait.ixx
similarity index 83%
rename from include/omath/engines/iw_engine/traits/pred_engine_trait.hpp
rename to modules/game_engines/iw_engine/traits/pred_engine_trait.ixx
index 7961268a..a02b21f5 100644
--- a/include/omath/engines/iw_engine/traits/pred_engine_trait.hpp
+++ b/modules/game_engines/iw_engine/traits/pred_engine_trait.ixx
@@ -1,14 +1,20 @@
 //
-// Created by Vlad on 8/6/2025.
+// Created by Vlad on 9/2/2025.
 //
-#pragma once
-
-#include "omath/engines/iw_engine/formulas.hpp"
-#include "omath/projectile_prediction/projectile.hpp"
-#include "omath/projectile_prediction/target.hpp"
+module;
 #include <optional>
+#include <cmath>
+
+export module omath.iw_engine.pred_engine_trait;
+
+import omath.vector3;
+import omath.iw_engine.formulas;
+import omath.iw_engine.constants;
+import omath.projectile_prediction.projectile;
+import omath.projectile_prediction.target;
+import omath.angle;
 
-namespace omath::iw_engine
+export namespace omath::iw_engine
 {
     class PredEngineTrait final
     {
@@ -54,7 +60,7 @@ namespace omath::iw_engine
                                                          const std::optional<float> projectile_pitch) noexcept
         {
             const auto delta2d = calc_vector_2d_distance(predicted_target_position - projectile.m_origin);
-            const auto height = delta2d * std::tan(angles::degrees_to_radians(projectile_pitch.value()));
+            const auto height = delta2d * std::tan(degrees_to_radians(projectile_pitch.value()));
 
             return {predicted_target_position.x, predicted_target_position.y, projectile.m_origin.z + height};
         }
@@ -66,14 +72,14 @@ namespace omath::iw_engine
             const auto distance = origin.distance_to(view_to);
             const auto delta = view_to - origin;
 
-            return angles::radians_to_degrees(std::asin(delta.z / distance));
+            return radians_to_degrees(std::asin(delta.z / distance));
         }
         [[nodiscard]]
         static float calc_direct_yaw_angle(const Vector3<float>& origin, const Vector3<float>& view_to) noexcept
         {
             const auto delta = view_to - origin;
 
-            return angles::radians_to_degrees(std::atan2(delta.y, delta.x));
+            return radians_to_degrees(std::atan2(delta.y, delta.x));
         };
     };
 } // namespace omath::iw_engine
\ No newline at end of file
diff --git a/modules/game_engines/opengl_engine/camera.ixx b/modules/game_engines/opengl_engine/camera.ixx
new file mode 100644
index 00000000..ee085b44
--- /dev/null
+++ b/modules/game_engines/opengl_engine/camera.ixx
@@ -0,0 +1,14 @@
+//
+// Created by Vlad on 9/2/2025.
+//
+
+export module omath.opengl_engine.camera;
+
+export import omath.camera;
+import omath.opengl_engine.constants;
+import omath.opengl_engine.camera_trait;
+
+export namespace omath::opengl_engine
+{
+    using Camera = projection::Camera<Mat4X4, ViewAngles, CameraTrait>;
+}
\ No newline at end of file
diff --git a/include/omath/engines/opengl_engine/constants.hpp b/modules/game_engines/opengl_engine/constants.ixx
similarity index 75%
rename from include/omath/engines/opengl_engine/constants.hpp
rename to modules/game_engines/opengl_engine/constants.ixx
index 4f5a955a..16c86f29 100644
--- a/include/omath/engines/opengl_engine/constants.hpp
+++ b/modules/game_engines/opengl_engine/constants.ixx
@@ -1,14 +1,15 @@
 //
-// Created by Orange on 12/23/2024.
+// Created by Vlad on 9/2/2025.
 //
-#pragma once
 
-#include "omath/linear_algebra/mat.hpp"
-#include "omath/linear_algebra/vector3.hpp"
-#include <omath/angle.hpp>
-#include <omath/view_angles.hpp>
+export module omath.opengl_engine.constants;
 
-namespace omath::opengl_engine
+import omath.vector3;
+import omath.mat;
+import omath.angle;
+import omath.view_angles;
+
+export namespace omath::opengl_engine
 {
     constexpr Vector3<float> k_abs_up = {0, 1, 0};
     constexpr Vector3<float> k_abs_right = {1, 0, 0};
diff --git a/source/engines/opengl_engine/formulas.cpp b/modules/game_engines/opengl_engine/formulas.ixx
similarity index 66%
rename from source/engines/opengl_engine/formulas.cpp
rename to modules/game_engines/opengl_engine/formulas.ixx
index 4a14ab2f..2570d659 100644
--- a/source/engines/opengl_engine/formulas.cpp
+++ b/modules/game_engines/opengl_engine/formulas.ixx
@@ -1,46 +1,62 @@
 //
-// Created by Vlad on 3/19/2025.
+// Created by Vlad on 9/2/2025.
 //
-#include "omath/engines/opengl_engine/formulas.hpp"
+module;
+#include <cmath>
+export module omath.opengl_engine.formulas;
 
-namespace omath::opengl_engine
+import omath.vector3;
+import omath.opengl_engine.constants;
+import omath.mat;
+import omath.angle;
+
+export namespace omath::opengl_engine
 {
+    [[nodiscard]]
+    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept
+    {
+        return mat_rotation_axis_x<float, MatStoreType::COLUMN_MAJOR>(-angles.pitch)
+               * mat_rotation_axis_y<float, MatStoreType::COLUMN_MAJOR>(-angles.yaw)
+               * mat_rotation_axis_z<float, MatStoreType::COLUMN_MAJOR>(angles.roll);
+    }
 
+    [[nodiscard]]
     Vector3<float> forward_vector(const ViewAngles& angles) noexcept
     {
-        const auto vec
-                = rotation_matrix(angles) * mat_column_from_vector<float, MatStoreType::COLUMN_MAJOR>(k_abs_forward);
+        const auto vec =
+                rotation_matrix(angles) * mat_column_from_vector<float, MatStoreType::COLUMN_MAJOR>(k_abs_forward);
 
         return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
     }
+
+    [[nodiscard]]
     Vector3<float> right_vector(const ViewAngles& angles) noexcept
     {
-        const auto vec
-                = rotation_matrix(angles) * mat_column_from_vector<float, MatStoreType::COLUMN_MAJOR>(k_abs_right);
+        const auto vec =
+                rotation_matrix(angles) * mat_column_from_vector<float, MatStoreType::COLUMN_MAJOR>(k_abs_right);
 
         return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
     }
+
+    [[nodiscard]]
     Vector3<float> up_vector(const ViewAngles& angles) noexcept
     {
         const auto vec = rotation_matrix(angles) * mat_column_from_vector<float, MatStoreType::COLUMN_MAJOR>(k_abs_up);
 
         return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
     }
-    Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
+
+    [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
     {
         return mat_camera_view<float, MatStoreType::COLUMN_MAJOR>(-forward_vector(angles), right_vector(angles),
                                                                   up_vector(angles), cam_origin);
     }
-    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept
-    {
-        return mat_rotation_axis_x<float, MatStoreType::COLUMN_MAJOR>(-angles.pitch)
-               * mat_rotation_axis_y<float, MatStoreType::COLUMN_MAJOR>(-angles.yaw)
-               * mat_rotation_axis_z<float, MatStoreType::COLUMN_MAJOR>(angles.roll);
-    }
+
+    [[nodiscard]]
     Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
                                               const float far) noexcept
     {
-        const float fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / 2.f);
+        const float fov_half_tan = std::tan(degrees_to_radians(field_of_view) / 2.f);
 
         return {
                 {1.f / (aspect_ratio * fov_half_tan), 0, 0, 0},
diff --git a/modules/game_engines/opengl_engine/traits/camera_trait.ixx b/modules/game_engines/opengl_engine/traits/camera_trait.ixx
new file mode 100644
index 00000000..4597e703
--- /dev/null
+++ b/modules/game_engines/opengl_engine/traits/camera_trait.ixx
@@ -0,0 +1,43 @@
+//
+// Created by Vlad on 9/2/2025.
+//
+module;
+#include <cmath>
+
+export module omath.opengl_engine.camera_trait;
+
+import omath.vector3;
+import omath.view_angles;
+import omath.opengl_engine.constants;
+import omath.opengl_engine.formulas;
+import omath.camera;
+
+export namespace omath::opengl_engine
+{
+    class CameraTrait final
+    {
+    public:
+        [[nodiscard]]
+        static ViewAngles calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept
+        {
+            const auto distance = cam_origin.distance_to(look_at);
+            const auto delta = cam_origin - look_at;
+
+            return {PitchAngle::from_radians(-std::asin(delta.y / distance)),
+                    YawAngle::from_radians(std::atan2(delta.z, delta.x)), RollAngle::from_radians(0.f)};
+        }
+
+        [[nodiscard]]
+        static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
+        {
+            return opengl_engine::calc_view_matrix(angles, cam_origin);
+        }
+        [[nodiscard]]
+        static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port,
+                                             float near, float far) noexcept
+        {
+            return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far);
+        }
+    };
+
+} // namespace omath::opengl_engine
\ No newline at end of file
diff --git a/include/omath/engines/opengl_engine/traits/pred_engine_trait.hpp b/modules/game_engines/opengl_engine/traits/pred_engine_trait.ixx
similarity index 84%
rename from include/omath/engines/opengl_engine/traits/pred_engine_trait.hpp
rename to modules/game_engines/opengl_engine/traits/pred_engine_trait.ixx
index 9c014ff8..19969e17 100644
--- a/include/omath/engines/opengl_engine/traits/pred_engine_trait.hpp
+++ b/modules/game_engines/opengl_engine/traits/pred_engine_trait.ixx
@@ -1,11 +1,18 @@
 //
-// Created by Vlad on 8/6/2025.
+// Created by Vlad on 9/2/2025.
 //
-#pragma once
-#include "omath/engines/opengl_engine/formulas.hpp"
-#include "omath/projectile_prediction/projectile.hpp"
-#include "omath/projectile_prediction/target.hpp"
+module;
 #include <optional>
+#include <cmath>
+
+export module omath.opengl_engine.pred_engine_trait;
+
+import omath.opengl_engine.formulas;
+import omath.opengl_engine.constants;
+import omath.vector3;
+import omath.projectile_prediction.projectile;
+import omath.projectile_prediction.target;
+import omath.angle;
 
 namespace omath::opengl_engine
 {
@@ -53,7 +60,7 @@ namespace omath::opengl_engine
                                                          const std::optional<float> projectile_pitch) noexcept
         {
             const auto delta2d = calc_vector_2d_distance(predicted_target_position - projectile.m_origin);
-            const auto height = delta2d * std::tan(angles::degrees_to_radians(projectile_pitch.value()));
+            const auto height = delta2d * std::tan(degrees_to_radians(projectile_pitch.value()));
 
             return {predicted_target_position.x, predicted_target_position.y + height, projectile.m_origin.z};
         }
@@ -65,14 +72,14 @@ namespace omath::opengl_engine
             const auto distance = origin.distance_to(view_to);
             const auto delta = view_to - origin;
 
-            return angles::radians_to_degrees(std::asin(delta.y / distance));
+            return radians_to_degrees(std::asin(delta.y / distance));
         }
         [[nodiscard]]
         static float calc_direct_yaw_angle(const Vector3<float>& origin, const Vector3<float>& view_to) noexcept
         {
             const auto delta = view_to - origin;
 
-            return angles::radians_to_degrees(std::atan2(delta.z, delta.x));
+            return radians_to_degrees(std::atan2(delta.z, delta.x));
         };
     };
-} // namespace omath::opengl_engine
+}
\ No newline at end of file
diff --git a/modules/game_engines/source_engine/camera.ixx b/modules/game_engines/source_engine/camera.ixx
new file mode 100644
index 00000000..83e1a689
--- /dev/null
+++ b/modules/game_engines/source_engine/camera.ixx
@@ -0,0 +1,13 @@
+//
+// Created by Vlad on 9/2/2025.
+//
+
+export module omath.source_engine.camera;
+import omath.camera;
+export import omath.source_engine.constants;
+export import omath.source_engine.camera_trait;
+
+export namespace omath::source_engine
+{
+    using Camera = projection::Camera<Mat4X4, ViewAngles, CameraTrait>;
+}
\ No newline at end of file
diff --git a/include/omath/engines/source_engine/constants.hpp b/modules/game_engines/source_engine/constants.ixx
similarity index 71%
rename from include/omath/engines/source_engine/constants.hpp
rename to modules/game_engines/source_engine/constants.ixx
index 33df18ba..89bff3c9 100644
--- a/include/omath/engines/source_engine/constants.hpp
+++ b/modules/game_engines/source_engine/constants.ixx
@@ -1,14 +1,15 @@
 //
-// Created by Orange on 12/4/2024.
+// Created by Vlad on 9/2/2025.
 //
-#pragma once
 
-#include "omath/linear_algebra/mat.hpp"
-#include "omath/linear_algebra/vector3.hpp"
-#include <omath/angle.hpp>
-#include <omath/view_angles.hpp>
+export module omath.source_engine.constants;
 
-namespace omath::source_engine
+import omath.vector3;
+import omath.mat;
+import omath.angle;
+import omath.view_angles;
+
+export namespace omath::source_engine
 {
     constexpr Vector3<float> k_abs_up = {0, 0, 1};
     constexpr Vector3<float> k_abs_right = {0, -1, 0};
@@ -22,4 +23,4 @@ namespace omath::source_engine
     using RollAngle = Angle<float, -180.f, 180.f, AngleFlags::Normalized>;
 
     using ViewAngles = omath::ViewAngles<PitchAngle, YawAngle, RollAngle>;
-} // namespace omath::source_engine
+}
\ No newline at end of file
diff --git a/source/engines/source_engine/formulas.cpp b/modules/game_engines/source_engine/formulas.ixx
similarity index 66%
rename from source/engines/source_engine/formulas.cpp
rename to modules/game_engines/source_engine/formulas.ixx
index 326507e8..88eda5ac 100644
--- a/source/engines/source_engine/formulas.cpp
+++ b/modules/game_engines/source_engine/formulas.ixx
@@ -1,10 +1,26 @@
 //
-// Created by Vlad on 3/19/2025.
+// Created by Vlad on 9/2/2025.
 //
-#include <omath/engines/source_engine/formulas.hpp>
+module;
+#include <cmath>
 
-namespace omath::source_engine
+export module omath.source_engine.formulas;
+
+import omath.vector3;
+import omath.source_engine.constants;
+import omath.view_angles;
+import omath.mat;
+import omath.angle;
+
+export namespace omath::source_engine
 {
+    [[nodiscard]]
+    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept
+    {
+        return mat_rotation_axis_z(angles.yaw) * mat_rotation_axis_y(angles.pitch) * mat_rotation_axis_x(angles.roll);
+    }
+
+    [[nodiscard]]
     Vector3<float> forward_vector(const ViewAngles& angles) noexcept
     {
         const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward);
@@ -12,17 +28,14 @@ namespace omath::source_engine
         return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
     }
 
-    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept
-    {
-        return mat_rotation_axis_z(angles.yaw) * mat_rotation_axis_y(angles.pitch) * mat_rotation_axis_x(angles.roll);
-    }
-
+    [[nodiscard]]
     Vector3<float> right_vector(const ViewAngles& angles) noexcept
     {
         const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right);
 
         return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
     }
+    [[nodiscard]]
     Vector3<float> up_vector(const ViewAngles& angles) noexcept
     {
         const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up);
@@ -30,18 +43,18 @@ namespace omath::source_engine
         return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
     }
 
-    Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
+    [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
     {
         return mat_camera_view(forward_vector(angles), right_vector(angles), up_vector(angles), cam_origin);
     }
 
-    Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
-                                              const float far) noexcept
+    [[nodiscard]]
+    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far) noexcept
     {
         // NOTE: Need magic number to fix fov calculation, since source inherit Quake proj matrix calculation
         constexpr auto k_multiply_factor = 0.75f;
 
-        const float fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / 2.f) * k_multiply_factor;
+        const float fov_half_tan = std::tan(degrees_to_radians(field_of_view) / 2.f) * k_multiply_factor;
 
         return {
                 {1.f / (aspect_ratio * fov_half_tan), 0, 0, 0},
@@ -50,4 +63,4 @@ namespace omath::source_engine
                 {0, 0, 1, 0},
         };
     }
-} // namespace omath::source_engine
+} // namespace omath::source_engine
\ No newline at end of file
diff --git a/modules/game_engines/source_engine/traits/camera_trait.ixx b/modules/game_engines/source_engine/traits/camera_trait.ixx
new file mode 100644
index 00000000..650157a5
--- /dev/null
+++ b/modules/game_engines/source_engine/traits/camera_trait.ixx
@@ -0,0 +1,40 @@
+//
+// Created by Vlad on 9/2/2025.
+//
+module;
+#include <cmath>
+
+export module omath.source_engine.camera_trait;
+
+import omath.source_engine.constants;
+import omath.source_engine.formulas;
+import omath.vector3;
+import omath.camera;
+export namespace omath::source_engine
+{
+    class CameraTrait final
+    {
+    public:
+        [[nodiscard]]
+        static ViewAngles calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept
+        {
+            const auto distance = cam_origin.distance_to(look_at);
+            const auto delta = cam_origin - look_at;
+
+            return {PitchAngle::from_radians(-std::asin(delta.z / distance)),
+                    YawAngle::from_radians(std::atan2(delta.y, delta.x)), RollAngle::from_radians(0.f)};
+        }
+
+        [[nodiscard]]
+        static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
+        {
+            return source_engine::calc_view_matrix(angles, cam_origin);
+        }
+        [[nodiscard]]
+        static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port,
+                                             const float near, const float far) noexcept
+        {
+            return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far);
+        }
+    };
+}
\ No newline at end of file
diff --git a/include/omath/engines/source_engine/traits/pred_engine_trait.hpp b/modules/game_engines/source_engine/traits/pred_engine_trait.ixx
similarity index 83%
rename from include/omath/engines/source_engine/traits/pred_engine_trait.hpp
rename to modules/game_engines/source_engine/traits/pred_engine_trait.ixx
index ca9771e1..a37d3381 100644
--- a/include/omath/engines/source_engine/traits/pred_engine_trait.hpp
+++ b/modules/game_engines/source_engine/traits/pred_engine_trait.ixx
@@ -1,14 +1,20 @@
 //
-// Created by Vlad on 8/3/2025.
+// Created by Vlad on 9/2/2025.
 //
-
-#pragma once
-#include "omath/engines/source_engine/formulas.hpp"
-#include "omath/projectile_prediction/projectile.hpp"
-#include "omath/projectile_prediction/target.hpp"
+module;
+#include <cmath>
 #include <optional>
 
-namespace omath::source_engine
+export module omath.source_engine.pred_engine_trait;
+
+import omath.vector3;
+import omath.angle;
+import omath.source_engine.formulas;
+import omath.source_engine.constants;
+import omath.projectile_prediction.target;
+import omath.projectile_prediction.projectile;
+
+export namespace omath::source_engine
 {
     class PredEngineTrait final
     {
@@ -54,7 +60,7 @@ namespace omath::source_engine
                                                          const std::optional<float> projectile_pitch) noexcept
         {
             const auto delta2d = calc_vector_2d_distance(predicted_target_position - projectile.m_origin);
-            const auto height = delta2d * std::tan(angles::degrees_to_radians(projectile_pitch.value()));
+            const auto height = delta2d * std::tan(degrees_to_radians(projectile_pitch.value()));
 
             return {predicted_target_position.x, predicted_target_position.y, projectile.m_origin.z + height};
         }
@@ -66,14 +72,14 @@ namespace omath::source_engine
             const auto distance = origin.distance_to(view_to);
             const auto delta = view_to - origin;
 
-            return angles::radians_to_degrees(std::asin(delta.z / distance));
+            return radians_to_degrees(std::asin(delta.z / distance));
         }
         [[nodiscard]]
         static float calc_direct_yaw_angle(const Vector3<float>& origin, const Vector3<float>& view_to) noexcept
         {
             const auto delta = view_to - origin;
 
-            return angles::radians_to_degrees(std::atan2(delta.y, delta.x));
+            return radians_to_degrees(std::atan2(delta.y, delta.x));
         };
     };
 } // namespace omath::source_engine
\ No newline at end of file
diff --git a/modules/game_engines/unity_engine/camera.ixx b/modules/game_engines/unity_engine/camera.ixx
new file mode 100644
index 00000000..032fdf13
--- /dev/null
+++ b/modules/game_engines/unity_engine/camera.ixx
@@ -0,0 +1,14 @@
+//
+// Created by Vlad on 9/3/2025.
+//
+
+export module omath.unity_engine.camera;
+import omath.camera;
+import omath.unity_engine.constants;
+import omath.unity_engine.camera_trait;
+
+
+export namespace omath::unity_engine
+{
+    using Camera = projection::Camera<Mat4X4, ViewAngles, CameraTrait>;
+}
\ No newline at end of file
diff --git a/include/omath/engines/unity_engine/constants.hpp b/modules/game_engines/unity_engine/constants.ixx
similarity index 72%
rename from include/omath/engines/unity_engine/constants.hpp
rename to modules/game_engines/unity_engine/constants.ixx
index 81151bc6..444653f3 100644
--- a/include/omath/engines/unity_engine/constants.hpp
+++ b/modules/game_engines/unity_engine/constants.ixx
@@ -1,15 +1,16 @@
 //
-// Created by Vlad on 3/22/2025.
+// Created by Vlad on 9/3/2025.
 //
 
-#pragma once
+export module omath.unity_engine.constants;
 
-#include "omath/linear_algebra/mat.hpp"
-#include "omath/linear_algebra/vector3.hpp"
-#include <omath/angle.hpp>
-#include <omath/view_angles.hpp>
+export import omath.vector3;
+export import omath.vector3;
+export import omath.mat;
+export import omath.angle;
+export import omath.view_angles;
 
-namespace omath::unity_engine
+export namespace omath::unity_engine
 {
     constexpr Vector3<float> k_abs_up = {0, 1, 0};
     constexpr Vector3<float> k_abs_right = {1, 0, 0};
diff --git a/source/engines/unity_engine/formulas.cpp b/modules/game_engines/unity_engine/formulas.ixx
similarity index 76%
rename from source/engines/unity_engine/formulas.cpp
rename to modules/game_engines/unity_engine/formulas.ixx
index 4560e277..405e08f2 100644
--- a/source/engines/unity_engine/formulas.cpp
+++ b/modules/game_engines/unity_engine/formulas.ixx
@@ -1,43 +1,57 @@
 //
-// Created by Vlad on 3/22/2025.
+// Created by Vlad on 9/3/2025.
 //
-#include "omath/engines/unity_engine/formulas.hpp"
+module;
+#include <cmath>
 
-namespace omath::unity_engine
+export module omath.unity_engine.formulas;
+export import omath.unity_engine.constants;
+
+export namespace omath::unity_engine
 {
+    [[nodiscard]]
+    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept
+    {
+        return mat_rotation_axis_x<float, MatStoreType::ROW_MAJOR>(angles.pitch)
+               * mat_rotation_axis_y<float, MatStoreType::ROW_MAJOR>(angles.yaw)
+               * mat_rotation_axis_z<float, MatStoreType::ROW_MAJOR>(angles.roll);
+    }
+
+    [[nodiscard]]
     Vector3<float> forward_vector(const ViewAngles& angles) noexcept
     {
         const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward);
 
         return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
     }
+
+    [[nodiscard]]
     Vector3<float> right_vector(const ViewAngles& angles) noexcept
     {
         const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right);
 
         return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
     }
+
+    [[nodiscard]]
     Vector3<float> up_vector(const ViewAngles& angles) noexcept
     {
         const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up);
 
         return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
     }
-    Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
+
+    [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
     {
         return mat_camera_view<float, MatStoreType::ROW_MAJOR>(forward_vector(angles), -right_vector(angles),
                                                                up_vector(angles), cam_origin);
     }
-    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept
-    {
-        return mat_rotation_axis_x<float, MatStoreType::ROW_MAJOR>(angles.pitch)
-               * mat_rotation_axis_y<float, MatStoreType::ROW_MAJOR>(angles.yaw)
-               * mat_rotation_axis_z<float, MatStoreType::ROW_MAJOR>(angles.roll);
-    }
+
+    [[nodiscard]]
     Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
                                               const float far) noexcept
     {
-        const float fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / 2.f);
+        const float fov_half_tan = std::tan(degrees_to_radians(field_of_view) / 2.f);
 
         return {
                 {1.f / (aspect_ratio * fov_half_tan), 0, 0, 0},
@@ -46,4 +60,4 @@ namespace omath::unity_engine
                 {0, 0, -1.f, 0},
         };
     }
-} // namespace omath::unity_engine
+} // namespace omath::unity_engine
\ No newline at end of file
diff --git a/modules/game_engines/unity_engine/traits/camera_trait.ixx b/modules/game_engines/unity_engine/traits/camera_trait.ixx
new file mode 100644
index 00000000..3d1fd465
--- /dev/null
+++ b/modules/game_engines/unity_engine/traits/camera_trait.ixx
@@ -0,0 +1,42 @@
+//
+// Created by Vlad on 9/3/2025.
+//
+module;
+#include <cmath>
+
+export module omath.unity_engine.camera_trait;
+import omath.unity_engine.formulas;
+import omath.projectile_prediction.projectile;
+import omath.projectile_prediction.target;
+import omath.camera;
+
+export namespace omath::unity_engine
+{
+    class CameraTrait final
+    {
+    public:
+        [[nodiscard]]
+        static ViewAngles calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept
+        {
+            const auto distance = cam_origin.distance_to(look_at);
+            const auto delta = cam_origin - look_at;
+
+            return {PitchAngle::from_radians(-std::asin(delta.y / distance)),
+                    YawAngle::from_radians(std::atan2(delta.z, delta.x)), RollAngle::from_radians(0.f)};
+        }
+
+        [[nodiscard]]
+        static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
+        {
+            return unity_engine::calc_view_matrix(angles, cam_origin);
+        }
+
+        [[nodiscard]]
+        static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port,
+                                             const float near, const float far) noexcept
+        {
+            return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far);
+        }
+    };
+
+}
\ No newline at end of file
diff --git a/include/omath/engines/unity_engine/traits/pred_engine_trait.hpp b/modules/game_engines/unity_engine/traits/pred_engine_trait.ixx
similarity index 83%
rename from include/omath/engines/unity_engine/traits/pred_engine_trait.hpp
rename to modules/game_engines/unity_engine/traits/pred_engine_trait.ixx
index 5851e4c6..956a72f4 100644
--- a/include/omath/engines/unity_engine/traits/pred_engine_trait.hpp
+++ b/modules/game_engines/unity_engine/traits/pred_engine_trait.ixx
@@ -1,13 +1,16 @@
 //
-// Created by Vlad on 8/6/2025.
+// Created by Vlad on 9/3/2025.
 //
-#pragma once
-#include "omath/engines/unity_engine/formulas.hpp"
-#include "omath/projectile_prediction/projectile.hpp"
-#include "omath/projectile_prediction/target.hpp"
+module;
+#include <cmath>
 #include <optional>
+export module omath.unity_engine.pred_engine_trait;
+import omath.unity_engine.formulas;
+import omath.projectile_prediction.target;
+import omath.projectile_prediction.projectile;
+import omath.angle;
 
-namespace omath::unity_engine
+export namespace omath::unity_engine
 {
     class PredEngineTrait final
     {
@@ -53,7 +56,7 @@ namespace omath::unity_engine
                                                          const std::optional<float> projectile_pitch) noexcept
         {
             const auto delta2d = calc_vector_2d_distance(predicted_target_position - projectile.m_origin);
-            const auto height = delta2d * std::tan(angles::degrees_to_radians(projectile_pitch.value()));
+            const auto height = delta2d * std::tan(degrees_to_radians(projectile_pitch.value()));
 
             return {predicted_target_position.x, predicted_target_position.y + height, projectile.m_origin.z};
         }
@@ -65,14 +68,14 @@ namespace omath::unity_engine
             const auto distance = origin.distance_to(view_to);
             const auto delta = view_to - origin;
 
-            return angles::radians_to_degrees(std::asin(delta.y / distance));
+            return radians_to_degrees(std::asin(delta.y / distance));
         }
         [[nodiscard]]
         static float calc_direct_yaw_angle(const Vector3<float>& origin, const Vector3<float>& view_to) noexcept
         {
             const auto delta = view_to - origin;
 
-            return angles::radians_to_degrees(std::atan2(delta.z, delta.x));
+            return radians_to_degrees(std::atan2(delta.z, delta.x));
         };
     };
-} // namespace omath::unity_engine
+} // namespace omath::unity_engine
\ No newline at end of file
diff --git a/modules/game_engines/unreal_engine/camera.ixx b/modules/game_engines/unreal_engine/camera.ixx
new file mode 100644
index 00000000..789853c7
--- /dev/null
+++ b/modules/game_engines/unreal_engine/camera.ixx
@@ -0,0 +1,14 @@
+//
+// Created by Vlad on 9/3/2025.
+//
+
+export module omath.unreal_engine.camera;
+export import omath.camera;
+import omath.unreal_engine.constants;
+import omath.unreal_engine.camera_trait;
+
+
+export namespace omath::unreal_engine
+{
+    using Camera = projection::Camera<Mat4X4, ViewAngles, CameraTrait>;
+}
\ No newline at end of file
diff --git a/include/omath/engines/unreal_engine/constants.hpp b/modules/game_engines/unreal_engine/constants.ixx
similarity index 75%
rename from include/omath/engines/unreal_engine/constants.hpp
rename to modules/game_engines/unreal_engine/constants.ixx
index e2e0eb7e..917ab871 100644
--- a/include/omath/engines/unreal_engine/constants.hpp
+++ b/modules/game_engines/unreal_engine/constants.ixx
@@ -1,15 +1,15 @@
 //
-// Created by Vlad on 3/22/2025.
+// Created by Vlad on 9/3/2025.
 //
 
-#pragma once
+export module omath.unreal_engine.constants;
 
-#include "omath/linear_algebra/mat.hpp"
-#include "omath/linear_algebra/vector3.hpp"
-#include <omath/angle.hpp>
-#include <omath/view_angles.hpp>
+export import omath.vector3;
+export import omath.mat;
+export import omath.angle;
+export import omath.view_angles;
 
-namespace omath::unreal_engine
+export namespace omath::unreal_engine
 {
     constexpr Vector3<float> k_abs_up = {0, 0, 1};
     constexpr Vector3<float> k_abs_right = {0, 1, 0};
diff --git a/source/engines/unreal_engine/formulas.cpp b/modules/game_engines/unreal_engine/formulas.ixx
similarity index 76%
rename from source/engines/unreal_engine/formulas.cpp
rename to modules/game_engines/unreal_engine/formulas.ixx
index 6f02ae85..3a0b9d11 100644
--- a/source/engines/unreal_engine/formulas.cpp
+++ b/modules/game_engines/unreal_engine/formulas.ixx
@@ -1,43 +1,59 @@
 //
-// Created by Vlad on 3/22/2025.
+// Created by Vlad on 9/3/2025.
 //
-#include "omath/engines/unreal_engine/formulas.hpp"
+module;
+#include <cmath>
 
-namespace omath::unreal_engine
+export module omath.unreal_engine.formulas;
+
+export import omath.unreal_engine.constants;
+import omath.angle;
+
+export namespace omath::unreal_engine
 {
+    [[nodiscard]]
+    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept
+    {
+        return mat_rotation_axis_x<float, MatStoreType::ROW_MAJOR>(angles.roll)
+               * mat_rotation_axis_y<float, MatStoreType::ROW_MAJOR>(angles.pitch)
+               * mat_rotation_axis_z<float, MatStoreType::ROW_MAJOR>(angles.yaw);
+    }
+
+    [[nodiscard]]
     Vector3<float> forward_vector(const ViewAngles& angles) noexcept
     {
         const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward);
 
         return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
     }
+
+    [[nodiscard]]
     Vector3<float> right_vector(const ViewAngles& angles) noexcept
     {
         const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right);
 
         return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
     }
+
+    [[nodiscard]]
     Vector3<float> up_vector(const ViewAngles& angles) noexcept
     {
         const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up);
 
         return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
     }
-    Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
+
+    [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
     {
         return mat_camera_view<float, MatStoreType::ROW_MAJOR>(forward_vector(angles), -right_vector(angles),
                                                                up_vector(angles), cam_origin);
     }
-    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept
-    {
-        return mat_rotation_axis_x<float, MatStoreType::ROW_MAJOR>(angles.roll)
-               * mat_rotation_axis_y<float, MatStoreType::ROW_MAJOR>(angles.pitch)
-               * mat_rotation_axis_z<float, MatStoreType::ROW_MAJOR>(angles.yaw);
-    }
+
+    [[nodiscard]]
     Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
                                               const float far) noexcept
     {
-        const float fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / 2.f);
+        const float fov_half_tan = std::tan(degrees_to_radians(field_of_view) / 2.f);
 
         return {
                 {1.f / (aspect_ratio * fov_half_tan), 0, 0, 0},
@@ -46,4 +62,4 @@ namespace omath::unreal_engine
                 {0, 0, -1.f, 0},
         };
     }
-} // namespace omath::unreal_engine
+} // namespace omath::unreal_engine
\ No newline at end of file
diff --git a/modules/game_engines/unreal_engine/traits/camera_trait.ixx b/modules/game_engines/unreal_engine/traits/camera_trait.ixx
new file mode 100644
index 00000000..991fe656
--- /dev/null
+++ b/modules/game_engines/unreal_engine/traits/camera_trait.ixx
@@ -0,0 +1,40 @@
+//
+// Created by Vlad on 9/3/2025.
+//
+module;
+#include <cmath>
+export module omath.unreal_engine.camera_trait;
+
+import omath.unreal_engine.constants;
+import omath.unreal_engine.formulas;
+import omath.camera;
+
+export namespace omath::unreal_engine
+{
+    class CameraTrait final
+    {
+    public:
+        [[nodiscard]]
+        static ViewAngles calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept
+        {
+            const auto distance = cam_origin.distance_to(look_at);
+            const auto delta = cam_origin - look_at;
+
+            return {PitchAngle::from_radians(-std::asin(delta.z / distance)),
+                    YawAngle::from_radians(std::atan2(delta.x, delta.y)), RollAngle::from_radians(0.f)};
+        }
+
+        [[nodiscard]]
+        static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
+        {
+            return unreal_engine::calc_view_matrix(angles, cam_origin);
+        }
+        [[nodiscard]]
+        static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port,
+                                             const float near, const float far) noexcept
+        {
+            return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far);
+        }
+    };
+
+} // namespace omath::unreal_engine
\ No newline at end of file
diff --git a/include/omath/engines/unreal_engine/traits/pred_engine_trait.hpp b/modules/game_engines/unreal_engine/traits/pred_engine_trait.ixx
similarity index 82%
rename from include/omath/engines/unreal_engine/traits/pred_engine_trait.hpp
rename to modules/game_engines/unreal_engine/traits/pred_engine_trait.ixx
index a57b8807..8b9b94b0 100644
--- a/include/omath/engines/unreal_engine/traits/pred_engine_trait.hpp
+++ b/modules/game_engines/unreal_engine/traits/pred_engine_trait.ixx
@@ -1,13 +1,19 @@
 //
-// Created by Vlad on 8/6/2025.
+// Created by Vlad on 9/3/2025.
 //
-#pragma once
-#include "omath/engines/unreal_engine/formulas.hpp"
-#include "omath/projectile_prediction/projectile.hpp"
-#include "omath/projectile_prediction/target.hpp"
+module;
+#include <cmath>
 #include <optional>
 
-namespace omath::unreal_engine
+export module omath.unreal_engine.pred_engine_trait;
+
+import omath.unreal_engine.constants;
+import omath.unreal_engine.formulas;
+import omath.projectile_prediction.projectile;
+import omath.projectile_prediction.target;
+import omath.angle;
+
+export namespace omath::unreal_engine
 {
     class PredEngineTrait final
     {
@@ -53,7 +59,7 @@ namespace omath::unreal_engine
                                                          const std::optional<float> projectile_pitch) noexcept
         {
             const auto delta2d = calc_vector_2d_distance(predicted_target_position - projectile.m_origin);
-            const auto height = delta2d * std::tan(angles::degrees_to_radians(projectile_pitch.value()));
+            const auto height = delta2d * std::tan(degrees_to_radians(projectile_pitch.value()));
 
             return {predicted_target_position.x, predicted_target_position.y, projectile.m_origin.z + height};
         }
@@ -65,14 +71,14 @@ namespace omath::unreal_engine
             const auto distance = origin.distance_to(view_to);
             const auto delta = view_to - origin;
 
-            return angles::radians_to_degrees(std::asin(delta.z / distance));
+            return radians_to_degrees(std::asin(delta.z / distance));
         }
         [[nodiscard]]
         static float calc_direct_yaw_angle(const Vector3<float>& origin, const Vector3<float>& view_to) noexcept
         {
             const auto delta = view_to - origin;
 
-            return angles::radians_to_degrees(std::atan2(delta.y, delta.x));
+            return radians_to_degrees(std::atan2(delta.y, delta.x));
         };
     };
-} // namespace omath::unreal_engine
+} // namespace omath::unreal_engine
\ No newline at end of file
diff --git a/include/omath/linear_algebra/mat.hpp b/modules/linear_algebra/mat.ixx
similarity index 94%
rename from include/omath/linear_algebra/mat.hpp
rename to modules/linear_algebra/mat.ixx
index 95276dcc..b526c122 100644
--- a/include/omath/linear_algebra/mat.hpp
+++ b/modules/linear_algebra/mat.ixx
@@ -1,8 +1,8 @@
 //
-// Created by vlad on 9/29/2024.
+// Created by Vlad on 9/1/2025.
 //
-#pragma once
-#include "vector3.hpp"
+module;
+
 #include <algorithm>
 #include <array>
 #include <iomanip>
@@ -10,16 +10,14 @@
 #include <sstream>
 #include <stdexcept>
 #include <utility>
+#include <format>
 
-#ifdef near
-#undef near
-#endif
+export module omath.mat;
 
-#ifdef far
-#undef far
-#endif
+import omath.vector3;
+import omath.angle;
 
-namespace omath
+export namespace omath
 {
     struct MatSize
     {
@@ -88,7 +86,7 @@ namespace omath
         }
 
         [[nodiscard]]
-        constexpr Type& operator[](const size_t row, const size_t col) const
+        constexpr const Type& operator[](const size_t row, const size_t col) const
         {
             return at(row, col);
         }
@@ -331,7 +329,12 @@ namespace omath
         [[nodiscard]]
         bool operator==(const Mat& mat) const
         {
-            return m_data == mat.m_data;
+            for (size_t i = 0; i < Rows * Columns; ++i)
+            {
+                if (m_data[i] != mat.m_data[i])
+                    return false;
+            }
+            return true;
         }
 
         [[nodiscard]]
@@ -377,13 +380,13 @@ namespace omath
     };
 
     template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR> [[nodiscard]]
-    constexpr static Mat<1, 4, Type, St> mat_row_from_vector(const Vector3<Type>& vector) noexcept
+    constexpr Mat<1, 4, Type, St> mat_row_from_vector(const Vector3<Type>& vector) noexcept
     {
         return {{vector.x, vector.y, vector.z, 1}};
     }
 
     template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR> [[nodiscard]]
-    constexpr static Mat<4, 1, Type, St> mat_column_from_vector(const Vector3<Type>& vector) noexcept
+    constexpr Mat<4, 1, Type, St> mat_column_from_vector(const Vector3<Type>& vector) noexcept
     {
         return {{vector.x}, {vector.y}, {vector.z}, {1}};
     }
@@ -442,7 +445,7 @@ namespace omath
 
     template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR>
     [[nodiscard]]
-    static Mat<4, 4, Type, St> mat_camera_view(const Vector3<Type>& forward, const Vector3<Type>& right,
+    Mat<4, 4, Type, St> mat_camera_view(const Vector3<Type>& forward, const Vector3<Type>& right,
                                                const Vector3<Type>& up, const Vector3<Type>& camera_origin) noexcept
     {
         return  Mat<4, 4, Type, St>
@@ -459,7 +462,7 @@ namespace omath
     Mat<4, 4, Type, St> mat_perspective_left_handed(const float field_of_view, const float aspect_ratio,
                                                     const float near, const float far) noexcept
     {
-        const float fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / 2.f);
+        const float fov_half_tan = std::tan(degrees_to_radians(field_of_view) / 2.f);
 
         return {{1.f / (aspect_ratio * fov_half_tan), 0.f, 0.f, 0.f},
                 {0.f, 1.f / fov_half_tan, 0.f, 0.f},
@@ -472,7 +475,7 @@ namespace omath
     Mat<4, 4, Type, St> mat_perspective_right_handed(const float field_of_view, const float aspect_ratio,
                                                      const float near, const float far) noexcept
     {
-        const float fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / 2.f);
+        const float fov_half_tan = std::tan(degrees_to_radians(field_of_view) / 2.f);
 
         return {{1.f / (aspect_ratio * fov_half_tan), 0.f, 0.f, 0.f},
                 {0.f, 1.f / fov_half_tan, 0.f, 0.f},
@@ -510,7 +513,7 @@ namespace omath
 
 } // namespace omath
 
-template<size_t Rows, size_t Columns, class Type, omath::MatStoreType StoreType>
+export template<size_t Rows, size_t Columns, class Type, omath::MatStoreType StoreType>
 struct std::formatter<omath::Mat<Rows, Columns, Type, StoreType>> // NOLINT(*-dcl58-cpp)
 {
     using MatType = omath::Mat<Rows, Columns, Type, StoreType>;
diff --git a/include/omath/linear_algebra/vector2.hpp b/modules/linear_algebra/vector2.ixx
similarity index 96%
rename from include/omath/linear_algebra/vector2.hpp
rename to modules/linear_algebra/vector2.ixx
index 7e8ddc83..80ec8c55 100644
--- a/include/omath/linear_algebra/vector2.hpp
+++ b/modules/linear_algebra/vector2.ixx
@@ -1,19 +1,22 @@
 //
-// Created by Vlad on 02.09.2024.
+// Created by Vlad on 9/1/2025.
 //
+module;
 
-#pragma once
 #include <cmath>
 #include <format>
 #include <tuple>
+#include <cmath>
 
 #ifdef OMATH_IMGUI_INTEGRATION
 #include <imgui.h>
 #endif
 
-namespace omath
-{
+export module omath.vector2;
 
+
+export namespace omath
+{
     template<class Type>
     requires std::is_arithmetic_v<Type>
     class Vector2
@@ -234,8 +237,8 @@ namespace omath
     };
 } // namespace omath
 
-template<class Type>
-struct std::formatter<omath::Vector2<Type>> // NOLINT(*-dcl58-cpp)
+export template<class Type, class CharT>
+struct std::formatter<omath::Vector2<Type>, CharT> // NOLINT(*-dcl58-cpp)
 {
     [[nodiscard]]
     static constexpr auto parse(std::format_parse_context& ctx)
@@ -247,4 +250,4 @@ struct std::formatter<omath::Vector2<Type>> // NOLINT(*-dcl58-cpp)
     {
         return std::format_to(ctx.out(), "[{}, {}]", vec.x, vec.y);
     }
-};
+};
\ No newline at end of file
diff --git a/include/omath/linear_algebra/vector3.hpp b/modules/linear_algebra/vector3.ixx
similarity index 94%
rename from include/omath/linear_algebra/vector3.hpp
rename to modules/linear_algebra/vector3.ixx
index e5f4fdaf..8b069e70 100644
--- a/include/omath/linear_algebra/vector3.hpp
+++ b/modules/linear_algebra/vector3.ixx
@@ -1,18 +1,24 @@
 //
-// Created by vlad on 10/28/23.
+// Created by Vlad on 9/1/2025.
 //
+module;
 
-#pragma once
-
-#include "omath/angle.hpp"
-#include "omath/linear_algebra/vector2.hpp"
 #include <cstdint>
 #include <expected>
 #include <functional>
+#include <format>
+#include <cmath>
 
-namespace omath
-{
+#ifdef OMATH_IMGUI_INTEGRATION
+#include <imgui.h>
+#endif
 
+export module omath.vector3;
+import omath.vector2;
+import omath.angle;
+
+export namespace omath
+{
     enum class Vector3Error
     {
         IMPOSSIBLE_BETWEEN_ANGLE,
@@ -250,8 +256,8 @@ namespace omath
             const auto distance = distance_to(other);
             const auto delta = other - *this;
 
-            return {angles::radians_to_degrees(std::asin(delta.z / distance)),
-                    angles::radians_to_degrees(std::atan2(delta.y, delta.x)), 0};
+            return {radians_to_degrees(std::asin(delta.z / distance)),
+                    radians_to_degrees(std::atan2(delta.y, delta.x)), 0};
         }
 
         [[nodiscard]]
@@ -280,7 +286,7 @@ namespace omath
     };
 } // namespace omath
 
-template<> struct std::hash<omath::Vector3<float>>
+export template<> struct std::hash<omath::Vector3<float>>
 {
     std::size_t operator()(const omath::Vector3<float>& vec) const noexcept
     {
@@ -295,7 +301,7 @@ template<> struct std::hash<omath::Vector3<float>>
     }
 };
 
-template<class Type>
+export template<class Type>
 struct std::formatter<omath::Vector3<Type>> // NOLINT(*-dcl58-cpp)
 {
     [[nodiscard]]
@@ -308,4 +314,4 @@ struct std::formatter<omath::Vector3<Type>> // NOLINT(*-dcl58-cpp)
     {
         return std::format_to(ctx.out(), "[{}, {}, {}]", vec.x, vec.y, vec.z);
     }
-};
+};
\ No newline at end of file
diff --git a/include/omath/linear_algebra/vector4.hpp b/modules/linear_algebra/vector4.ixx
similarity index 96%
rename from include/omath/linear_algebra/vector4.hpp
rename to modules/linear_algebra/vector4.ixx
index 95c095f6..b47ed912 100644
--- a/include/omath/linear_algebra/vector4.hpp
+++ b/modules/linear_algebra/vector4.ixx
@@ -1,12 +1,20 @@
 //
-// Vector4.h
+// Created by Vlad on 9/1/2025.
 //
-#pragma once
-
+module;
 #include <algorithm>
-#include "omath/linear_algebra/vector3.hpp"
+#include <format>
+#include <cmath>
+
+#ifdef OMATH_IMGUI_INTEGRATION
+#include <imgui.h>
+#endif
+
+export module omath.vector4;
+
+import omath.vector3;
 
-namespace omath
+export namespace omath
 {
     template<class Type>
     requires std::is_arithmetic_v<Type>
@@ -202,7 +210,7 @@ namespace omath
 };
 } // namespace omath
 
-template<class Type>
+export template<class Type>
 struct std::formatter<omath::Vector4<Type>> // NOLINT(*-dcl58-cpp)
 {
     [[nodiscard]]
diff --git a/modules/omath.ixx b/modules/omath.ixx
new file mode 100644
index 00000000..5a01bb9e
--- /dev/null
+++ b/modules/omath.ixx
@@ -0,0 +1,5 @@
+//
+// Created by Vlad on 9/1/2025.
+//
+
+export module omath;
diff --git a/modules/pathfinding/a_star.ixx b/modules/pathfinding/a_star.ixx
new file mode 100644
index 00000000..5b38fbee
--- /dev/null
+++ b/modules/pathfinding/a_star.ixx
@@ -0,0 +1,115 @@
+//
+// Created by Vlad on 9/3/2025.
+//
+module;
+#include <algorithm>
+#include <optional>
+#include <unordered_map>
+#include <vector>
+
+export module omath.pathfinding.a_star;
+export import omath.vector3;
+export import omath.pathfinding.navigation_mesh;
+
+namespace omath::pathfinding
+{
+    struct PathNode final
+    {
+        std::optional<Vector3<float>> came_from;
+        float g_cost = 0.f;
+    };
+} // namespace omath::pathfinding
+
+export namespace omath::pathfinding
+{
+    class Astar final
+    {
+    public:
+        [[nodiscard]]
+        static std::vector<Vector3<float>> find_path(const Vector3<float>& start, const Vector3<float>& end,
+                                                     const NavigationMesh& nav_mesh) noexcept
+        {
+            std::unordered_map<Vector3<float>, PathNode> closed_list;
+            std::unordered_map<Vector3<float>, PathNode> open_list;
+
+            const auto maybe_start_vertex = nav_mesh.get_closest_vertex(start);
+            const auto maybe_end_vertex = nav_mesh.get_closest_vertex(end);
+
+            if (!maybe_start_vertex || !maybe_end_vertex)
+                return {};
+
+            const auto start_vertex = maybe_start_vertex.value();
+            const auto end_vertex = maybe_end_vertex.value();
+
+            open_list.emplace(start_vertex, PathNode{std::nullopt, 0.f});
+
+            while (!open_list.empty())
+            {
+                auto current_it = get_perfect_node(open_list, end_vertex);
+
+                const auto current = current_it->first;
+                const auto current_node = current_it->second;
+
+                if (current == end_vertex)
+                    return reconstruct_final_path(closed_list, current);
+
+                closed_list.emplace(current, current_node);
+                open_list.erase(current_it);
+
+                for (const auto& neighbor: nav_mesh.get_neighbors(current))
+                {
+                    if (closed_list.contains(neighbor))
+                        continue;
+
+                    const float tentative_g_cost = current_node.g_cost + neighbor.distance_to(current);
+
+                    // ReSharper disable once CppTooWideScopeInitStatement
+                    const auto open_it = open_list.find(neighbor);
+
+                    if (open_it == open_list.end() || tentative_g_cost < open_it->second.g_cost)
+                        open_list[neighbor] = PathNode{current, tentative_g_cost};
+                }
+            }
+
+            return {};
+        }
+
+    private:
+        [[nodiscard]]
+        static std::vector<Vector3<float>>
+        reconstruct_final_path(const std::unordered_map<Vector3<float>, PathNode>& closed_list,
+                               const Vector3<float>& current) noexcept
+        {
+            std::vector<Vector3<float>> path;
+            std::optional current_opt = current;
+
+            while (current_opt)
+            {
+                path.push_back(*current_opt);
+
+                auto it = closed_list.find(*current_opt);
+
+                if (it == closed_list.end())
+                    break;
+
+                current_opt = it->second.came_from;
+            }
+
+            std::ranges::reverse(path);
+            return path;
+        }
+
+        [[nodiscard]]
+        static auto get_perfect_node(const std::unordered_map<Vector3<float>, PathNode>& open_list,
+                                     const Vector3<float>& end_vertex) noexcept
+        {
+            return std::ranges::min_element(open_list,
+                                            [&end_vertex](const auto& a, const auto& b)
+                                            {
+                                                const float fa = a.second.g_cost + a.first.distance_to(end_vertex);
+                                                const float fb = b.second.g_cost + b.first.distance_to(end_vertex);
+                                                return fa < fb;
+                                            });
+        }
+    };
+} // namespace omath::pathfinding
diff --git a/modules/pathfinding/navigation_mesh.ixx b/modules/pathfinding/navigation_mesh.ixx
new file mode 100644
index 00000000..8217b945
--- /dev/null
+++ b/modules/pathfinding/navigation_mesh.ixx
@@ -0,0 +1,110 @@
+//
+// Created by Vlad on 9/3/2025.
+//
+module;
+#include <vector>
+#include <unordered_map>
+#include <expected>
+#include <string>
+#include <stdexcept>
+export module omath.pathfinding.navigation_mesh;
+export import omath.vector3;
+
+export namespace omath::pathfinding
+{
+
+    enum Error
+    {
+    };
+
+    class NavigationMesh final
+    {
+    public:
+        [[nodiscard]]
+        std::expected<Vector3<float>, std::string> get_closest_vertex(const Vector3<float>& point) const noexcept
+        {
+            const auto res = std::ranges::min_element(m_vertex_map, [&point](const auto& a, const auto& b)
+                                                      { return a.first.distance_to(point) < b.first.distance_to(point); });
+
+            if (res == m_vertex_map.cend())
+                return std::unexpected("Failed to get clossest point");
+
+            return res->first;
+        }
+
+        [[nodiscard]]
+        const std::vector<Vector3<float>>& get_neighbors(const Vector3<float>& vertex) const noexcept
+        {
+            return m_vertex_map.at(vertex);
+        }
+
+        [[nodiscard]]
+        bool empty() const
+        {
+            return m_vertex_map.empty();
+        }
+
+        [[nodiscard]] std::vector<uint8_t> serialize() const noexcept
+        {
+            auto dump_to_vector = []<typename T>(const T& t, std::vector<uint8_t>& vec)
+            {
+                for (size_t i = 0; i < sizeof(t); i++)
+                    vec.push_back(*(reinterpret_cast<const uint8_t*>(&t) + i));
+            };
+
+            std::vector<uint8_t> raw;
+
+            for (const auto& [vertex, neighbors]: m_vertex_map)
+            {
+                const auto neighbors_count = neighbors.size();
+
+                dump_to_vector(vertex, raw);
+                dump_to_vector(neighbors_count, raw);
+
+                for (const auto& neighbor: neighbors)
+                    dump_to_vector(neighbor, raw);
+            }
+            return raw;
+        }
+
+        void deserialize(const std::vector<uint8_t>& raw) noexcept
+        {
+            auto load_from_vector = [](const std::vector<uint8_t>& vec, size_t& offset, auto& value)
+            {
+                if (offset + sizeof(value) > vec.size())
+                {
+                    throw std::runtime_error("Deserialize: Invalid input data size.");
+                }
+                std::copy_n(vec.data() + offset, sizeof(value), reinterpret_cast<uint8_t*>(&value));
+                offset += sizeof(value);
+            };
+
+            m_vertex_map.clear();
+
+            size_t offset = 0;
+
+            while (offset < raw.size())
+            {
+                Vector3<float> vertex;
+                load_from_vector(raw, offset, vertex);
+
+                uint16_t neighbors_count;
+                load_from_vector(raw, offset, neighbors_count);
+
+                std::vector<Vector3<float>> neighbors;
+                neighbors.reserve(neighbors_count);
+
+                for (size_t i = 0; i < neighbors_count; ++i)
+                {
+                    Vector3<float> neighbor;
+                    load_from_vector(raw, offset, neighbor);
+                    neighbors.push_back(neighbor);
+                }
+
+                m_vertex_map.emplace(vertex, std::move(neighbors));
+            }
+        }
+
+        std::unordered_map<Vector3<float>, std::vector<Vector3<float>>> m_vertex_map;
+    };
+} // namespace omath::pathfinding
diff --git a/include/omath/projectile_prediction/proj_pred_engine.hpp b/modules/projectile_prediction/proj_pred_engine.ixx
similarity index 53%
rename from include/omath/projectile_prediction/proj_pred_engine.hpp
rename to modules/projectile_prediction/proj_pred_engine.ixx
index bbd5a546..48e90d3e 100644
--- a/include/omath/projectile_prediction/proj_pred_engine.hpp
+++ b/modules/projectile_prediction/proj_pred_engine.ixx
@@ -1,12 +1,15 @@
 //
-// Created by Vlad on 2/23/2025.
+// Created by Vlad on 9/1/2025.
 //
-#pragma once
-#include "omath/linear_algebra/vector3.hpp"
-#include "omath/projectile_prediction/projectile.hpp"
-#include "omath/projectile_prediction/target.hpp"
+module;
+#include <optional>
 
-namespace omath::projectile_prediction
+export module omath.projectile_prediction.proj_pred_engine;
+
+import omath.projectile_prediction.target;
+import omath.projectile_prediction.projectile;
+
+export namespace omath::projectile_prediction
 {
     class ProjPredEngineInterface
     {
@@ -16,4 +19,4 @@ namespace omath::projectile_prediction
                                                                         const Target& target) const = 0;
         virtual ~ProjPredEngineInterface() = default;
     };
-} // namespace omath::projectile_prediction
+} // namespace omath::projectile_prediction
\ No newline at end of file
diff --git a/modules/projectile_prediction/proj_pred_engine_avx2.ixx b/modules/projectile_prediction/proj_pred_engine_avx2.ixx
new file mode 100644
index 00000000..e5ac4bf1
--- /dev/null
+++ b/modules/projectile_prediction/proj_pred_engine_avx2.ixx
@@ -0,0 +1,177 @@
+//
+// Created by Vlad on 9/3/2025.
+//
+module;
+#include <optional>
+#include <source_location>
+
+#if defined(OMATH_USE_AVX2) && defined(__i386__) && defined(__x86_64__)
+#include <immintrin.h>
+#else
+#include <format>
+#endif
+
+export module omath.projectile_prediction.proj_pred_engine_avx2;
+
+import omath.projectile_prediction.proj_pred_engine;
+import omath.projectile_prediction.projectile;
+import omath.projectile_prediction.target;
+
+namespace omath::projectile_prediction
+{
+    class ProjPredEngineAvx2 final : public ProjPredEngineInterface
+    {
+    public:
+        [[nodiscard]] std::optional<Vector3<float>>
+        maybe_calculate_aim_point([[maybe_unused]] const Projectile& projectile,
+                                  [[maybe_unused]] const Target& target) const override
+        {
+#if defined(OMATH_USE_AVX2) && defined(__i386__) && defined(__x86_64__)
+            const float bulletGravity = m_gravityConstant * projectile.m_gravityScale;
+            const float v0 = projectile.m_launchSpeed;
+            const float v0Sqr = v0 * v0;
+            const Vector3 projOrigin = projectile.m_origin;
+
+            constexpr int SIMD_FACTOR = 8;
+            float currentTime = m_simulationTimeStep;
+
+            for (; currentTime <= m_maximumSimulationTime; currentTime += m_simulationTimeStep * SIMD_FACTOR)
+            {
+                const __m256 times =
+                        _mm256_setr_ps(currentTime, currentTime + m_simulationTimeStep,
+                                       currentTime + m_simulationTimeStep * 2, currentTime + m_simulationTimeStep * 3,
+                                       currentTime + m_simulationTimeStep * 4, currentTime + m_simulationTimeStep * 5,
+                                       currentTime + m_simulationTimeStep * 6, currentTime + m_simulationTimeStep * 7);
+
+                const __m256 targetX =
+                        _mm256_fmadd_ps(_mm256_set1_ps(target.m_velocity.x), times, _mm256_set1_ps(target.m_origin.x));
+                const __m256 targetY =
+                        _mm256_fmadd_ps(_mm256_set1_ps(target.m_velocity.y), times, _mm256_set1_ps(target.m_origin.y));
+                const __m256 timesSq = _mm256_mul_ps(times, times);
+                const __m256 targetZ = _mm256_fmadd_ps(_mm256_set1_ps(target.m_velocity.z), times,
+                                                       _mm256_fnmadd_ps(_mm256_set1_ps(0.5f * m_gravityConstant),
+                                                                        timesSq, _mm256_set1_ps(target.m_origin.z)));
+
+                const __m256 deltaX = _mm256_sub_ps(targetX, _mm256_set1_ps(projOrigin.x));
+                const __m256 deltaY = _mm256_sub_ps(targetY, _mm256_set1_ps(projOrigin.y));
+                const __m256 deltaZ = _mm256_sub_ps(targetZ, _mm256_set1_ps(projOrigin.z));
+
+                const __m256 dSqr = _mm256_add_ps(_mm256_mul_ps(deltaX, deltaX), _mm256_mul_ps(deltaY, deltaY));
+
+                const __m256 bgTimesSq = _mm256_mul_ps(_mm256_set1_ps(bulletGravity), timesSq);
+                const __m256 term = _mm256_add_ps(deltaZ, _mm256_mul_ps(_mm256_set1_ps(0.5f), bgTimesSq));
+                const __m256 termSq = _mm256_mul_ps(term, term);
+                const __m256 numerator = _mm256_add_ps(dSqr, termSq);
+                const __m256 denominator = _mm256_add_ps(timesSq, _mm256_set1_ps(1e-8f)); // Avoid division by zero
+                const __m256 requiredV0Sqr = _mm256_div_ps(numerator, denominator);
+
+                const __m256 v0SqrVec = _mm256_set1_ps(v0Sqr + 1e-3f);
+                const __m256 mask = _mm256_cmp_ps(requiredV0Sqr, v0SqrVec, _CMP_LE_OQ);
+
+                const unsigned validMask = _mm256_movemask_ps(mask);
+
+                if (!validMask)
+                    continue;
+
+                alignas(32) float validTimes[SIMD_FACTOR];
+                _mm256_store_ps(validTimes, times);
+
+                for (int i = 0; i < SIMD_FACTOR; ++i)
+                {
+                    if (!(validMask & (1 << i)))
+                        continue;
+
+                    const float candidateTime = validTimes[i];
+
+                    if (candidateTime > m_maximumSimulationTime)
+                        continue;
+
+                    // Fine search around candidate time
+                    for (float fineTime = candidateTime - m_simulationTimeStep * 2;
+                         fineTime <= candidateTime + m_simulationTimeStep * 2; fineTime += m_simulationTimeStep)
+                    {
+                        if (fineTime < 0)
+                            continue;
+
+                        const Vector3 targetPos = target.PredictPosition(fineTime, m_gravityConstant);
+                        const auto pitch = CalculatePitch(projOrigin, targetPos, bulletGravity, v0, fineTime);
+                        if (!pitch)
+                            continue;
+
+                        const Vector3 delta = targetPos - projOrigin;
+                        const float d = std::sqrt(delta.x * delta.x + delta.y * delta.y);
+                        const float height = d * std::tan(angles::DegreesToRadians(*pitch));
+                        return Vector3(targetPos.x, targetPos.y, projOrigin.z + height);
+                    }
+                }
+            }
+
+            // Fallback scalar processing for remaining times
+            for (; currentTime <= m_maximumSimulationTime; currentTime += m_simulationTimeStep)
+            {
+                const Vector3 targetPos = target.PredictPosition(currentTime, m_gravityConstant);
+                const auto pitch = CalculatePitch(projOrigin, targetPos, bulletGravity, v0, currentTime);
+                if (!pitch)
+                    continue;
+
+                const Vector3 delta = targetPos - projOrigin;
+                const float d = std::sqrt(delta.x * delta.x + delta.y * delta.y);
+                const float height = d * std::tan(angles::DegreesToRadians(*pitch));
+                return Vector3(targetPos.x, targetPos.y, projOrigin.z + height);
+            }
+
+            return std::nullopt;
+#else
+            throw std::runtime_error(
+                    std::format("{} AVX2 feature is not enabled!", std::source_location::current().function_name()));
+#endif
+        }
+
+        ProjPredEngineAvx2(const float gravity_constant, const float simulation_time_step,
+                           const float maximum_simulation_time)
+            : m_gravity_constant(gravity_constant), m_simulation_time_step(simulation_time_step),
+              m_maximum_simulation_time(maximum_simulation_time)
+        {
+        }
+        ~ProjPredEngineAvx2() override = default;
+
+    private:
+        [[nodiscard]] static std::optional<float> calculate_pitch([[maybe_unused]] const Vector3<float>& proj_origin,
+                                                                  [[maybe_unused]] const Vector3<float>& target_pos,
+                                                                  [[maybe_unused]] float bullet_gravity,
+                                                                  [[maybe_unused]] float v0,
+                                                                  [[maybe_unused]] float time)
+        {
+#if defined(OMATH_USE_AVX2) && defined(__i386__) && defined(__x86_64__)
+            if (time <= 0.0f)
+                return std::nullopt;
+
+            const Vector3 delta = target_pos - proj_origin;
+            const float dSqr = delta.x * delta.x + delta.y * delta.y;
+            const float h = delta.z;
+
+            const float term = h + 0.5f * bullet_gravity * time * time;
+            const float requiredV0Sqr = (dSqr + term * term) / (time * time);
+            const float v0Sqr = v0 * v0;
+
+            if (requiredV0Sqr > v0Sqr + 1e-3f)
+                return std::nullopt;
+
+            if (dSqr == 0.0f)
+                return term >= 0.0f ? 90.0f : -90.0f;
+
+            const float d = std::sqrt(dSqr);
+            const float tanTheta = term / d;
+            return angles::RadiansToDegrees(std::atan(tanTheta));
+#else
+            throw std::runtime_error(
+                    std::format("{} AVX2 feature is not enabled!", std::source_location::current().function_name()));
+#endif
+        }
+
+        // We use [[maybe_unused]] here since AVX2 is not available for ARM and ARM64 CPU
+        [[maybe_unused]] const float m_gravity_constant;
+        [[maybe_unused]] const float m_simulation_time_step;
+        [[maybe_unused]] const float m_maximum_simulation_time;
+    };
+} // namespace omath::projectile_prediction
\ No newline at end of file
diff --git a/include/omath/projectile_prediction/proj_pred_engine_legacy.hpp b/modules/projectile_prediction/proj_pred_engine_legacy.ixx
similarity index 90%
rename from include/omath/projectile_prediction/proj_pred_engine_legacy.hpp
rename to modules/projectile_prediction/proj_pred_engine_legacy.ixx
index 231db3b7..75158a31 100644
--- a/include/omath/projectile_prediction/proj_pred_engine_legacy.hpp
+++ b/modules/projectile_prediction/proj_pred_engine_legacy.ixx
@@ -1,17 +1,22 @@
 //
-// Created by Vlad on 6/9/2024.
+// Created by Vlad on 9/1/2025.
 //
 
-#pragma once
+module;
 
-#include "omath/linear_algebra/vector3.hpp"
-#include "omath/engines/source_engine/traits/pred_engine_trait.hpp"
-#include "omath/projectile_prediction/proj_pred_engine.hpp"
-#include "omath/projectile_prediction/projectile.hpp"
-#include "omath/projectile_prediction/target.hpp"
+#include <cmath>
 #include <optional>
 
-namespace omath::projectile_prediction
+export module omath.projectile_prediction.proj_pred_legacy;
+
+export import omath.projectile_prediction.projectile;
+export import omath.projectile_prediction.target;
+
+import omath.projectile_prediction.proj_pred_engine;
+import omath.source_engine.pred_engine_trait;
+import omath.angle;
+
+export namespace omath::projectile_prediction
 {
     template<class T>
     concept PredEngineConcept =
@@ -20,7 +25,9 @@ namespace omath::projectile_prediction
                      Vector3<float> v3, // by-value for calc_viewpoint_from_angles
                      float pitch, float yaw, float time, float gravity, std::optional<float> maybe_pitch) {
                 // Presence + return types
-                { T::predict_projectile_position(projectile, pitch, yaw, time, gravity) } -> std::same_as<Vector3<float>>;
+                {
+                    T::predict_projectile_position(projectile, pitch, yaw, time, gravity)
+                } -> std::same_as<Vector3<float>>;
                 { T::predict_target_position(target, time, gravity) } -> std::same_as<Vector3<float>>;
                 { T::calc_vector_2d_distance(vec_a) } -> std::same_as<float>;
                 { T::get_vector_height_coordinate(vec_b) } -> std::same_as<float>;
@@ -118,7 +125,7 @@ namespace omath::projectile_prediction
             root = std::sqrt(root);
             const float angle = std::atan((launch_speed_sqr - root) / (bullet_gravity * distance2d));
 
-            return angles::radians_to_degrees(angle);
+            return radians_to_degrees(angle);
         }
         [[nodiscard]]
         bool is_projectile_reached_target(const Vector3<float>& target_position, const Projectile& projectile,
@@ -131,4 +138,4 @@ namespace omath::projectile_prediction
             return projectile_position.distance_to(target_position) <= m_distance_tolerance;
         }
     };
-} // namespace omath::projectile_prediction
+} // namespace omath::projectile_prediction
\ No newline at end of file
diff --git a/include/omath/projectile_prediction/projectile.hpp b/modules/projectile_prediction/projectile.ixx
similarity index 54%
rename from include/omath/projectile_prediction/projectile.hpp
rename to modules/projectile_prediction/projectile.ixx
index c4560ed4..37adaa26 100644
--- a/include/omath/projectile_prediction/projectile.hpp
+++ b/modules/projectile_prediction/projectile.ixx
@@ -1,11 +1,11 @@
 //
-// Created by Vlad on 6/9/2024.
+// Created by Vlad on 9/1/2025.
 //
 
-#pragma once
-#include "omath/linear_algebra/vector3.hpp"
+export module omath.projectile_prediction.       projectile;
+export import omath.vector3;
 
-namespace omath::projectile_prediction
+export namespace omath::projectile_prediction
 {
     class Projectile final
     {
diff --git a/include/omath/projectile_prediction/target.hpp b/modules/projectile_prediction/target.ixx
similarity index 55%
rename from include/omath/projectile_prediction/target.hpp
rename to modules/projectile_prediction/target.ixx
index 5b3f5db2..94809efd 100644
--- a/include/omath/projectile_prediction/target.hpp
+++ b/modules/projectile_prediction/target.ixx
@@ -1,11 +1,11 @@
 //
-// Created by Vlad on 6/9/2024.
+// Created by Vlad on 9/1/2025.
 //
 
-#pragma once
-#include "omath/linear_algebra/vector3.hpp"
+export module omath.projectile_prediction.target;
+export import omath.vector3;
 
-namespace omath::projectile_prediction
+export namespace omath::projectile_prediction
 {
     class Target final
     {
diff --git a/include/omath/projection/camera.hpp b/modules/projection/camera.ixx
similarity index 95%
rename from include/omath/projection/camera.hpp
rename to modules/projection/camera.ixx
index be44e8e8..d99a4543 100644
--- a/include/omath/projection/camera.hpp
+++ b/modules/projection/camera.ixx
@@ -1,17 +1,19 @@
 //
-// Created by Vlad on 27.08.2024.
+// Created by Vlad on 9/1/2025.
 //
+module;
 
-#pragma once
-
-#include "omath/projection/error_codes.hpp"
-#include "omath/linear_algebra/mat.hpp"
-#include "omath/linear_algebra/vector3.hpp"
 #include <expected>
-#include <omath/angle.hpp>
-#include <type_traits>
+#include <optional>
+#include <algorithm>
+
+export module omath.camera;
+
+export import omath.vector3;
+export import omath.angle;
+export import omath.error_codes;
 
-namespace omath::projection
+export namespace omath::projection
 {
     class ViewPort final
     {
@@ -201,4 +203,4 @@ namespace omath::projection
             return {(ndc.x + 1.f) / 2.f * m_view_port.m_width, (1.f - ndc.y) / 2.f * m_view_port.m_height, ndc.z};
         }
     };
-} // namespace omath::projection
+} // namespace omath::projection
\ No newline at end of file
diff --git a/include/omath/projection/error_codes.hpp b/modules/projection/proj_error_codes.ixx
similarity index 53%
rename from include/omath/projection/error_codes.hpp
rename to modules/projection/proj_error_codes.ixx
index ae29fc07..c3e9fe70 100644
--- a/include/omath/projection/error_codes.hpp
+++ b/modules/projection/proj_error_codes.ixx
@@ -1,11 +1,13 @@
 //
-// Created by Vlad on 03.09.2024.
+// Created by Vlad on 9/1/2025.
 //
-
-#pragma once
+module;
 #include <cstdint>
 
-namespace omath::projection
+export module omath.error_codes;
+
+
+export namespace omath::projection
 {
     enum class Error : uint16_t
     {
diff --git a/include/omath/angle.hpp b/modules/trigonometry/angle.ixx
similarity index 59%
rename from include/omath/angle.hpp
rename to modules/trigonometry/angle.ixx
index a13b27fa..4220e556 100644
--- a/include/omath/angle.hpp
+++ b/modules/trigonometry/angle.ixx
@@ -1,15 +1,72 @@
 //
-// Created by Orange on 11/30/2024.
+// Created by Vlad on 9/1/2025.
 //
-
-#pragma once
-#include "omath/angles.hpp"
+module;
 #include <algorithm>
-#include <utility>
+#include <cmath>
+#include <compare>
 #include <format>
+#include <numbers>
+#include <utility>
 
-namespace omath
+export module omath.angle;
+
+export namespace omath
 {
+    template<class Type>
+    requires std::is_floating_point_v<Type>
+    [[nodiscard]] constexpr Type radians_to_degrees(const Type& radians) noexcept
+    {
+        return radians * (static_cast<Type>(180) / std::numbers::pi_v<Type>);
+    }
+
+    template<class Type>
+    requires std::is_floating_point_v<Type>
+    [[nodiscard]] constexpr Type degrees_to_radians(const Type& degrees) noexcept
+    {
+        return degrees * (std::numbers::pi_v<Type> / static_cast<Type>(180));
+    }
+
+    template<class Type>
+    requires std::is_floating_point_v<Type>
+    [[nodiscard]] Type horizontal_fov_to_vertical(const Type& horizontal_fov, const Type& aspect) noexcept
+    {
+        const auto fov_rad = degrees_to_radians(horizontal_fov);
+
+        const auto vert_fov = static_cast<Type>(2) * std::atan(std::tan(fov_rad / static_cast<Type>(2)) / aspect);
+
+        return radians_to_degrees(vert_fov);
+    }
+
+    template<class Type>
+    requires std::is_floating_point_v<Type>
+    [[nodiscard]] Type vertical_fov_to_horizontal(const Type& vertical_fov, const Type& aspect) noexcept
+    {
+        const auto fov_as_radians = degrees_to_radians(vertical_fov);
+
+        const auto horizontal_fov =
+                static_cast<Type>(2) * std::atan(std::tan(fov_as_radians / static_cast<Type>(2)) * aspect);
+
+        return radians_to_degrees(horizontal_fov);
+    }
+
+    template<class Type>
+    requires std::is_arithmetic_v<Type>
+    [[nodiscard]] Type wrap_angle(const Type& angle, const Type& min, const Type& max) noexcept
+    {
+        if (angle <= max && angle >= min)
+            return angle;
+
+        const Type range = max - min;
+
+        Type wrapped_angle = std::fmod(angle - min, range);
+
+        if (wrapped_angle < 0)
+            wrapped_angle += range;
+
+        return wrapped_angle + min;
+    }
+
     enum class AngleFlags
     {
         Normalized = 0,
@@ -24,7 +81,7 @@ namespace omath
         constexpr explicit Angle(const Type& degrees) noexcept
         {
             if constexpr (flags == AngleFlags::Normalized)
-                m_angle = angles::wrap_angle(degrees, min, max);
+                m_angle = wrap_angle(degrees, min, max);
 
             else if constexpr (flags == AngleFlags::Clamped)
                 m_angle = std::clamp(degrees, min, max);
@@ -47,7 +104,7 @@ namespace omath
         [[nodiscard]]
         constexpr static Angle from_radians(const Type& degrees) noexcept
         {
-            return Angle{angles::radians_to_degrees<Type>(degrees)};
+            return Angle{radians_to_degrees<Type>(degrees)};
         }
 
         [[nodiscard]]
@@ -65,7 +122,7 @@ namespace omath
         [[nodiscard]]
         constexpr Type as_radians() const noexcept
         {
-            return angles::degrees_to_radians(m_angle);
+            return degrees_to_radians(m_angle);
         }
 
         [[nodiscard]]
@@ -101,7 +158,7 @@ namespace omath
         constexpr Angle& operator+=(const Angle& other) noexcept
         {
             if constexpr (flags == AngleFlags::Normalized)
-                m_angle = angles::wrap_angle(m_angle + other.m_angle, min, max);
+                m_angle = wrap_angle(m_angle + other.m_angle, min, max);
 
             else if constexpr (flags == AngleFlags::Clamped)
                 m_angle = std::clamp(m_angle + other.m_angle, min, max);
@@ -114,9 +171,6 @@ namespace omath
             return *this;
         }
 
-        [[nodiscard]]
-        constexpr std::partial_ordering operator<=>(const Angle& other) const noexcept = default;
-
         constexpr Angle& operator-=(const Angle& other) noexcept
         {
             return operator+=(-other);
@@ -126,7 +180,7 @@ namespace omath
         constexpr Angle& operator+(const Angle& other) noexcept
         {
             if constexpr (flags == AngleFlags::Normalized)
-                return {angles::wrap_angle(m_angle + other.m_angle, min, max)};
+                return {wrap_angle(m_angle + other.m_angle, min, max)};
 
             else if constexpr (flags == AngleFlags::Clamped)
                 return {std::clamp(m_angle + other.m_angle, min, max)};
@@ -149,18 +203,4 @@ namespace omath
             return Angle{-m_angle};
         }
     };
-} // namespace omath
-template<class Type, Type min, Type max, omath::AngleFlags flags>
-struct std::formatter<omath::Angle<Type, min, max, flags>> // NOLINT(*-dcl58-cpp)
-{
-    [[nodiscard]]
-    static constexpr auto parse(std::format_parse_context& ctx)
-    {
-        return ctx.begin();
-    }
-    [[nodiscard]]
-    static auto format(const omath::Angle<Type, min, max, flags>& deg, std::format_context& ctx)
-    {
-        return std::format_to(ctx.out(), "{}deg", deg.as_degrees());
-    }
-};
\ No newline at end of file
+} // namespace omath
\ No newline at end of file
diff --git a/include/omath/view_angles.hpp b/modules/trigonometry/view_angles.ixx
similarity index 68%
rename from include/omath/view_angles.hpp
rename to modules/trigonometry/view_angles.ixx
index cd63640a..44e8d24b 100644
--- a/include/omath/view_angles.hpp
+++ b/modules/trigonometry/view_angles.ixx
@@ -1,9 +1,10 @@
 //
-// Created by Orange on 11/30/2024.
+// Created by Vlad on 9/1/2025.
 //
-#pragma once
 
-namespace omath
+export module omath.view_angles;
+
+export namespace omath
 {
     template<class PitchType, class YawType, class RollType>
     struct ViewAngles
diff --git a/include/omath/color.hpp b/modules/utility/color.ixx
similarity index 95%
rename from include/omath/color.hpp
rename to modules/utility/color.ixx
index 69e554fc..665be612 100644
--- a/include/omath/color.hpp
+++ b/modules/utility/color.ixx
@@ -1,13 +1,20 @@
 //
-// Created by vlad on 2/4/24.
+// Created by Vlad on 9/1/2025.
 //
+module;
+#include <cstdint>
+#include <cmath>
+#include <algorithm>
+#include <format>
 
-#pragma once
+#ifdef OMATH_IMGUI_INTEGRATION
+#include <imgui.h>
+#endif
 
-#include "linear_algebra/vector4.hpp"
-#include <cstdint>
+export module omath.color;
+import omath.vector4;
 
-namespace omath
+export namespace omath
 {
     struct Hsv
     {
@@ -166,7 +173,7 @@ namespace omath
 #endif
     };
 } // namespace omath
-template<>
+export template<>
 struct std::formatter<omath::Color> // NOLINT(*-dcl58-cpp)
 {
     [[nodiscard]]
diff --git a/source/3d_primitives/plane.cpp b/source/3d_primitives/plane.cpp
deleted file mode 100644
index c5418109..00000000
--- a/source/3d_primitives/plane.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-//
-// Created by Vlad on 8/28/2025.
-//
-#include "omath/3d_primitives/plane.hpp"
-
-namespace omath::primitives
-{
-    std::array<Triangle<Vector3<float>>, 2> create_plane(const Vector3<float>& vertex_a,
-                                                          const Vector3<float>& vertex_b,
-                                                          const Vector3<float>& direction, const float size) noexcept
-    {
-        const auto second_vertex_a = vertex_a + direction * size;
-        return std::array
-        {
-            Triangle{second_vertex_a, vertex_a, vertex_b},
-            Triangle{second_vertex_a, vertex_b + direction * size, vertex_b}
-        };
-    }
-} // namespace omath::primitives
\ No newline at end of file
diff --git a/source/collision/line_tracer.cpp b/source/collision/line_tracer.cpp
deleted file mode 100644
index 311c99a2..00000000
--- a/source/collision/line_tracer.cpp
+++ /dev/null
@@ -1,63 +0,0 @@
-//
-// Created by Orange on 11/13/2024.
-//
-#include "omath/collision/line_tracer.hpp"
-
-namespace omath::collision
-{
-    bool LineTracer::can_trace_line(const Ray& ray, const Triangle<Vector3<float>>& triangle) noexcept
-    {
-        return get_ray_hit_point(ray, triangle) == ray.end;
-    }
-    Vector3<float> Ray::direction_vector() const noexcept
-    {
-        return end - start;
-    }
-
-    Vector3<float> Ray::direction_vector_normalized() const noexcept
-    {
-        return direction_vector().normalized();
-    }
-
-    Vector3<float> LineTracer::get_ray_hit_point(const Ray& ray, const Triangle<Vector3<float>>& triangle) noexcept
-    {
-        constexpr float k_epsilon = std::numeric_limits<float>::epsilon();
-
-        const auto side_a = triangle.side_a_vector();
-        const auto side_b = triangle.side_b_vector();
-
-        const auto ray_dir = ray.direction_vector();
-
-        const auto p = ray_dir.cross(side_b);
-        const auto det = side_a.dot(p);
-
-        if (std::abs(det) < k_epsilon)
-            return ray.end;
-
-        const auto inv_det = 1.0f / det;
-        const auto t = ray.start - triangle.m_vertex2;
-        const auto u = t.dot(p) * inv_det;
-
-        if ((u < 0 && std::abs(u) > k_epsilon) || (u > 1 && std::abs(u - 1) > k_epsilon))
-            return ray.end;
-
-        const auto q = t.cross(side_a);
-        // ReSharper disable once CppTooWideScopeInitStatement
-        const auto v = ray_dir.dot(q) * inv_det;
-
-        if ((v < 0 && std::abs(v) > k_epsilon) || (u + v > 1 && std::abs(u + v - 1) > k_epsilon))
-            return ray.end;
-
-        const auto t_hit = side_b.dot(q) * inv_det;
-
-        if (ray.infinite_length)
-        {
-            if (t_hit <= k_epsilon)
-                return ray.end;
-        }
-        else if (t_hit <= k_epsilon || t_hit > 1.0f - k_epsilon)
-            return ray.end;
-
-        return ray.start + ray_dir * t_hit;
-    }
-} // namespace omath::collision
diff --git a/source/engines/iw_engine/traits/camera_trait.cpp b/source/engines/iw_engine/traits/camera_trait.cpp
deleted file mode 100644
index 6619751d..00000000
--- a/source/engines/iw_engine/traits/camera_trait.cpp
+++ /dev/null
@@ -1,27 +0,0 @@
-//
-// Created by Vlad on 8/11/2025.
-//
-#include "omath/engines/iw_engine/traits/camera_trait.hpp"
-#include "omath/engines/iw_engine/formulas.hpp"
-namespace omath::iw_engine
-{
-
-    ViewAngles CameraTrait::calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept
-    {
-        const auto distance = cam_origin.distance_to(look_at);
-        const auto delta = cam_origin - look_at;
-
-        return {PitchAngle::from_radians(-std::asin(delta.z / distance)),
-                YawAngle::from_radians(std::atan2(delta.y, delta.x)), RollAngle::from_radians(0.f)};
-    }
-    Mat4X4 CameraTrait::calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
-    {
-        return iw_engine::calc_view_matrix(angles, cam_origin);
-    }
-    Mat4X4 CameraTrait::calc_projection_matrix(const projection::FieldOfView& fov,
-                                               const projection::ViewPort& view_port, const float near,
-                                               const float far) noexcept
-    {
-        return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far);
-    }
-} // namespace omath::iw_engine
\ No newline at end of file
diff --git a/source/engines/opengl_engine/traits/camera_trait.cpp b/source/engines/opengl_engine/traits/camera_trait.cpp
deleted file mode 100644
index 98f886df..00000000
--- a/source/engines/opengl_engine/traits/camera_trait.cpp
+++ /dev/null
@@ -1,28 +0,0 @@
-//
-// Created by Vlad on 8/11/2025.
-//
-#include "omath/engines/opengl_engine/traits/camera_trait.hpp"
-#include "omath/engines/opengl_engine/formulas.hpp"
-
-namespace omath::opengl_engine
-{
-
-    ViewAngles CameraTrait::calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept
-    {
-        const auto distance = cam_origin.distance_to(look_at);
-        const auto delta = cam_origin - look_at;
-
-        return {PitchAngle::from_radians(-std::asin(delta.y / distance)),
-                YawAngle::from_radians(std::atan2(delta.z, delta.x)), RollAngle::from_radians(0.f)};
-    }
-    Mat4X4 CameraTrait::calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
-    {
-        return opengl_engine::calc_view_matrix(angles, cam_origin);
-    }
-    Mat4X4 CameraTrait::calc_projection_matrix(const projection::FieldOfView& fov,
-                                               const projection::ViewPort& view_port, const float near,
-                                               const float far) noexcept
-    {
-        return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far);
-    }
-} // namespace omath::opengl_engine
\ No newline at end of file
diff --git a/source/engines/source_engine/traits/camera_trait.cpp b/source/engines/source_engine/traits/camera_trait.cpp
deleted file mode 100644
index 688ee3b2..00000000
--- a/source/engines/source_engine/traits/camera_trait.cpp
+++ /dev/null
@@ -1,27 +0,0 @@
-//
-// Created by Vlad on 8/11/2025.
-//
-#include "omath/engines/source_engine/traits/camera_trait.hpp"
-#include "omath/engines/source_engine/formulas.hpp"
-namespace omath::source_engine
-{
-
-    ViewAngles CameraTrait::calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept
-    {
-        const auto distance = cam_origin.distance_to(look_at);
-        const auto delta = cam_origin - look_at;
-
-        return {PitchAngle::from_radians(-std::asin(delta.z / distance)),
-                YawAngle::from_radians(std::atan2(delta.y, delta.x)), RollAngle::from_radians(0.f)};
-    }
-    Mat4X4 CameraTrait::calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
-    {
-        return source_engine::calc_view_matrix(angles, cam_origin);
-    }
-    Mat4X4 CameraTrait::calc_projection_matrix(const projection::FieldOfView& fov,
-                                               const projection::ViewPort& view_port, const float near,
-                                               const float far) noexcept
-    {
-        return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far);
-    }
-} // namespace omath::source_engine
\ No newline at end of file
diff --git a/source/engines/unity_engine/traits/camera_trait.cpp b/source/engines/unity_engine/traits/camera_trait.cpp
deleted file mode 100644
index d76426b7..00000000
--- a/source/engines/unity_engine/traits/camera_trait.cpp
+++ /dev/null
@@ -1,27 +0,0 @@
-//
-// Created by Vlad on 8/11/2025.
-//
-#include "omath/engines/unity_engine/traits/camera_trait.hpp"
-
-namespace omath::unity_engine
-{
-
-    ViewAngles CameraTrait::calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept
-    {
-        const auto distance = cam_origin.distance_to(look_at);
-        const auto delta = cam_origin - look_at;
-
-        return {PitchAngle::from_radians(-std::asin(delta.y / distance)),
-                YawAngle::from_radians(std::atan2(delta.z, delta.x)), RollAngle::from_radians(0.f)};
-    }
-    Mat4X4 CameraTrait::calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
-    {
-        return unity_engine::calc_view_matrix(angles, cam_origin);
-    }
-    Mat4X4 CameraTrait::calc_projection_matrix(const projection::FieldOfView& fov,
-                                               const projection::ViewPort& view_port, const float near,
-                                               const float far) noexcept
-    {
-        return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far);
-    }
-} // namespace omath::unity_engine
\ No newline at end of file
diff --git a/source/engines/unreal_engine/traits/camera_trait.cpp b/source/engines/unreal_engine/traits/camera_trait.cpp
deleted file mode 100644
index 5eb81262..00000000
--- a/source/engines/unreal_engine/traits/camera_trait.cpp
+++ /dev/null
@@ -1,27 +0,0 @@
-//
-// Created by Vlad on 8/11/2025.
-//
-#include "omath/engines/unreal_engine/traits/camera_trait.hpp"
-
-namespace omath::unreal_engine
-{
-
-    ViewAngles CameraTrait::calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept
-    {
-        const auto distance = cam_origin.distance_to(look_at);
-        const auto delta = cam_origin - look_at;
-
-        return {PitchAngle::from_radians(-std::asin(delta.z / distance)),
-                YawAngle::from_radians(std::atan2(delta.x, delta.y)), RollAngle::from_radians(0.f)};
-    }
-    Mat4X4 CameraTrait::calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
-    {
-        return unreal_engine::calc_view_matrix(angles, cam_origin);
-    }
-    Mat4X4 CameraTrait::calc_projection_matrix(const projection::FieldOfView& fov,
-                                               const projection::ViewPort& view_port, const float near,
-                                               const float far) noexcept
-    {
-        return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far);
-    }
-} // namespace omath::unreal_engine
\ No newline at end of file
diff --git a/source/matrix.cpp b/source/matrix.cpp
deleted file mode 100644
index 322ea967..00000000
--- a/source/matrix.cpp
+++ /dev/null
@@ -1,364 +0,0 @@
-#ifdef OMATH_ENABLE_LEGACY
-
-#include "omath/matrix.hpp"
-#include "omath/angles.hpp"
-#include "omath/vector3.hpp"
-#include <complex>
-#include <format>
-#include <stdexcept>
-#include <utility>
-
-namespace omath
-{
-    Matrix::Matrix(const size_t rows, const size_t columns)
-    {
-        if (rows == 0 and columns == 0)
-            throw std::runtime_error("Matrix cannot be 0x0");
-
-        m_rows = rows;
-        m_columns = columns;
-
-        m_data = std::make_unique<float[]>(m_rows * m_columns);
-
-        set(0.f);
-    }
-
-    Matrix::Matrix(const std::initializer_list<std::initializer_list<float>>& rows)
-    {
-        m_rows = rows.size();
-        m_columns = rows.begin()->size();
-
-        for (const auto& row: rows)
-            if (row.size() != m_columns)
-                throw std::invalid_argument("All rows must have the same number of columns.");
-
-        m_data = std::make_unique<float[]>(m_rows * m_columns);
-
-        size_t i = 0;
-        for (const auto& row: rows)
-        {
-            size_t j = 0;
-            for (const auto& value: row)
-                at(i, j++) = value;
-            ++i;
-        }
-    }
-
-    Matrix::Matrix(const Matrix& other)
-    {
-        m_rows = other.m_rows;
-        m_columns = other.m_columns;
-
-        m_data = std::make_unique<float[]>(m_rows * m_columns);
-
-        for (size_t i = 0; i < m_rows; ++i)
-            for (size_t j = 0; j < m_columns; ++j)
-                at(i, j) = other.at(i, j);
-    }
-
-    Matrix::Matrix(const size_t rows, const size_t columns, const float* raw_data)
-    {
-        m_rows = rows;
-        m_columns = columns;
-
-        m_data = std::make_unique<float[]>(m_rows * m_columns);
-
-        for (size_t i = 0; i < rows * columns; ++i)
-            at(i / rows, i % columns) = raw_data[i];
-    }
-
-    size_t Matrix::row_count() const noexcept
-    {
-        return m_rows;
-    }
-
-    float& Matrix::operator[](const size_t row, const size_t column)
-    {
-        return at(row, column);
-    }
-
-    Matrix::Matrix(Matrix&& other) noexcept
-    {
-        m_rows = other.m_rows;
-        m_columns = other.m_columns;
-        m_data = std::move(other.m_data);
-
-        other.m_rows = 0;
-        other.m_columns = 0;
-
-        other.m_data = nullptr;
-    }
-
-    size_t Matrix::columns_count() const noexcept
-    {
-        return m_columns;
-    }
-
-    std::pair<size_t, size_t> Matrix::size() const noexcept
-    {
-        return {row_count(), columns_count()};
-    }
-
-    float& Matrix::at(const size_t row, const size_t col)
-    {
-        return const_cast<float&>(std::as_const(*this).at(row, col));
-    }
-
-    float Matrix::sum()
-    {
-        float sum = 0;
-
-        for (size_t i = 0; i < row_count(); i++)
-            for (size_t j = 0; j < columns_count(); j++)
-                sum += at(i, j);
-
-        return sum;
-    }
-
-    const float& Matrix::at(const size_t row, const size_t col) const
-    {
-        return m_data[row * m_columns + col];
-    }
-
-    Matrix Matrix::operator*(const Matrix& other) const
-    {
-        if (m_columns != other.m_rows)
-            throw std::runtime_error("n != m");
-
-        auto out_mat = Matrix(m_rows, other.m_columns);
-
-        for (size_t d = 0; d < m_rows; ++d)
-            for (size_t i = 0; i < other.m_columns; ++i)
-                for (size_t j = 0; j < other.m_rows; ++j)
-                    out_mat.at(d, i) += at(d, j) * other.at(j, i);
-
-        return out_mat;
-    }
-
-    Matrix& Matrix::operator*=(const Matrix& other)
-    {
-        *this = *this * other;
-        return *this;
-    }
-
-    Matrix Matrix::operator*(const float f) const
-    {
-        auto out = *this;
-        for (size_t i = 0; i < m_rows; ++i)
-            for (size_t j = 0; j < m_columns; ++j)
-                out.at(i, j) *= f;
-
-        return out;
-    }
-
-    Matrix& Matrix::operator*=(const float f)
-    {
-        for (size_t i = 0; i < row_count(); i++)
-            for (size_t j = 0; j < columns_count(); j++)
-                at(i, j) *= f;
-        return *this;
-    }
-
-    void Matrix::clear()
-    {
-        set(0.f);
-    }
-
-    Matrix& Matrix::operator=(const Matrix& other)
-    {
-        if (this == &other)
-            return *this;
-
-        for (size_t i = 0; i < m_rows; ++i)
-            for (size_t j = 0; j < m_columns; ++j)
-                at(i, j) = other.at(i, j);
-
-        return *this;
-    }
-
-    Matrix& Matrix::operator=(Matrix&& other) noexcept
-    {
-        if (this == &other)
-            return *this;
-
-        m_rows = other.m_rows;
-        m_columns = other.m_columns;
-        m_data = std::move(other.m_data);
-
-        other.m_rows = 0;
-        other.m_columns = 0;
-
-        return *this;
-    }
-
-    Matrix& Matrix::operator/=(const float f)
-    {
-        for (size_t i = 0; i < m_rows; ++i)
-            for (size_t j = 0; j < m_columns; ++j)
-                at(i, j) /= f;
-
-        return *this;
-    }
-
-    Matrix Matrix::operator/(const float f) const
-    {
-        auto out = *this;
-        for (size_t i = 0; i < m_rows; ++i)
-            for (size_t j = 0; j < m_columns; ++j)
-                out.at(i, j) /= f;
-
-        return out;
-    }
-
-    std::string Matrix::to_string() const
-    {
-        std::string str;
-
-        for (size_t i = 0; i < m_rows; i++)
-        {
-            for (size_t j = 0; j < m_columns; ++j)
-            {
-                str += std::format("{:.1f}", at(i, j));
-
-                if (j == m_columns - 1)
-                    str += '\n';
-                else
-                    str += ' ';
-            }
-        }
-        return str;
-    }
-
-    float Matrix::determinant() const // NOLINT(*-no-recursion)
-    {
-        if (m_rows + m_columns == 2)
-            return at(0, 0);
-
-        if (m_rows == 2 and m_columns == 2)
-            return at(0, 0) * at(1, 1) - at(0, 1) * at(1, 0);
-
-        float det = 0;
-        for (size_t i = 0; i < m_columns; i++)
-            det += alg_complement(0, i) * at(0, i);
-
-        return det;
-    }
-
-    float Matrix::alg_complement(const size_t i, const size_t j) const // NOLINT(*-no-recursion)
-    {
-        const auto tmp = minor(i, j);
-        return ((i + j + 2) % 2 == 0) ? tmp : -tmp;
-    }
-
-    Matrix Matrix::transpose() const
-    {
-        Matrix transposed = {m_columns, m_rows};
-
-        for (size_t i = 0; i < m_rows; ++i)
-            for (size_t j = 0; j < m_columns; ++j)
-                transposed.at(j, i) = at(i, j);
-
-        return transposed;
-    }
-
-    Matrix::~Matrix() = default;
-
-    void Matrix::set(const float val)
-    {
-        for (size_t i = 0; i < m_rows; ++i)
-            for (size_t j = 0; j < m_columns; ++j)
-                at(i, j) = val;
-    }
-
-    Matrix Matrix::strip(const size_t row, const size_t column) const
-    {
-        Matrix stripped = {m_rows - 1, m_columns - 1};
-        size_t strip_row_index = 0;
-
-        for (size_t i = 0; i < m_rows; i++)
-        {
-            if (i == row)
-                continue;
-
-            size_t strip_column_index = 0;
-            for (size_t j = 0; j < m_columns; ++j)
-            {
-                if (j == column)
-                    continue;
-
-                stripped.at(strip_row_index, strip_column_index) = at(i, j);
-                strip_column_index++;
-            }
-
-            strip_row_index++;
-        }
-
-        return stripped;
-    }
-
-    float Matrix::minor(const size_t i, const size_t j) const // NOLINT(*-no-recursion)
-    {
-        return strip(i, j).determinant();
-    }
-
-    Matrix Matrix::to_screen_matrix(const float screen_width, const float screen_height)
-    {
-        return {
-                {screen_width / 2.f, 0.f, 0.f, 0.f},
-                {0.f, -screen_height / 2.f, 0.f, 0.f},
-                {0.f, 0.f, 1.f, 0.f},
-                {screen_width / 2.f, screen_height / 2.f, 0.f, 1.f},
-        };
-    }
-
-    Matrix Matrix::translation_matrix(const Vector3<float>& diff)
-    {
-        return {
-                {1.f, 0.f, 0.f, 0.f},
-                {0.f, 1.f, 0.f, 0.f},
-                {0.f, 0.f, 1.f, 0.f},
-                {diff.x, diff.y, diff.z, 1.f},
-        };
-    }
-
-    Matrix Matrix::orientation_matrix(const Vector3<float>& forward, const Vector3<float>& right,
-                                      const Vector3<float>& up)
-    {
-        return {
-                {right.x, up.x, forward.x, 0.f},
-                {right.y, up.y, forward.y, 0.f},
-                {right.z, up.z, forward.z, 0.f},
-                {0.f, 0.f, 0.f, 1.f},
-        };
-    }
-
-    Matrix Matrix::projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
-                                     const float far)
-    {
-        const float fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / 2.f);
-
-        return {{1.f / (aspect_ratio * fov_half_tan), 0.f, 0.f, 0.f},
-                {0.f, 1.f / fov_half_tan, 0.f, 0.f},
-                {0.f, 0.f, (far + near) / (far - near), 2.f * near * far / (far - near)},
-                {0.f, 0.f, -1.f, 0.f}};
-    }
-
-    const float* Matrix::raw() const
-    {
-        return m_data.get();
-    }
-
-    void Matrix::set_data_from_raw(const float* raw_matrix)
-    {
-        for (size_t i = 0; i < m_columns * m_rows; ++i)
-            at(i / m_rows, i % m_columns) = raw_matrix[i];
-    }
-
-    Matrix::Matrix()
-    {
-        m_columns = 0;
-        m_rows = 0;
-        m_data = nullptr;
-    }
-} // namespace omath
-#endif
diff --git a/source/pathfinding/a_star.cpp b/source/pathfinding/a_star.cpp
deleted file mode 100644
index bcd73484..00000000
--- a/source/pathfinding/a_star.cpp
+++ /dev/null
@@ -1,99 +0,0 @@
-//
-// Created by Vlad on 28.07.2024.
-//
-#include "omath/pathfinding/a_star.hpp"
-#include <algorithm>
-#include <optional>
-#include <unordered_map>
-#include <unordered_set>
-
-namespace omath::pathfinding
-{
-    struct PathNode final
-    {
-        std::optional<Vector3<float>> came_from;
-        float g_cost = 0.f;
-    };
-
-    std::vector<Vector3<float>>
-    Astar::reconstruct_final_path(const std::unordered_map<Vector3<float>, PathNode>& closed_list,
-                                  const Vector3<float>& current) noexcept
-    {
-        std::vector<Vector3<float>> path;
-        std::optional current_opt = current;
-
-        while (current_opt)
-        {
-            path.push_back(*current_opt);
-
-            auto it = closed_list.find(*current_opt);
-
-            if (it == closed_list.end())
-                break;
-
-            current_opt = it->second.came_from;
-        }
-
-        std::ranges::reverse(path);
-        return path;
-    }
-    auto Astar::get_perfect_node(const std::unordered_map<Vector3<float>, PathNode>& open_list,
-                                 const Vector3<float>& end_vertex) noexcept
-    {
-        return std::ranges::min_element(open_list,
-                                        [&end_vertex](const auto& a, const auto& b)
-                                        {
-                                            const float fa = a.second.g_cost + a.first.distance_to(end_vertex);
-                                            const float fb = b.second.g_cost + b.first.distance_to(end_vertex);
-                                            return fa < fb;
-                                        });
-    }
-
-    std::vector<Vector3<float>> Astar::find_path(const Vector3<float>& start, const Vector3<float>& end,
-                                                 const NavigationMesh& nav_mesh) noexcept
-    {
-        std::unordered_map<Vector3<float>, PathNode> closed_list;
-        std::unordered_map<Vector3<float>, PathNode> open_list;
-
-        auto maybe_start_vertex = nav_mesh.get_closest_vertex(start);
-        auto maybe_end_vertex = nav_mesh.get_closest_vertex(end);
-
-        if (!maybe_start_vertex || !maybe_end_vertex)
-            return {};
-
-        const auto start_vertex = maybe_start_vertex.value();
-        const auto end_vertex = maybe_end_vertex.value();
-
-        open_list.emplace(start_vertex, PathNode{std::nullopt, 0.f});
-
-        while (!open_list.empty())
-        {
-            auto current_it = get_perfect_node(open_list, end_vertex);
-
-            const auto current = current_it->first;
-            const auto current_node = current_it->second;
-
-            if (current == end_vertex)
-                return reconstruct_final_path(closed_list, current);
-
-            closed_list.emplace(current, current_node);
-            open_list.erase(current_it);
-
-            for (const auto& neighbor: nav_mesh.get_neighbors(current))
-            {
-                if (closed_list.contains(neighbor))
-                    continue;
-
-                const float tentative_g_cost = current_node.g_cost + neighbor.distance_to(current);
-
-                // ReSharper disable once CppTooWideScopeInitStatement
-                const auto open_it = open_list.find(neighbor);
-
-                if (open_it == open_list.end() || tentative_g_cost < open_it->second.g_cost)
-                    open_list[neighbor] = PathNode{current, tentative_g_cost};
-            }
-        }
-
-        return {};
-    }
-} // namespace omath::pathfinding
diff --git a/source/pathfinding/navigation_mesh.cpp b/source/pathfinding/navigation_mesh.cpp
deleted file mode 100644
index b2a831b0..00000000
--- a/source/pathfinding/navigation_mesh.cpp
+++ /dev/null
@@ -1,91 +0,0 @@
-//
-// Created by Vlad on 28.07.2024.
-//
-#include "omath/pathfinding/navigation_mesh.hpp"
-#include <algorithm>
-#include <stdexcept>
-namespace omath::pathfinding
-{
-    std::expected<Vector3<float>, std::string>
-    NavigationMesh::get_closest_vertex(const Vector3<float>& point) const noexcept
-    {
-        const auto res = std::ranges::min_element(m_vertex_map, [&point](const auto& a, const auto& b)
-                                                  { return a.first.distance_to(point) < b.first.distance_to(point); });
-
-        if (res == m_vertex_map.cend())
-            return std::unexpected("Failed to get clossest point");
-
-        return res->first;
-    }
-
-    const std::vector<Vector3<float>>& NavigationMesh::get_neighbors(const Vector3<float>& vertex) const noexcept
-    {
-        return m_vertex_map.at(vertex);
-    }
-
-    bool NavigationMesh::empty() const
-    {
-        return m_vertex_map.empty();
-    }
-
-    std::vector<uint8_t> NavigationMesh::serialize() const noexcept
-    {
-        auto dump_to_vector = []<typename T>(const T& t, std::vector<uint8_t>& vec)
-        {
-            for (size_t i = 0; i < sizeof(t); i++)
-                vec.push_back(*(reinterpret_cast<const uint8_t*>(&t) + i));
-        };
-
-        std::vector<uint8_t> raw;
-
-        for (const auto& [vertex, neighbors]: m_vertex_map)
-        {
-            const auto neighbors_count = neighbors.size();
-
-            dump_to_vector(vertex, raw);
-            dump_to_vector(neighbors_count, raw);
-
-            for (const auto& neighbor: neighbors)
-                dump_to_vector(neighbor, raw);
-        }
-        return raw;
-    }
-
-    void NavigationMesh::deserialize(const std::vector<uint8_t>& raw) noexcept
-    {
-        auto load_from_vector = [](const std::vector<uint8_t>& vec, size_t& offset, auto& value)
-        {
-            if (offset + sizeof(value) > vec.size())
-            {
-                throw std::runtime_error("Deserialize: Invalid input data size.");
-            }
-            std::copy_n(vec.data() + offset, sizeof(value), reinterpret_cast<uint8_t*>(&value));
-            offset += sizeof(value);
-        };
-
-        m_vertex_map.clear();
-
-        size_t offset = 0;
-
-        while (offset < raw.size())
-        {
-            Vector3<float> vertex;
-            load_from_vector(raw, offset, vertex);
-
-            uint16_t neighbors_count;
-            load_from_vector(raw, offset, neighbors_count);
-
-            std::vector<Vector3<float>> neighbors;
-            neighbors.reserve(neighbors_count);
-
-            for (size_t i = 0; i < neighbors_count; ++i)
-            {
-                Vector3<float> neighbor;
-                load_from_vector(raw, offset, neighbor);
-                neighbors.push_back(neighbor);
-            }
-
-            m_vertex_map.emplace(vertex, std::move(neighbors));
-        }
-    }
-} // namespace omath::pathfinding
diff --git a/source/projectile_prediction/proj_pred_engine_avx2.cpp b/source/projectile_prediction/proj_pred_engine_avx2.cpp
deleted file mode 100644
index 9a26c435..00000000
--- a/source/projectile_prediction/proj_pred_engine_avx2.cpp
+++ /dev/null
@@ -1,158 +0,0 @@
-//
-// Created by Vlad on 2/23/2025.
-//
-#include "omath/projectile_prediction/proj_pred_engine_avx2.hpp"
-#include <source_location>
-#include <stdexcept>
-
-#if defined(OMATH_USE_AVX2) && defined(__i386__) && defined(__x86_64__)
-#include <immintrin.h>
-#else
-#include <format>
-#endif
-
-namespace omath::projectile_prediction
-{
-    std::optional<Vector3<float>>
-    ProjPredEngineAvx2::maybe_calculate_aim_point([[maybe_unused]] const Projectile& projectile,
-                                                  [[maybe_unused]] const Target& target) const
-    {
-#if defined(OMATH_USE_AVX2) && defined(__i386__) && defined(__x86_64__)
-        const float bulletGravity = m_gravityConstant * projectile.m_gravityScale;
-        const float v0 = projectile.m_launchSpeed;
-        const float v0Sqr = v0 * v0;
-        const Vector3 projOrigin = projectile.m_origin;
-
-        constexpr int SIMD_FACTOR = 8;
-        float currentTime = m_simulationTimeStep;
-
-        for (; currentTime <= m_maximumSimulationTime; currentTime += m_simulationTimeStep * SIMD_FACTOR)
-        {
-            const __m256 times
-                    = _mm256_setr_ps(currentTime, currentTime + m_simulationTimeStep,
-                                     currentTime + m_simulationTimeStep * 2, currentTime + m_simulationTimeStep * 3,
-                                     currentTime + m_simulationTimeStep * 4, currentTime + m_simulationTimeStep * 5,
-                                     currentTime + m_simulationTimeStep * 6, currentTime + m_simulationTimeStep * 7);
-
-            const __m256 targetX
-                    = _mm256_fmadd_ps(_mm256_set1_ps(target.m_velocity.x), times, _mm256_set1_ps(target.m_origin.x));
-            const __m256 targetY
-                    = _mm256_fmadd_ps(_mm256_set1_ps(target.m_velocity.y), times, _mm256_set1_ps(target.m_origin.y));
-            const __m256 timesSq = _mm256_mul_ps(times, times);
-            const __m256 targetZ = _mm256_fmadd_ps(_mm256_set1_ps(target.m_velocity.z), times,
-                                                   _mm256_fnmadd_ps(_mm256_set1_ps(0.5f * m_gravityConstant), timesSq,
-                                                                    _mm256_set1_ps(target.m_origin.z)));
-
-            const __m256 deltaX = _mm256_sub_ps(targetX, _mm256_set1_ps(projOrigin.x));
-            const __m256 deltaY = _mm256_sub_ps(targetY, _mm256_set1_ps(projOrigin.y));
-            const __m256 deltaZ = _mm256_sub_ps(targetZ, _mm256_set1_ps(projOrigin.z));
-
-            const __m256 dSqr = _mm256_add_ps(_mm256_mul_ps(deltaX, deltaX), _mm256_mul_ps(deltaY, deltaY));
-
-            const __m256 bgTimesSq = _mm256_mul_ps(_mm256_set1_ps(bulletGravity), timesSq);
-            const __m256 term = _mm256_add_ps(deltaZ, _mm256_mul_ps(_mm256_set1_ps(0.5f), bgTimesSq));
-            const __m256 termSq = _mm256_mul_ps(term, term);
-            const __m256 numerator = _mm256_add_ps(dSqr, termSq);
-            const __m256 denominator = _mm256_add_ps(timesSq, _mm256_set1_ps(1e-8f)); // Avoid division by zero
-            const __m256 requiredV0Sqr = _mm256_div_ps(numerator, denominator);
-
-            const __m256 v0SqrVec = _mm256_set1_ps(v0Sqr + 1e-3f);
-            const __m256 mask = _mm256_cmp_ps(requiredV0Sqr, v0SqrVec, _CMP_LE_OQ);
-
-            const unsigned validMask = _mm256_movemask_ps(mask);
-
-            if (!validMask)
-                continue;
-
-            alignas(32) float validTimes[SIMD_FACTOR];
-            _mm256_store_ps(validTimes, times);
-
-            for (int i = 0; i < SIMD_FACTOR; ++i)
-            {
-                if (!(validMask & (1 << i)))
-                    continue;
-
-                const float candidateTime = validTimes[i];
-
-                if (candidateTime > m_maximumSimulationTime)
-                    continue;
-
-                // Fine search around candidate time
-                for (float fineTime = candidateTime - m_simulationTimeStep * 2;
-                     fineTime <= candidateTime + m_simulationTimeStep * 2; fineTime += m_simulationTimeStep)
-                {
-                    if (fineTime < 0)
-                        continue;
-
-                    const Vector3 targetPos = target.PredictPosition(fineTime, m_gravityConstant);
-                    const auto pitch = CalculatePitch(projOrigin, targetPos, bulletGravity, v0, fineTime);
-                    if (!pitch)
-                        continue;
-
-                    const Vector3 delta = targetPos - projOrigin;
-                    const float d = std::sqrt(delta.x * delta.x + delta.y * delta.y);
-                    const float height = d * std::tan(angles::DegreesToRadians(*pitch));
-                    return Vector3(targetPos.x, targetPos.y, projOrigin.z + height);
-                }
-            }
-        }
-
-        // Fallback scalar processing for remaining times
-        for (; currentTime <= m_maximumSimulationTime; currentTime += m_simulationTimeStep)
-        {
-            const Vector3 targetPos = target.PredictPosition(currentTime, m_gravityConstant);
-            const auto pitch = CalculatePitch(projOrigin, targetPos, bulletGravity, v0, currentTime);
-            if (!pitch)
-                continue;
-
-            const Vector3 delta = targetPos - projOrigin;
-            const float d = std::sqrt(delta.x * delta.x + delta.y * delta.y);
-            const float height = d * std::tan(angles::DegreesToRadians(*pitch));
-            return Vector3(targetPos.x, targetPos.y, projOrigin.z + height);
-        }
-
-        return std::nullopt;
-#else
-        throw std::runtime_error(
-                std::format("{} AVX2 feature is not enabled!", std::source_location::current().function_name()));
-#endif
-    }
-    ProjPredEngineAvx2::ProjPredEngineAvx2(const float gravity_constant, const float simulation_time_step,
-                                           const float maximum_simulation_time)
-        : m_gravity_constant(gravity_constant), m_simulation_time_step(simulation_time_step),
-          m_maximum_simulation_time(maximum_simulation_time)
-    {
-    }
-    std::optional<float> ProjPredEngineAvx2::calculate_pitch([[maybe_unused]] const Vector3<float>& proj_origin,
-                                                             [[maybe_unused]] const Vector3<float>& target_pos,
-                                                             [[maybe_unused]] const float bullet_gravity,
-                                                             [[maybe_unused]] const float v0,
-                                                             [[maybe_unused]] const float time)
-    {
-#if defined(OMATH_USE_AVX2) && defined(__i386__) && defined(__x86_64__)
-        if (time <= 0.0f)
-            return std::nullopt;
-
-        const Vector3 delta = target_pos - proj_origin;
-        const float dSqr = delta.x * delta.x + delta.y * delta.y;
-        const float h = delta.z;
-
-        const float term = h + 0.5f * bullet_gravity * time * time;
-        const float requiredV0Sqr = (dSqr + term * term) / (time * time);
-        const float v0Sqr = v0 * v0;
-
-        if (requiredV0Sqr > v0Sqr + 1e-3f)
-            return std::nullopt;
-
-        if (dSqr == 0.0f)
-            return term >= 0.0f ? 90.0f : -90.0f;
-
-        const float d = std::sqrt(dSqr);
-        const float tanTheta = term / d;
-        return angles::RadiansToDegrees(std::atan(tanTheta));
-#else
-        throw std::runtime_error(
-                std::format("{} AVX2 feature is not enabled!", std::source_location::current().function_name()));
-#endif
-    }
-} // namespace omath::projectile_prediction
diff --git a/tests/engines/unit_test_iw_engine.cpp b/tests/engines/unit_test_iw_engine.cpp
index 199fa9b2..87cd2f61 100644
--- a/tests/engines/unit_test_iw_engine.cpp
+++ b/tests/engines/unit_test_iw_engine.cpp
@@ -2,10 +2,10 @@
 // Created by Vlad on 3/17/2025.
 //
 #include <gtest/gtest.h>
-#include <omath/engines/iw_engine/camera.hpp>
-#include <omath/engines/iw_engine/constants.hpp>
-#include <omath/engines/iw_engine/formulas.hpp>
-
+import omath.iw_engine.constants;
+import omath.iw_engine.formulas;
+import omath.iw_engine.camera;
+import omath.camera;
 
 TEST(unit_test_iw_engine, ForwardVector)
 {
diff --git a/tests/engines/unit_test_open_gl.cpp b/tests/engines/unit_test_open_gl.cpp
index 89506e61..be3238c5 100644
--- a/tests/engines/unit_test_open_gl.cpp
+++ b/tests/engines/unit_test_open_gl.cpp
@@ -2,9 +2,10 @@
 // Created by Orange on 11/23/2024.
 //
 #include <gtest/gtest.h>
-#include <omath/engines/opengl_engine/camera.hpp>
-#include <omath/engines/opengl_engine/constants.hpp>
-#include <omath/engines/opengl_engine/formulas.hpp>
+
+import omath.opengl_engine.camera;
+import omath.opengl_engine.constants;
+import omath.opengl_engine.formulas;
 
 
 TEST(unit_test_opengl, ForwardVector)
diff --git a/tests/engines/unit_test_source_engine.cpp b/tests/engines/unit_test_source_engine.cpp
index 82dcc918..53f4a78d 100644
--- a/tests/engines/unit_test_source_engine.cpp
+++ b/tests/engines/unit_test_source_engine.cpp
@@ -2,9 +2,11 @@
 // Created by Orange on 11/23/2024.
 //
 #include <gtest/gtest.h>
-#include <omath/engines/source_engine/camera.hpp>
-#include <omath/engines/source_engine/constants.hpp>
-#include <omath/engines/source_engine/formulas.hpp>
+
+import omath.source_engine.formulas;
+import omath.source_engine.constants;
+import omath.source_engine.camera;
+import omath.camera;
 
 
 TEST(unit_test_source_engine, ForwardVector)
diff --git a/tests/engines/unit_test_unity_engine.cpp b/tests/engines/unit_test_unity_engine.cpp
index 47ce136f..00e1fac4 100644
--- a/tests/engines/unit_test_unity_engine.cpp
+++ b/tests/engines/unit_test_unity_engine.cpp
@@ -2,11 +2,13 @@
 // Created by Orange on 11/27/2024.
 //
 #include <gtest/gtest.h>
-#include <omath/engines/unity_engine/camera.hpp>
-#include <omath/engines/unity_engine/constants.hpp>
-#include <omath/engines/unity_engine/formulas.hpp>
 #include <print>
 
+import omath.unity_engine.camera;
+import omath.unity_engine.formulas;
+import omath.unity_engine.constants;
+import omath.camera;
+
 TEST(unit_test_unity_engine, ForwardVector)
 {
     const auto forward = omath::unity_engine::forward_vector({});
diff --git a/tests/engines/unit_test_unreal_engine.cpp b/tests/engines/unit_test_unreal_engine.cpp
index 09912096..74e7d2c5 100644
--- a/tests/engines/unit_test_unreal_engine.cpp
+++ b/tests/engines/unit_test_unreal_engine.cpp
@@ -2,10 +2,10 @@
 // Created by Orange on 11/27/2024.
 //
 #include <gtest/gtest.h>
-#include <omath/engines/unreal_engine/camera.hpp>
-#include <omath/engines/unreal_engine/constants.hpp>
-#include <omath/engines/unreal_engine/formulas.hpp>
 #include <print>
+import omath.unreal_engine.formulas;
+import omath.unreal_engine.constants;
+import omath.unreal_engine.camera;
 
 TEST(unit_test_unreal_engine, ForwardVector)
 {
diff --git a/tests/general/unit_test_a_star.cpp b/tests/general/unit_test_a_star.cpp
index 6c341c4f..bcdd0b54 100644
--- a/tests/general/unit_test_a_star.cpp
+++ b/tests/general/unit_test_a_star.cpp
@@ -2,8 +2,11 @@
 // Created by Vlad on 18.08.2024.
 //
 #include <gtest/gtest.h>
-#include <omath/pathfinding/a_star.hpp>
-
+#include <algorithm>
+#include <optional>
+#include <unordered_map>
+#include <vector>
+import omath.pathfinding.a_star;
 TEST(unit_test_a_star, finding_right_path)
 {
     omath::pathfinding::NavigationMesh mesh;
diff --git a/tests/general/unit_test_angles.cpp b/tests/general/unit_test_angles.cpp
index 94ba0eff..9395e441 100644
--- a/tests/general/unit_test_angles.cpp
+++ b/tests/general/unit_test_angles.cpp
@@ -2,27 +2,26 @@
 // Created by Orange on 11/30/2024.
 //
 #include <gtest/gtest.h>
-#include <omath/angles.hpp>
-
+import omath.angle;
 TEST(unit_test_angles, radians_to_deg)
 {
     constexpr float rad = 67;
 
-    EXPECT_NEAR(omath::angles::radians_to_degrees(rad), 3838.82f, 0.01f);
+    EXPECT_NEAR(omath::radians_to_degrees(rad), 3838.82f, 0.01f);
 }
 
 TEST(unit_test_angles, degrees_to_radians)
 {
     constexpr float degree = 90;
 
-    EXPECT_NEAR(omath::angles::degrees_to_radians(degree), 1.5708f, 0.01f);
+    EXPECT_NEAR(omath::degrees_to_radians(degree), 1.5708f, 0.01f);
 }
 
 TEST(unit_test_angles, horizontal_fov_to_verical)
 {
     constexpr float h_fov = 90;
     constexpr float aspect_ration = 16.0f / 9.0f;
-    const auto vertical_fov = omath::angles::horizontal_fov_to_vertical(h_fov, aspect_ration);
+    const auto vertical_fov = omath::horizontal_fov_to_vertical(h_fov, aspect_ration);
 
     EXPECT_NEAR(vertical_fov, 58.71f, 0.01f);
 }
@@ -31,19 +30,19 @@ TEST(unit_test_angles, vertical_to_horizontal)
 {
     constexpr float v_fov = 58.71;
     constexpr float aspect_ration = 16.0f / 9.0f;
-    const auto horizontal_fov = omath::angles::vertical_fov_to_horizontal(v_fov, aspect_ration);
+    const auto horizontal_fov = omath::vertical_fov_to_horizontal(v_fov, aspect_ration);
 
     EXPECT_NEAR(horizontal_fov, 89.99f, 0.01f);
 }
 TEST(unit_test_angles, wrap_angle)
 {
-    const float wrapped = omath::angles::wrap_angle(361.f, 0.f, 360.f);
+    const float wrapped = omath::wrap_angle(361.f, 0.f, 360.f);
 
     EXPECT_NEAR(wrapped, 1.f, 0.01f);
 }
 TEST(unit_test_angles, wrap_angle_negative_range)
 {
-    const float wrapped = omath::angles::wrap_angle(-90.f, 0.f, 360.f);
+    const float wrapped = omath::wrap_angle(-90.f, 0.f, 360.f);
 
     EXPECT_NEAR(wrapped, 270.f, 0.01f);
 }
\ No newline at end of file
diff --git a/tests/general/unit_test_box_primitive.cpp b/tests/general/unit_test_box_primitive.cpp
index 215f2229..78d636b2 100644
--- a/tests/general/unit_test_box_primitive.cpp
+++ b/tests/general/unit_test_box_primitive.cpp
@@ -2,5 +2,7 @@
 // Created by Vlad on 4/18/2025.
 //
 #include <gtest/gtest.h>
-#include <omath/3d_primitives/box.hpp>
+import omath.box;
+import omath.plane;
+
 
diff --git a/tests/general/unit_test_color.cpp b/tests/general/unit_test_color.cpp
index 0f0d332b..9f67a771 100644
--- a/tests/general/unit_test_color.cpp
+++ b/tests/general/unit_test_color.cpp
@@ -2,8 +2,9 @@
 // Created by Vlad on 01.09.2024.
 //
 #include <gtest/gtest.h>
-#include <omath/color.hpp>
 
+import omath.color;
+import omath.vector4;
 
 using namespace omath;
 
diff --git a/tests/general/unit_test_line_trace.cpp b/tests/general/unit_test_line_trace.cpp
index 31cb6a79..26daa016 100644
--- a/tests/general/unit_test_line_trace.cpp
+++ b/tests/general/unit_test_line_trace.cpp
@@ -2,12 +2,9 @@
 // Revised unit‑test suite for LineTracer (segment‑based Möller–Trumbore)
 // Pure ASCII: avoids non‑standard characters that MSVC rejects.
 //
-#include "omath/linear_algebra/vector3.hpp"
-#include "omath/collision/line_tracer.hpp"
-#include "omath/triangle.hpp"
 #include "gtest/gtest.h"
 #include <cmath>
-
+import omath.line_tracer;
 using namespace omath;
 using namespace omath::collision;
 
diff --git a/tests/general/unit_test_mat.cpp b/tests/general/unit_test_mat.cpp
index 3cbf3de4..4bc23c16 100644
--- a/tests/general/unit_test_mat.cpp
+++ b/tests/general/unit_test_mat.cpp
@@ -1,8 +1,9 @@
 // UnitTestMat.cpp
-#include "omath/linear_algebra/mat.hpp"
-#include "omath/linear_algebra/vector3.hpp"
+
 #include <gtest/gtest.h>
 
+import omath.mat;
+import omath.vector3;
 using namespace omath;
 
 class UnitTestMat : public ::testing::Test
diff --git a/tests/general/unit_test_prediction.cpp b/tests/general/unit_test_prediction.cpp
index 6fb054a5..4cad9254 100644
--- a/tests/general/unit_test_prediction.cpp
+++ b/tests/general/unit_test_prediction.cpp
@@ -1,14 +1,13 @@
 #include <gtest/gtest.h>
-#include <omath/projectile_prediction/proj_pred_engine_legacy.hpp>
-
+import omath.projectile_prediction.proj_pred_legacy;
 TEST(UnitTestPrediction, PredictionTest)
 {
     constexpr omath::projectile_prediction::Target target{
             .m_origin = {100, 0, 90}, .m_velocity = {0, 0, 0}, .m_is_airborne = false};
     constexpr omath::projectile_prediction::Projectile proj = {
             .m_origin = {3, 2, 1}, .m_launch_speed = 5000, .m_gravity_scale = 0.4};
-    const auto viewPoint =
-            omath::projectile_prediction::ProjPredEngineLegacy(400, 1.f / 1000.f, 50, 5.f).maybe_calculate_aim_point(proj, target);
+    const auto viewPoint = omath::projectile_prediction::ProjPredEngineLegacy(400, 1.f / 1000.f, 50, 5.f)
+                                   .maybe_calculate_aim_point(proj, target);
 
     const auto [pitch, yaw, _] = proj.m_origin.view_angle_to(viewPoint.value()).as_tuple();
 
diff --git a/tests/general/unit_test_projection.cpp b/tests/general/unit_test_projection.cpp
index a5ca9a74..9e2541c2 100644
--- a/tests/general/unit_test_projection.cpp
+++ b/tests/general/unit_test_projection.cpp
@@ -3,10 +3,12 @@
 //
 #include <complex>
 #include <gtest/gtest.h>
-#include <omath/engines/source_engine/camera.hpp>
-#include <omath/projection/camera.hpp>
 #include <print>
 
+import omath.source_engine.camera;
+import omath.angle;
+import omath.view_angles;
+
 TEST(UnitTestProjection, Projection)
 {
     constexpr auto fov = omath::Angle<float, 0.f, 180.f, omath::AngleFlags::Clamped>::from_degrees(90.f);
diff --git a/tests/general/unit_test_triangle.cpp b/tests/general/unit_test_triangle.cpp
index 643ecdc2..83882629 100644
--- a/tests/general/unit_test_triangle.cpp
+++ b/tests/general/unit_test_triangle.cpp
@@ -1,11 +1,10 @@
 //
 // Created by Orange on 1/6/2025.
 //
-#include "omath/triangle.hpp"
-#include "omath/linear_algebra/vector3.hpp"
 #include <cmath> // For std::sqrt, std::isinf, std::isnan
 #include <gtest/gtest.h>
 
+import omath.triangle;
 using namespace omath;
 
 class UnitTestTriangle : public ::testing::Test
diff --git a/tests/general/unit_test_vector2.cpp b/tests/general/unit_test_vector2.cpp
index a8f641d7..144be74d 100644
--- a/tests/general/unit_test_vector2.cpp
+++ b/tests/general/unit_test_vector2.cpp
@@ -2,11 +2,12 @@
 // Created by Vlad on 02.09.2024.
 //
 
-#include <omath/linear_algebra/vector2.hpp>
+#include <format>
 #include <cfloat> // For FLT_MAX and FLT_MIN
 #include <cmath> // For std::isinf and std::isnan
 #include <gtest/gtest.h>
 
+import omath.vector2;
 using namespace omath;
 
 class UnitTestVector2 : public ::testing::Test
diff --git a/tests/general/unit_test_vector3.cpp b/tests/general/unit_test_vector3.cpp
index f5cc9fb3..f39be7c4 100644
--- a/tests/general/unit_test_vector3.cpp
+++ b/tests/general/unit_test_vector3.cpp
@@ -2,12 +2,14 @@
 // Created by Vlad on 01.09.2024.
 //
 
-#include <omath/linear_algebra/vector3.hpp>
+#include <format>
 #include <cfloat> // For FLT_MAX, FLT_MIN
 #include <cmath>
 #include <gtest/gtest.h>
 #include <limits> // For std::numeric_limits
 
+import omath.vector3;
+
 using namespace omath;
 
 class UnitTestVector3 : public ::testing::Test
diff --git a/tests/general/unit_test_vector4.cpp b/tests/general/unit_test_vector4.cpp
index d274f7a5..2a1d3fbf 100644
--- a/tests/general/unit_test_vector4.cpp
+++ b/tests/general/unit_test_vector4.cpp
@@ -5,10 +5,10 @@
 // Vector4Test.cpp
 //
 
-#include <omath/linear_algebra/vector4.hpp>
 #include <gtest/gtest.h>
 #include <limits> // For std::numeric_limits
 
+import omath.vector4;
 using namespace omath;
 
 class UnitTestVector4 : public ::testing::Test
diff --git a/tests/general/unit_test_view_angles.cpp b/tests/general/unit_test_view_angles.cpp
index 28605456..66bc0d12 100644
--- a/tests/general/unit_test_view_angles.cpp
+++ b/tests/general/unit_test_view_angles.cpp
@@ -1,4 +1,3 @@
 //
 // Created by Orange on 11/30/2024.
 //
-#include <omath/view_angles.hpp>
\ No newline at end of file