- More Documentation

- Updated Copyright

.gitignore

@@ -4,3 +4,4 @@
 /bin/
 /lib/
 /doxy/README.md
+/doxy/Doxyfile.out

CMakeLists.txt

@@ -1,6 +1,6 @@
 # ======================================================================================================================
 #  fennec, a free and open source game engine
-#  Copyright © 2025  Medusa Slockbower
+#  Copyright © 2025 - 2026  Medusa Slockbower
 #
 #  This program is free software: you can redistribute it and/or modify
 #  it under the terms of the GNU General Public License as published by
@@ -16,17 +16,45 @@
 #  along with this program.  If not, see <https://www.gnu.org/licenses/>.
 # ======================================================================================================================
 
-cmake_minimum_required(VERSION 3.30)
+cmake_minimum_required(VERSION 3.28...3.31)
+
 project(fennec)
+set(FENNEC_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+
+macro(fennec_add_sources)
+    list(APPEND FENNEC_SOURCES ${ARGN})
+endmacro()
+
+macro(fennec_add_definitions)
+    list(APPEND FENNEC_COMPILE_DEFINITIONS ${ARGN})
+endmacro()
+
+macro(fennec_add_link_libraries)
+    list(APPEND FENNEC_LINK_LIBRARIES ${ARGN})
+endmacro()
+
+macro(fennec_add_shared_libraries)
+    list(APPEND FENNEC_SHARED_LIBRARIES ${ARGN})
+endmacro()
+
+macro(fennec_add_compile_options)
+    list(APPEND FENNEC_PRIVATE_COMPILE_OPTIONS ${ARGN})
+endmacro()
+
+macro(fennec_add_link_options)
+    list(APPEND FENNEC_PRIVATE_LINK_OPTIONS ${ARGN})
+endmacro()
 
 # External dependencies should be loaded here
-
-# CppTrace is a dependency of the project, added as a git submodule
 add_subdirectory(external/cpptrace)
 
 set(CMAKE_CXX_STANDARD 23)
 set(CMAKE_C_STANDARD 23)
-set(FENNEC_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+
+add_custom_target(fennec-dependencies
+        COMMAND ${CMAKE_COMMAND} -E echo "Running dependencies."
+        COMMENT "Running dependencies."
+)
 
 # include scripts
 include("${FENNEC_SOURCE_DIR}/cmake/version.cmake")
@@ -47,83 +75,125 @@ include_directories(${FENNEC_SOURCE_DIR}/include)
 # Metaprogramming is a dependency for generating various type info before compilation of the engine.
 add_subdirectory(metaprogramming)
 
-
+# Specify where to send libraries and executables
 set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${FENNEC_SOURCE_DIR}/lib/${FENNEC_BUILD_NAME})
 set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${FENNEC_SOURCE_DIR}/lib/${FENNEC_BUILD_NAME})
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${FENNEC_SOURCE_DIR}/bin/${FENNEC_BUILD_NAME})
 
-# add the test suite as a sub-project
+# Core Files
-add_subdirectory(test)
+fennec_add_sources(
-
-add_library(fennec STATIC
-
 # CORE =================================================================================================================
         include/fennec/core/engine.h source/core/engine.cpp
         include/fennec/core/event.h  source/core/event.cpp
+        include/fennec/core/logger.h source/core/logger.cpp
 
+        include/fennec/core/version.h
         include/fennec/core/system.h
 
 
+
 # SCENE ================================================================================================================
-        include/fennec/scene/scene.h
+        include/fennec/scene/scene.h source/scene/scene.cpp
         include/fennec/scene/component.h
+        include/fennec/scene/scene_node.h
+        include/fennec/scene/node2d.h
+        include/fennec/scene/forward.h
+
+
+
+
+# RENDERERS ============================================================================================================
+        include/fennec/renderers/interface/forward.h
+
+        include/fennec/renderers/interface/gfxcontext.h
+        include/fennec/renderers/interface/gfxsurface.h
+
 
 
 # CONTAINERS ===========================================================================================================
         include/fennec/containers/containers.h
 
         include/fennec/containers/array.h
+        include/fennec/containers/bintree.h
+        include/fennec/containers/bitfield.h
         include/fennec/containers/deque.h
         include/fennec/containers/dynarray.h
+        include/fennec/containers/generic.h
         include/fennec/containers/graph.h
+        include/fennec/containers/initializer_list.h
         include/fennec/containers/list.h
         include/fennec/containers/map.h
         include/fennec/containers/object_pool.h
         include/fennec/containers/optional.h
         include/fennec/containers/pair.h
+        include/fennec/containers/priority_queue.h
         include/fennec/containers/rdtree.h
+        include/fennec/containers/sequence.h
         include/fennec/containers/set.h
         include/fennec/containers/traversal.h
         include/fennec/containers/tuple.h
+        include/fennec/containers/variant.h
 
 
         include/fennec/containers/detail/_tuple.h
 
 
-# LANG =================================================================================================================
+
+# lang =================================================================================================================
         include/fennec/lang/lang.h
         include/fennec/lang/metaprogramming.h
 
+
         include/fennec/lang/bits.h
         include/fennec/lang/constants.h
         include/fennec/lang/conditional_types.h
+        include/fennec/lang/declval.h
+        include/fennec/lang/function.h
         include/fennec/lang/hashing.h
         include/fennec/lang/intrinsics.h
         include/fennec/lang/limits.h
         include/fennec/lang/numeric_transforms.h
-        include/fennec/lang/const_sequences.h
+        include/fennec/lang/metasequences.h
-        include/fennec/lang/startup.h
+        include/fennec/lang/ranges.h
+        include/fennec/lang/static_constructor.h
         include/fennec/lang/type_identity.h
         include/fennec/lang/type_operators.h
         include/fennec/lang/type_sequences.h
         include/fennec/lang/type_traits.h
         include/fennec/lang/type_transforms.h
-        include/fennec/lang/typeuuid.h
         include/fennec/lang/types.h
         include/fennec/lang/utility.h
         include/fennec/lang/integer.h
 
         include/fennec/lang/assert.h source/lang/assert.cpp
 
-
         include/fennec/lang/detail/_bits.h
+        include/fennec/lang/detail/_declval.h
+        include/fennec/lang/detail/_function.h
         include/fennec/lang/detail/_int.h
         include/fennec/lang/detail/_numeric_transforms.h
         include/fennec/lang/detail/_stdlib.h
         include/fennec/lang/detail/_type_traits.h
         include/fennec/lang/detail/_type_transforms.h
         include/fennec/lang/detail/_type_sequences.h
-        include/fennec/lang/detail/_typeuuid.h
+
+
+# RTTI =================================================================================================================
+        include/fennec/rtti/typeid.h
+        include/fennec/rtti/type_data.h
+        include/fennec/rtti/type.h
+        include/fennec/rtti/enable.h
+        include/fennec/rtti/forward.h
+        include/fennec/rtti/typelist.h
+        include/fennec/rtti/type_registry.h
+        include/fennec/rtti/singleton.h
+
+
+        include/fennec/rtti/detail/_constants.h
+        include/fennec/rtti/detail/_this_t.h
+        include/fennec/rtti/detail/_typeid.h
+        include/fennec/rtti/detail/_type_name.h
+
 
 
 # MEMORY ===============================================================================================================
@@ -138,15 +208,13 @@ add_library(fennec STATIC
 
         include/fennec/memory/detail/_ptr_traits.h
 
-# CONCURRENCY ==========================================================================================================
+
-        include/fennec/concurrency/thread.h
-        include/fennec/concurrency/mutex.h
-        include/fennec/concurrency/atomic.h
 
 # DEBUG ================================================================================================================
         source/debug/assert_impl.cpp
 
 
+
 # MATH =================================================================================================================
         include/fennec/math/math.h
 
@@ -172,61 +240,107 @@ add_library(fennec STATIC
         include/fennec/math/ext/constants.h
         include/fennec/math/ext/primes.h
         include/fennec/math/ext/quaternion.h
+        include/fennec/math/ext/rect.h
         include/fennec/math/ext/transform.h
-        include/fennec/math/ext/trigonometric.h
 
 
-        include/fennec/math/detail/_fwd.h
+        include/fennec/math/detail/_forward.h
         include/fennec/math/detail/_math.h
         include/fennec/math/detail/_matrix.h
         include/fennec/math/detail/_types.h
         include/fennec/math/detail/_vector_traits.h
 
 
-# langproc ================================================================================================================
 
-        # Strings
+# threading ============================================================================================================
-        include/fennec/langproc/strings/cstring.h
-        include/fennec/langproc/strings/locale.h
-        include/fennec/langproc/strings/string.h
 
-        include/fennec/langproc/strings/detail/_ctype.h
+        include/fennec/threading/atomic.h
+        include/fennec/threading/lock_guard.h
+        include/fennec/threading/mpscq.h
+        include/fennec/threading/mutex.h
+        include/fennec/threading/thread.h
+
+        include/fennec/threading/detail/_thread.h
+
+
+
+# string ===============================================================================================================
+        include/fennec/string/locale.h
+        include/fennec/string/cstring.h
+        include/fennec/string/string.h
+
+        include/fennec/string/detail/_ctype.h
+
+
+
+# format ===============================================================================================================
+        include/fennec/format/format.h
+        include/fennec/format/format_arg.h
+        include/fennec/format/formatter.h
+        include/fennec/format/charconv.h
+
+        include/fennec/format/detail/_format.h
+
+        source/format/charconv.cpp
+
+
+
+# filesystem ===========================================================================================================
+        include/fennec/filesystem/file.h source/filesystem/file.cpp
+        include/fennec/filesystem/path.h source/filesystem/path.cpp
+
+
+
+# interpret ============================================================================================================
+        include/fennec/interpret/tokenizer.h
 
-        # Filesystem
-        include/fennec/langproc/filesystem/file.h source/langproc/filesystem/file.cpp
-        include/fennec/langproc/filesystem/path.h source/langproc/filesystem/path.cpp
 
 
 # PLATFORM =============================================================================================================
-
+        include/fennec/platform/interface/forward.h
-        include/fennec/platform/interface/fwd.h
+        include/fennec/platform/interface/display_server.h
         include/fennec/platform/interface/platform.h source/platform/interface/platform.cpp
-        include/fennec/platform/interface/display.h  source/platform/interface/display.cpp
+        include/fennec/platform/interface/window.h   source/platform/interface/window.cpp
-        include/fennec/platform/interface/gfxcontext.h
+        include/fennec/platform/window_manager.h     source/platform/window_manager.cpp
 
 
-# EXTRA SOURCES ========================================================================================================
 
-        ${FENNEC_EXTRA_SOURCES}
+# GRAPHICS =============================================================================================================
-        include/fennec/containers/variant.h
+
 )
 
-add_dependencies(fennec metaprogramming)
+# add the test suite as a sub-project
+add_subdirectory(test)
 
-target_compile_definitions(fennec PUBLIC
+add_library(fennec STATIC
-    ${FENNEC_COMPILE_DEFINITIONS}
+        ${FENNEC_SOURCES}
+        include/fennec/rtti/this_t.h
 )
 
+add_dependencies(fennec metaprogramming fennec-dependencies)
 
-target_link_options(fennec PRIVATE ${FENNEC_PRIVATE_LINK_OPTIONS}) # Do not compile base fennec library with c++ stdlib
+target_compile_definitions(fennec PUBLIC ${FENNEC_COMPILE_DEFINITIONS})
+target_compile_options(fennec PRIVATE ${FENNEC_PRIVATE_COMPILE_OPTIONS})
+
+# Do not compile base fennec library with c++ stdlib
 # fennec does not use the C++ stdlib because it is bloated, difficult to read, and implementation defined.
 # This implementation is designed to be as readable as possible, and expose information that would otherwise be obfuscated
+target_link_options(fennec PRIVATE ${FENNEC_PRIVATE_LINK_OPTIONS})
+
+
 
 target_link_libraries(fennec PRIVATE
-        cpptrace::cpptrace
         ${FENNEC_LINK_LIBRARIES}
+        ${FENNEC_SHARED_LIBRARIES}
+
+        cpptrace::cpptrace
 )
 
+foreach (_LIB IN ITEMS ${FENNEC_SHARED_LIBRARIES})
+    add_custom_command(TARGET fennec POST_BUILD
+            COMMAND ${CMAKE_COMMAND} -E copy $<TARGET_LINKER_FILE:${_LIB}> ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}
+    )
+endforeach ()
 
 
 # DOXYGEN ==============================================================================================================
@@ -240,7 +354,7 @@ if(DOXYGEN_FOUND)
     set(DOXY_EXAMPLES_DIR "${FENNEC_SOURCE_DIR}/examples")
     get_filename_component(DOXYGEN_PROJECT_NAME ${FENNEC_SOURCE_DIR} NAME) # Set Doxy Project name to the name of the root dir
     set(DOXYGEN_CONFIG_IN "${FENNEC_SOURCE_DIR}/doxy/Doxyfile.in") # Input config file with preprocessor arguments
-    set(DOXYGEN_CONFIG_OUT "${FENNEC_SOURCE_DIR}/doxy/Doxyfile") # Generated config file from input
+    set(DOXYGEN_CONFIG_OUT "${FENNEC_SOURCE_DIR}/doxy/Doxyfile.out") # Generated config file from input
 
     configure_file(${DOXYGEN_CONFIG_IN} ${DOXYGEN_CONFIG_OUT} @ONLY) # Execute preprocessing step
     message("Doxygen Build Started.")
@@ -249,7 +363,7 @@ if(DOXYGEN_FOUND)
     # Target for building docs
     add_custom_target(fennecdocs ALL
             COMMAND ${DOXYGEN_EXECUTABLE} ${DOXYGEN_CONFIG_OUT}
-            WORKING_DIRECTORY ${FENNEC_SOURCE_DIR}
+            WORKING_DIRECTORY ${FENNEC_SOURCE_DIR}/include/
             COMMAND ${CMAKE_COMMAND} -E copy ${FENNEC_SOURCE_DIR}/logo/raster.png
                                              ${DOXY_OUTPUT_DIR}/logo/raster.png
             COMMENT "Generating Doxygen Documentation"

READINGS.md

@@ -3,7 +3,7 @@
 
 # Readings
 
-Here is a list of relevant books and articles on various concepts related to  
+Here is a list of relevant books and articles on various concepts related to
 developing a game engine and its subsystems.
 
  - Game Engine Architecture, Ed. 3 – Jason Gregory

README.md

@@ -16,6 +16,7 @@
     * [Coding Standards](#coding-standards)
   * [Building from Source](#building-from-source)
     * [Building from Terminal](#building-from-terminal)
+      * [Git](#git) → `git`
       * [Debian](#debian) → `apt`
       * [Arch](#arch) → `pacman`
       * [Fedora](#fedora) → `dnf`
@@ -49,9 +50,11 @@ Some main areas where the engine strays from the GNU standard includes the follo
 
 * [Section 4.7, Standards for Graphical Interfaces](https://www.gnu.org/prep/standards/html_node/Graphical-Interfaces.html).
   fennec provides an implementation for X11, however it does not use the GTK toolkit.
-- [Section 6.1, GNU Manuals](https://www.gnu.org/prep/standards/html_node/GNU-Manuals.html)
+- [Section 5.1, Formatting Your Source Code](https://www.gnu.org/prep/standards/html_node/index.html).
+  fennec uses Allman (BSD) for namespaces, otherwise K&R.
+* [Section 6.1, GNU Manuals](https://www.gnu.org/prep/standards/html_node/GNU-Manuals.html)
   fennec does not use Texinfo and instead uses Doxygen. Otherwise, it follows the other standards of this section.
-* [Section 7, The Release Process](https://www.gnu.org/prep/standards/html_node/Managing-Releases.html)
+- [Section 7, The Release Process](https://www.gnu.org/prep/standards/html_node/Managing-Releases.html)
   fennec follows most of the conventions in this section, however the build system used is CMake and not
   Makefile. CMake, although overwhelming at first, is much more friendly to those who are learning build systems for the first time.
 
@@ -63,8 +66,8 @@ fennec Standards:
    `<APP_NAME>_`. Macros that wrap C-Style functions may use normal `snake_case`.
 
  - Header Guards should be implemented using `#ifndef`, `#define`, and `#endif` for portability.
-   The naming convention for Header Guards is as follows: `<APP_NAME>_<DIRECTORY_PATH>_<FILE_NAME>_H`.
+   The naming convention for Header Guards is as follows: `<APP_NAME>_<DIRECTORY_PATH>_<FILE_NAME>_H`,
-   I.E. the engine file `fennec/lang/utility.h` has the Header Guard `FENNEC_LANG_UTILITY_H`.
+   e.g. the engine file `fennec/lang/utility.h` has the Header Guard `FENNEC_LANG_UTILITY_H`.
 
  * Helper Functions, in the case of classes, should be private.
    In the case of global functions, helpers should be placed in a similarly named file in a subdirectory and namespace
@@ -75,10 +78,28 @@ fennec Standards:
 
  * Most behaviours should be type independent. Specifically interactions with the core systems of the engine.
 
+ - Classes should have banners between each distinct group of definitions, with the access specifier on the following 
+   line. E.G.
+   ```c++
+   class foo {
+   // Definitions ============================
+   public:
+       using bar = int;
+       
+   // Constructors & Destructor ==============
+   public:
+       foo();
+       ~foo();
+   };
+   ```
+   This helps significantly with readability, and it also serves to reduce bugs related to mistakes involving access
+   specifiers. E.G. in the example above, bar is changed to private, the constructors are still labeled public in the
+   case the person forgets to update the succeeding access specifiers.
+
 <br><br>
 
 <a id="f1"></a>
-<sup>[1]</sup> If we were to use the exception paradigm for all erroneous behaviour, we couldn't guarantee
+<sup>[[1]](#f1)</sup> If we were to use the exception paradigm for all erroneous behaviour, we couldn't guarantee
                that the state will not be corrupted when an exception is thrown. The behaviour afterward is undefined
                because of this, and we also don't really know when, how, or where that exception will be handled.
                The assertion paradigm is better at handling this because you are defining erroneous behaviour in the
@@ -90,7 +111,7 @@ fennec Standards:
                immediate events to listeners so that outside functionality may decide how to handle the impending crash.
                In Debug Mode there is nothing that can be done to stop the crash, as soon as the branch finishes,
                `abort()` will be called.
-  
+
 
 <br>
 
@@ -125,17 +146,24 @@ is also a viable IDE but involves some extra setup.
 | fennecdocs-clean       | Cleans the generated html documentation files.                                         |
 | fennec-test            | Test suite for verifying engine functionality.                                         |
 
-<a id="dependencies"></a>
+<br>
 
-| Dependency        | Notes                                                                                                    |
+<a id="dependencies"></a>
-|-------------------|----------------------------------------------------------------------------------------------------------|
+### Dependencies
-| C/C++ Compiler    | GCC/G++ is the compiler that fennec is designed around, however, Clang, MSVC, and MinGW may also be used |
+
-| CMake             | The build manager used by the engine                                                                     |
+| Dependency                   | Notes                                                                                                    |
-| glew              | OpenGL Extension Wrangler, necessary for modern OpenGL                                                   |
+|------------------------------|----------------------------------------------------------------------------------------------------------|
-| A build system    | Any build system will work, however, `build.sh` uses Ninja by default.                                   |
+| C/C++ Compiler               | GCC/G++ is the compiler that fennec is designed around, however, Clang, MSVC, and MinGW may also be used |
-| A memory debugger | Any memory debugger will work, however, `test.sh` uses Valgrind by default.                              |
+| CMake                        | The build manager used by the engine                                                                     |
-| Doxygen           | Doxygen is required for building the documentation for fennec. This is an optional dependency            |
+| Volk<sup>[*](#opt)</sup>     | The Vulkan loader Volk, includes necessary headers for Vulkan.                                           |
-| Graphviz          | Graphviz is a required dependency for Doxygen                                                            |
+| A build system               | Any build system will work, however, `build.sh` uses Ninja by default.                                   |
+| A memory debugger            | Any memory debugger will work, however, `test.sh` uses Valgrind by default.                              |
+| Doxygen<sup>[*](#opt)</sup>  | Doxygen is required for building the documentation for fennec.                                           |
+| Graphviz<sup>[*](#opt)</sup> | Graphviz is a required dependency for Doxygen                                                            |
+
+
+<a id="opt"></a>
+<sup>[*](#opt)</sup> Optional Dependency
 
 <br>
 
@@ -152,14 +180,20 @@ build scripts to use another build manager, see the [CMake documentation for ava
 using specific toolchains for specific platforms that necessitate this. The primary examples would be Android and iOS.
 If you wish to build for Windows *and* Linux, your options are WSL or Dual Boot. I recommend Dual Boot over WSL.
 
+<a id="git"></a>
+#### Git
+
+Install git dependencies with the following command:
+```shell
+git submodule update --force --init --recursive --remote
+```
 
 <a id="debian"></a>
 #### Debian
 
 On Debian-based distributions, you can install dependencies using the following command:
 ```shell
-sudo apt install build-essential cmake ninja-build libglew-dev valgrind
+sudo apt install build-essential cmake ninja-build valgrind libvulkan-volk-dev vulkan-validationlayers
-git submodule update --force --init --recursive --remote
 ```
 
 for Doxygen run:
@@ -172,8 +206,7 @@ sudo apt install doxygen graphviz
 
 On Arch-based distributions, you can install dependencies using the following command:
 ```shell
-sudo pacman -S base-devel cmake ninja glew valgrind
+sudo pacman -S base-devel cmake ninja valgrind vulkan-devel
-git submodule update --force --init --recursive --remote
 ```
 
 for Doxygen run:
@@ -186,8 +219,7 @@ sudo pacman -S doxygen graphviz
 
 On Fedora-based distributions, you can install dependencies using the following command:
 ```shell
-sudo dnf install build-essential g++ cmake ninja-build glew-devel valgrind
+sudo dnf install build-essential g++ cmake ninja-build valgrind vulkan-volk-devel vulkan-validation-layers
-git submodule update --force --init --recursive --remote
 ```
 
 for Doxygen run:

build.sh

@@ -1,6 +1,6 @@
 ## =====================================================================================================================
 ##  fennec, a free and open source game engine
-##  Copyright © 2025  Medusa Slockbower
+##  Copyright © 2025 - 2026  Medusa Slockbower
 ##
 ##  This program is free software: you can redistribute it and/or modify
 ##  it under the terms of the GNU General Public License as published by

cmake/build.cmake

@@ -1,6 +1,6 @@
 # ======================================================================================================================
 #  fennec, a free and open source game engine
-#  Copyright © 2025  Medusa Slockbower
+#  Copyright © 2025 - 2026  Medusa Slockbower
 #
 #  This program is free software: you can redistribute it and/or modify
 #  it under the terms of the GNU General Public License as published by

cmake/compiler.cmake

@@ -1,6 +1,6 @@
 # ======================================================================================================================
 #  fennec, a free and open source game engine
-#  Copyright © 2025  Medusa Slockbower
+#  Copyright © 2025 - 2026  Medusa Slockbower
 #
 #  This program is free software: you can redistribute it and/or modify
 #  it under the terms of the GNU General Public License as published by
@@ -18,7 +18,13 @@
 
 # this script finds the compiler being used
 
+message(STATUS "Compiler: ${CMAKE_CXX_COMPILER_ID} ${CMAKE_CXX_COMPILER_VERSION}")
+
+fennec_add_definitions(
+        FENNEC_LONG_COMPILER_NAME="${CMAKE_CXX_COMPILER_ID} ${CMAKE_SYSTEM_NAME} ${CMAKE_SYSTEM_PROCESSOR}"
+)
+
 if(${CMAKE_CXX_COMPILER_ID} MATCHES "GNU")
 set(FENNEC_COMPILER "GCC")
 include("${FENNEC_SOURCE_DIR}/cmake/gcc.cmake")
-endif()
+endif()

cmake/default_user.cmake

@@ -1,6 +1,6 @@
 # ======================================================================================================================
 #  fennec, a free and open source game engine
-#  Copyright © 2025  Medusa Slockbower
+#  Copyright © 2025 - 2026  Medusa Slockbower
 #
 #  This program is free software: you can redistribute it and/or modify
 #  it under the terms of the GNU General Public License as published by

cmake/gcc.cmake

@@ -1,6 +1,6 @@
 # ======================================================================================================================
 #  fennec, a free and open source game engine
-#  Copyright © 2025  Medusa Slockbower
+#  Copyright © 2025 - 2026  Medusa Slockbower
 #
 #  This program is free software: you can redistribute it and/or modify
 #  it under the terms of the GNU General Public License as published by
@@ -18,8 +18,15 @@
 
 # this script sets flags and variables for gnu and gnu-like compilers
 
-add_compile_options("-mxsave" "-Wall" "-Wextra" "-pedantic" "-Werror")
+add_compile_options("-Wall" "-Wextra" "-pedantic" "-Werror" "-fms-extensions")
 
-set(FENNEC_PRIVATE_LINK_OPTIONS "-nostdlib" "-fno-exceptions" "-fno-rtti" "-fdiagnostics-all-candidates")
+fennec_add_compile_options("-ffile-prefix-map=${FENNEC_SOURCE_DIR}=.")
 
-list(APPEND FENNEC_COMPILE_DEFINITIONS FENNEC_COMPILER_GCC=1 FENNEC_NO_INLINE=[[gnu::noinline]])
+fennec_add_link_options("-nostdlib" "-fno-exceptions" "-fno-rtti" "-fdiagnostics-all-candidates" "-pthread")
+
+fennec_add_definitions(
+        _GLIBCXX_INCLUDE_NEXT_C_HEADERS=1
+        FENNEC_COMPILER_GCC=1
+        FENNEC_NO_INLINE=[[gnu::noinline]]
+        FENNEC_FUNCTION_NAME=__PRETTY_FUNCTION__
+)

cmake/linux.cmake

@@ -1,6 +1,6 @@
 # ======================================================================================================================
 #  fennec, a free and open source game engine
-#  Copyright © 2025  Medusa Slockbower
+#  Copyright © 2025 - 2026  Medusa Slockbower
 #
 #  This program is free software: you can redistribute it and/or modify
 #  it under the terms of the GNU General Public License as published by
@@ -23,13 +23,13 @@ macro(fennec_check_platform)
     include("${FENNEC_SOURCE_DIR}/cmake/unix.cmake")
 
     # compile definitions
-    list(APPEND FENNEC_COMPILE_DEFINITIONS
+    fennec_add_definitions(
             FENNEC_PLATFORM_NAME="Linux"
             FENNEC_PLATFORM_LINUX=1
     )
 
     # extra source files
-    list(APPEND FENNEC_EXTRA_SOURCES
+    fennec_add_sources(
             include/fennec/platform/linux/platform.h source/platform/linux/platform.cpp
     )
 

cmake/opengl.cmake

@@ -1,6 +1,6 @@
 # ======================================================================================================================
 #  fennec, a free and open source game engine
-#  Copyright © 2025  Medusa Slockbower
+#  Copyright © 2025 - 2026  Medusa Slockbower
 #
 #  This program is free software: you can redistribute it and/or modify
 #  it under the terms of the GNU General Public License as published by
@@ -16,38 +16,28 @@
 #  along with this program.  If not, see <https://www.gnu.org/licenses/>.
 # ======================================================================================================================
 
+find_package(OpenGL)
+
 if(FENNEC_GRAPHICS_WANT_EGL)
-    find_package(OpenGL REQUIRED COMPONENTS EGL)
+    fennec_add_sources(
-    find_package(GLEW REQUIRED)
+            include/fennec/platform/opengl/egl/fwd.h
-    message(STATUS "EGL Requested")
+            include/fennec/platform/opengl/egl/error.h
-else()
+            include/fennec/platform/opengl/egl/context.h source/platform/opengl/egl/context.cpp
-    find_package(OpenGL)
+            include/fennec/platform/opengl/egl/surface.h source/platform/opengl/egl/surface.cpp
-    find_package(GLEW REQUIRED)
+
+            include/fennec/platform/opengl/glad/egl.h source/platform/opengl/glad/egl.c
+    )
 endif()
 
-if(TARGET OpenGL::GL AND TARGET GLEW::GLEW)
+if(TARGET OpenGL::GL)
-    message(STATUS "Found OpenGL: ${OPENGL_gl_LIBRARY}")
+    fennec_add_link_libraries(OpenGL::GL)
-    list(APPEND FENNEC_LINK_LIBRARIES OpenGL::GL GLEW::GLEW)
+    fennec_add_definitions(FENNEC_GRAPHICS_OPENGL=1)
-    list(APPEND FENNEC_COMPILE_DEFINITIONS FENNEC_GRAPHICS_OPENGL=1)
+
+    fennec_add_sources(
+            include/fennec/platform/opengl/glad/gl.h source/platform/opengl/glad/gl.c
+
+            include/fennec/renderers/opengl/glcontext.h source/renderers/opengl/glcontext.cpp
+    )
 else()
     message(FATAL_ERROR "No Suitable OpenGL implementation found.")
-endif()
-
-if(FENNEC_GRAPHICS_WANT_EGL)
-    if(NOT TARGET OpenGL::EGL)
-        message(FATAL_ERROR "EGL Library not found.")
-    endif()
-
-    message(STATUS "Found EGL: ${OPENGL_egl_LIBRARY}")
-    list(APPEND FENNEC_LINK_LIBRARIES OpenGL::EGL)
-    list(APPEND FENNEC_COMPILE_DEFINITIONS FENNEC_GRAPHICS_EGL=1)
-    list(APPEND FENNEC_EXTRA_SOURCES
-            include/fennec/platform/opengl/lib/fwd.h
-            include/fennec/platform/opengl/lib/enum.h
-            include/fennec/platform/opengl/lib/buffer.h
-            include/fennec/platform/opengl/lib/texture.h
-            include/fennec/platform/opengl/lib/vertex_array.h
-
-            include/fennec/platform/opengl/egl/context.h source/platform/opengl/egl/context.cpp
-    )
 endif()

cmake/platform.cmake

@@ -1,6 +1,6 @@
 # ======================================================================================================================
 #  fennec, a free and open source game engine
-#  Copyright © 2025  Medusa Slockbower
+#  Copyright © 2025 - 2026  Medusa Slockbower
 #
 #  This program is free software: you can redistribute it and/or modify
 #  it under the terms of the GNU General Public License as published by
@@ -22,13 +22,14 @@ message(STATUS "OS: ${CMAKE_SYSTEM_NAME}")
 
 include("${FENNEC_SOURCE_DIR}/cmake/default_user.cmake")
 
-# Graphics APIs
-macro(fennec_init_graphics)
-    include("${FENNEC_SOURCE_DIR}/cmake/opengl.cmake")
-endmacro()
-
 # Check for Linux
 if(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
     set(FENNEC_PLATFORM "Linux")
     include("${FENNEC_SOURCE_DIR}/cmake/linux.cmake")
-endif ()
+endif ()
+
+# Graphics APIs
+macro(fennec_init_graphics)
+    include("${FENNEC_SOURCE_DIR}/cmake/opengl.cmake")
+    include("${FENNEC_SOURCE_DIR}/cmake/vulkan.cmake")
+endmacro()

cmake/unix.cmake

@@ -1,6 +1,6 @@
 # ======================================================================================================================
 #  fennec, a free and open source game engine
-#  Copyright © 2025  Medusa Slockbower
+#  Copyright © 2025 - 2026  Medusa Slockbower
 #
 #  This program is free software: you can redistribute it and/or modify
 #  it under the terms of the GNU General Public License as published by
@@ -19,11 +19,11 @@
 # generic unix functionality
 
 # compile definitions
-list(APPEND FENNEC_COMPILE_DEFINITIONS
+fennec_add_definitions(
         FENNEC_PLATFORM_UNIX=1
 )
 
 # extra source files
-list(APPEND FENNEC_EXTRA_SOURCES
+fennec_add_sources(
         include/fennec/platform/unix/platform.h source/platform/unix/platform.cpp
 )

cmake/version.cmake

@@ -1,6 +1,6 @@
 # ======================================================================================================================
 #  fennec, a free and open source game engine
-#  Copyright © 2025  Medusa Slockbower
+#  Copyright © 2025 - 2026  Medusa Slockbower
 #
 #  This program is free software: you can redistribute it and/or modify
 #  it under the terms of the GNU General Public License as published by

cmake/vulkan.cmake

@@ -0,0 +1,40 @@
+# ======================================================================================================================
+#  fennec, a free and open source game engine
+#  Copyright © 2025 - 2026  Medusa Slockbower
+#
+#  This program is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+# ======================================================================================================================
+
+find_package(Vulkan COMPONENTS glslang volk)
+
+if(FENNEC_GRAPHICS_WANT_MOLTENVK)
+    find_package(Vulkan COMPONENTS MoltenVK)
+endif()
+
+if( TARGET Vulkan::Headers AND TARGET Vulkan::volk # Base Headers and Meta-Loader
+    AND TARGET Vulkan::glslang                     # GLSL Compilation
+    AND (NOT FENNEC_GRAPHICS_WANT_MOLTENVK OR TARGET Vulkan::MoltenVK)
+)
+    fennec_add_link_libraries(Vulkan::volk Vulkan::glslang)
+    fennec_add_definitions(FENNEC_GRAPHICS_VULKAN=1)
+
+    fennec_add_sources(
+        include/fennec/renderers/vulkan/lib/app_info.h
+        include/fennec/renderers/vulkan/lib/instance.h
+
+        include/fennec/renderers/vulkan/vkcontext.h include/fennec/renderers/vulkan/vkcontext.cpp
+    )
+else()
+    message(WARNING "No Suitable Vulkan implementation found.")
+endif()

cmake/wayland.cmake

@@ -1,6 +1,6 @@
 # ======================================================================================================================
 #  fennec, a free and open source game engine
-#  Copyright © 2025  Medusa Slockbower
+#  Copyright © 2025 - 2026  Medusa Slockbower
 #
 #  This program is free software: you can redistribute it and/or modify
 #  it under the terms of the GNU General Public License as published by
@@ -19,6 +19,34 @@
 # https://gist.github.com/mariobadr/acc3c8adf4b4e722705be38c3deac59a
 # this script finds libwayland and dependencies
 
+# some of this code is based on SDL3's use of wayland-scanner
+
+function(fennec_wayland_get_protocol)
+    set( _OPTIONS_ARGS )
+    set( _ONE_VALUE_ARGS )
+    set( _MULTI_VALUE_ARGS NAMES PATHS )
+
+    cmake_parse_arguments(_FINDPROTOCOLS "${_OPTIONS_ARGS}" "${_ONE_VALUE_ARGS}" "${_MULTI_VALUE_ARGS}" ${ARGN} )
+
+    find_file(_FINDPROTOCOLS_TEMP NAMES ${_FINDPROTOCOLS_NAMES} PATHS ${_FINDPROTOCOLS_PATHS})
+    file(COPY ${_FINDPROTOCOLS_TEMP} DESTINATION ${WAYLAND_PROTOCOLS_DIR})
+endfunction()
+
+macro(fennec_wayland_get_header _SCANNER _XML _FILE)
+    set(_WAYLAND_PROT_H_CODE "${WAYLAND_HEADERS_DIR}/${_FILE}-client-protocols.h")
+    set(_WAYLAND_PROT_C_CODE "${WAYLAND_SOURCES_DIR}/${_FILE}-client.c")
+
+    execute_process(
+            COMMAND ${_SCANNER} client-header "${_XML}" "${_WAYLAND_PROT_H_CODE}"
+    )
+
+    execute_process(
+            COMMAND ${_SCANNER} private-code "${_XML}" "${_WAYLAND_PROT_C_CODE}"
+    )
+
+    fennec_add_sources(${_WAYLAND_PROT_C_CODE} ${_WAYLAND_PROT_H_CODE})
+endmacro()
+
 macro(fennec_check_wayland)
     set(WAYLAND_CLIENT_FOUND 0)
 
@@ -30,6 +58,7 @@ macro(fennec_check_wayland)
             WAYLAND_CLIENT_LIBRARY
             NAMES wayland-client libwayland-client
     )
+    find_program(WAYLAND_SCANNER NAMES wayland-scanner)
 
     # EGL is required
     find_path(
@@ -41,13 +70,31 @@ macro(fennec_check_wayland)
             NAMES wayland-egl libwayland-egl
     )
 
-    if( (WAYLAND_CLIENT_INCLUDE_DIR AND WAYLAND_CLIENT_LIBRARY)
+
-    AND (WAYLAND_EGL_INCLUDE_DIR AND WAYLAND_EGL_LIBRARY))
+    if( (WAYLAND_CLIENT_INCLUDE_DIR AND WAYLAND_CLIENT_LIBRARY AND WAYLAND_SCANNER)
+            AND (WAYLAND_EGL_INCLUDE_DIR AND WAYLAND_EGL_LIBRARY))
         message(STATUS "Found Wayland: ${WAYLAND_CLIENT_LIBRARY}")
 
+        set(WAYLAND_PROTOCOLS_DIR ${FENNEC_SOURCE_DIR}/include/fennec/platform/linux/wayland/lib/protocols)
+        set(WAYLAND_HEADERS_DIR ${FENNEC_SOURCE_DIR}/include/fennec/platform/linux/wayland/lib/headers)
+        set(WAYLAND_SOURCES_DIR ${FENNEC_SOURCE_DIR}/source/platform/linux/wayland/lib/sources)
+
+        # Search for base protocol xml
+        fennec_wayland_get_protocol(NAMES "wayland.xml"   PATHS "/usr/share/wayland"                  "/usr/share/wayland-protocols")
+        fennec_wayland_get_protocol(NAMES "xdg-shell.xml" PATHS "/usr/share/wayland/stable/xdg-shell" "/usr/share/wayland-protocols/stable/xdg-shell")
+
+        # include sub-dependencies
         include("${FENNEC_SOURCE_DIR}/cmake/xkb.cmake")
         fennec_check_xkb()
 
+        # generate protocols, based on SDL3
+        file(GLOB WAYLAND_PROTOCOLS_XML RELATIVE "${WAYLAND_PROTOCOLS_DIR}" "${WAYLAND_PROTOCOLS_DIR}/*.xml")
+        foreach(_XML IN LISTS WAYLAND_PROTOCOLS_XML)
+            get_filename_component(_FILE ${_XML} NAME_WLE)
+            fennec_wayland_get_header("${WAYLAND_SCANNER}" "${WAYLAND_PROTOCOLS_DIR}/${_XML}" "${_FILE}")
+        endforeach()
+
+        # Add sources and libraries
         get_filename_component(
                 WAYLAND_CLIENT_LIBRARY
                 ${WAYLAND_CLIENT_LIBRARY}
@@ -63,22 +110,60 @@ macro(fennec_check_wayland)
         set(WAYLAND_EGL_FOUND 1)
         set(FENNEC_GRAPHICS_WANT_EGL 1)
 
-        list(APPEND FENNEC_EXTRA_SOURCES
+        fennec_add_sources(
                 # Dynamic Library Files
-                include/fennec/platform/linux/wayland/lib/fwd.h
                 include/fennec/platform/linux/wayland/lib/sym.h
-                include/fennec/platform/linux/wayland/lib/wayland-client.h
+                include/fennec/platform/linux/wayland/lib/wayland.h
-                include/fennec/platform/linux/wayland/lib/wayland-util.h
                 include/fennec/platform/linux/wayland/lib/loader.h source/platform/linux/wayland/lib/loader.cpp
 
                 # Fennec Files
-                include/fennec/platform/linux/wayland/display.h source/platform/linux/wayland/display.cpp
+                include/fennec/platform/linux/wayland/fwd.h
+                include/fennec/platform/linux/wayland/server.h source/platform/linux/wayland/server.cpp
+                include/fennec/platform/linux/wayland/window.h source/platform/linux/wayland/window.cpp
+
+                # EGL
+                include/fennec/platform/linux/wayland/egl/context.h source/platform/linux/wayland/egl/context.cpp
+                include/fennec/platform/linux/wayland/egl/surface.h source/platform/linux/wayland/egl/surface.cpp
         )
 
-        list(APPEND FENNEC_COMPILE_DEFINITIONS
+        fennec_add_definitions(
                 FENNEC_HAS_WAYLAND=1
                 FENNEC_LIB_WAYLAND="${WAYLAND_CLIENT_LIBRARY}"
                 FENNEC_LIB_WAYLAND_EGL="${WAYLAND_EGL_LIBRARY}"
+                VK_USE_PLATFORM_WAYLAND_KHR=1
         )
+
+
+        # find libdecor
+        find_path(
+                LIBDECOR_INCLUDE_DIR
+                PATH_SUFFIXES libdecor libdecor-0
+                NAMES libdecor.h libdecor.h
+        )
+        find_library(
+                LIBDECOR_LIBRARY
+                PATH_SUFFIXES libdecor libdecor-0
+                NAMES libdecor.so libdecor-0.so
+        )
+
+        if(LIBDECOR_INCLUDE_DIR AND LIBDECOR_LIBRARY)
+            message(STATUS "Found libdecor: ${LIBDECOR_LIBRARY}")
+
+            fennec_add_definitions(
+                    FENNEC_HAS_LIBDECOR=1
+                    FENNEC_LIB_LIBDECOR="${LIBDECOR_LIBRARY}"
+            )
+
+            include_directories(
+                    ${LIBDECOR_INCLUDE_DIR}
+            )
+
+            fennec_add_sources(
+                    include/fennec/platform/linux/wayland/libdecor/sym.h
+                    include/fennec/platform/linux/wayland/libdecor/libdecor.h
+                    include/fennec/platform/linux/wayland/libdecor/loader.h source/platform/linux/wayland/libdecor/loader.cpp
+            )
+        endif()
+
     endif()
 endmacro()

cmake/xkb.cmake

@@ -1,6 +1,6 @@
 # ======================================================================================================================
 #  fennec, a free and open source game engine
-#  Copyright © 2025  Medusa Slockbower
+#  Copyright © 2025 - 2026  Medusa Slockbower
 #
 #  This program is free software: you can redistribute it and/or modify
 #  it under the terms of the GNU General Public License as published by
@@ -41,17 +41,16 @@ macro(fennec_check_xkb)
 
         set(XKB_FOUND 1)
 
-        list(APPEND FENNEC_EXTRA_SOURCES
+        fennec_add_sources(
                 # Dynamic Library Files
-                include/fennec/platform/linux/xkb/lib/fwd.h
                 include/fennec/platform/linux/xkb/lib/sym.h
-                include/fennec/platform/linux/xkb/lib/xkbcommon.h
+                include/fennec/platform/linux/xkb/lib/xkb.h
                 include/fennec/platform/linux/xkb/lib/loader.h source/platform/linux/xkb/lib/loader.cpp
 
                 # Fennec files
         )
 
-        list(APPEND FENNEC_COMPILE_DEFINITIONS
+        fennec_add_definitions(
                 FENNEC_HAS_XKB=1
                 FENNEC_LIB_XKB="${XKB_LIBRARY}"
         )

doxy/Doxyfile.in

@@ -260,7 +260,7 @@ INHERIT_DOCS           = YES
 # of the file/class/namespace that contains it.
 # The default value is: NO.
 
-SEPARATE_MEMBER_PAGES  = NO
+SEPARATE_MEMBER_PAGES  = YES
 
 # The TAB_SIZE tag can be used to set the number of spaces in a tab. Doxygen
 # uses this value to replace tabs by spaces in code fragments.
@@ -582,7 +582,7 @@ RESOLVE_UNNAMED_PARAMS = YES
 # section is generated. This option has no effect if EXTRACT_ALL is enabled.
 # The default value is: NO.
 
-HIDE_UNDOC_MEMBERS     = YES
+HIDE_UNDOC_MEMBERS     = NO
 
 # If the HIDE_UNDOC_CLASSES tag is set to YES, doxygen will hide all
 # undocumented classes that are normally visible in the class hierarchy. If set
@@ -591,7 +591,7 @@ HIDE_UNDOC_MEMBERS     = YES
 # if EXTRACT_ALL is enabled.
 # The default value is: NO.
 
-HIDE_UNDOC_CLASSES     = YES
+HIDE_UNDOC_CLASSES     = NO
 
 # If the HIDE_FRIEND_COMPOUNDS tag is set to YES, doxygen will hide all friend
 # declarations. If set to NO, these declarations will be included in the
@@ -701,7 +701,7 @@ SORT_BRIEF_DOCS        = NO
 # detailed member documentation.
 # The default value is: NO.
 
-SORT_MEMBERS_CTORS_1ST = NO
+SORT_MEMBERS_CTORS_1ST = YES
 
 # If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the hierarchy
 # of group names into alphabetical order. If set to NO the group names will
@@ -943,8 +943,7 @@ WARN_LOGFILE           =
 # spaces. See also FILE_PATTERNS and EXTENSION_MAPPING
 # Note: If this tag is empty the current directory is searched.
 
-INPUT                  = "@PROJECT_SOURCE_DIR@/include" \
+INPUT                  = "@PROJECT_SOURCE_DIR@/include/" \
-                         "@PROJECT_SOURCE_DIR@/source" \
                          "@PROJECT_SOURCE_DIR@/README.md"
 
 # This tag can be used to specify the character encoding of the source files
@@ -1049,7 +1048,10 @@ RECURSIVE              = YES
 # Note that relative paths are relative to the directory from which doxygen is
 # run.
 
-EXCLUDE                =
+EXCLUDE                = "@PROJECT_SOURCE_DIR@/include/fennec/platform/linux/wayland/lib" \
+                         "@PROJECT_SOURCE_DIR@/include/fennec/platform/linux/wayland/libdecor" \
+                         "@PROJECT_SOURCE_DIR@/include/fennec/platform/linux/xkb/lib" \
+                         "@PROJECT_SOURCE_DIR@/include/fennec/platform/opengl/glad"
 
 # The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
 # directories that are symbolic links (a Unix file system feature) are excluded
@@ -2402,7 +2404,7 @@ MACRO_EXPANSION        = YES
 # The default value is: NO.
 # This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
 
-EXPAND_ONLY_PREDEF     = YES
+EXPAND_ONLY_PREDEF     = NO
 
 # If the SEARCH_INCLUDES tag is set to YES, the include files in the
 # INCLUDE_PATH will be searched if a #include is found.
@@ -2417,7 +2419,7 @@ SEARCH_INCLUDES        = YES
 # RECURSIVE has no effect here.
 # This tag requires that the tag SEARCH_INCLUDES is set to YES.
 
-INCLUDE_PATH           =
+INCLUDE_PATH           = "@PROJECT_SOURCE_DIR@/include"
 
 # You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
 # patterns (like *.h and *.hpp) to filter out the header-files in the
@@ -2435,8 +2437,7 @@ INCLUDE_FILE_PATTERNS  =
 # recursively expanded use the := operator instead of the = operator.
 # This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
 
-PREDEFINED             = "FENNEC_SCALAR_TEMPLATE=" \
+PREDEFINED             = "FENNEC_DOXYGEN="
-                         "FENNEC_VECTOR_TEMPLATE="
 
 # If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then this
 # tag can be used to specify a list of macro names that should be expanded. The
@@ -2511,7 +2512,7 @@ EXTERNAL_PAGES         = YES
 # and usage relations if the target is undocumented or is not a class.
 # The default value is: YES.
 
-HIDE_UNDOC_RELATIONS   = YES
+HIDE_UNDOC_RELATIONS   = NO
 
 # If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
 # available from the path. This tool is part of Graphviz (see:

examples/assert.cpp

@@ -0,0 +1,67 @@
+// =====================================================================================================================
+//  I release this example code into the public domain
+// =====================================================================================================================
+
+// This file contains code that tests the efficiency of the assert macro scheme in
+// fennec engine. This is purely looking at the branching aspect and not the private
+// assert definition. The code only uses passing values to see any performance overhead
+// from the conditional
+
+// This code is based on the example code that cppreference provides at
+// https://en.cppreference.com/w/cpp/language/attributes/likely
+
+// To my surprise, the difference between them is negligible.
+// Even when n is a crazy number like one billion, there isn't a conclusive difference.
+// I checked that it isn't the lambdas, they are optimized out.
+
+// In debug mode, the results are to be expected; release < experimental < control
+
+#include <cassert>
+#include <chrono>
+#include <cstddef>
+#include <iomanip>
+#include <iostream>
+
+#define assert_c(expression) \
+if(not(expression)) { \
+std::abort(); \
+}
+
+#define assert_e(expression) \
+if(not(expression)) [[unlikely]] { \
+std::abort(); \
+}
+
+#define assert_r(expression) (static_cast<void> (0))
+
+volatile int sink{}; // ensures a side effect
+
+int main() {
+	auto benchmark = [](auto fun, auto rem) {
+		srand(0);
+
+		const auto start = std::chrono::high_resolution_clock::now();
+		for (auto size{1ULL}; size != 10'000'000ULL; ++size)
+			sink = fun(rand());
+		const std::chrono::duration<double> diff =
+			std::chrono::high_resolution_clock::now() - start;
+
+		std::cout << "Time: " << std::fixed << std::setprecision(6) << diff.count()
+				  << " sec " << rem << std::endl;
+	};
+
+	benchmark([](int x) {
+		assert_c(0 <= x && x <= RAND_MAX);
+		return x;
+	}, "control");
+
+	benchmark([](int x) {
+		assert_r(0 <= x && x <= RAND_MAX);
+		return x;
+	}, "release");
+
+	benchmark([](int x) {
+		assert_e(0 <= x && x <= RAND_MAX);
+		return x;
+	}, "experimental");
+}

gdb/fennec/__init__.py

@@ -1,6 +1,6 @@
 # ======================================================================================================================
 #  fennec, a free and open source game engine
-#  Copyright © 2025  Medusa Slockbower
+#  Copyright © 2025 - 2026  Medusa Slockbower
 #
 #  This program is free software: you can redistribute it and/or modify
 #  it under the terms of the GNU General Public License as published by
@@ -20,6 +20,7 @@
 # GDB CODE =============================================================================================================
 
 import gdb
+import gdb.printing
 
 from . import containers
 from . import strings

gdb/fennec/containers.py

@@ -1,6 +1,6 @@
 # ======================================================================================================================
 #  fennec, a free and open source game engine
-#  Copyright © 2025  Medusa Slockbower
+#  Copyright © 2025 - 2026  Medusa Slockbower
 #
 #  This program is free software: you can redistribute it and/or modify
 #  it under the terms of the GNU General Public License as published by
@@ -371,7 +371,7 @@ class RDTreePrinter:
                 index += '└'
 
             index += '─'
-            index += '[{}, {}]'.format(node, i)
+            index += '[{}]'.format(node)
             return index, value
 
 
@@ -389,6 +389,200 @@ class RDTreePrinter:
         return self.Iterator(self.tree, 0, self.capacity)
 
 
+# PRIORITY QUEUE =======================================================================================================
+
+class PriorityQueuePrinter:
+    """Print a fennec::rdtree"""
+
+    class Iterator:
+        def __init__(self, tree, node, capacity):
+            self.tree = tree
+            self.capacity = capacity
+            self.visit = deque()
+            self.skip = True
+
+            self.visit.append((node, 0, 0, node))
+
+        def __iter__(self):
+            return self
+
+        def __next__(self):
+            if len(self.visit) == 0:
+                raise StopIteration
+
+            node  = self.visit[0][0]
+            i     = self.visit[0][1]
+            depth = self.visit[0][2]
+            start = self.visit[0][3]
+            self.visit.popleft()
+
+            if node == start and not self.skip:
+                return self.__next__()
+
+            self.skip = False
+
+            value = self.tree[node]['_val']['key']
+
+            nnext  = self.tree[node]['_val']['next']
+            child  = self.tree[node]['_val']['child']
+
+            index = '⠀' * depth * 2 # Uses Braille Space, otherwise it would get eaten as whitespace by parsers
+
+            if nnext < self.capacity:
+                self.visit.appendleft((nnext, i + 1, depth, start))
+
+            if child < self.capacity:
+                self.visit.appendleft((child, 0, depth + 1, child))
+                self.skip = True
+
+            # ┌ ─ ├ └
+
+            if nnext != 18446744073709551615:
+                index += '├'
+            else:
+                index += '└'
+
+            index += '─'
+            index += '[{}]'.format(node)
+            return index, value
+
+
+    def __init__(self, val):
+        self.tree     = val['_table']['_table']['_alloc']['_data']
+        self.size     = val['_table']['_size']
+        self.capacity = val['_table']['_table']['_alloc']['_capacity']
+        self.min      = val['_min']
+
+    def to_string(self):
+        if self.size == 0:
+            return "{ empty }"
+        return "{ size = " + str(self.size) + " }"
+
+    def children(self):
+        return self.Iterator(self.tree, self.min, self.capacity)
+
+
+# BINTREE ==============================================================================================================
+
+class BinTreePrinter:
+    """Print a fennec::bintree"""
+
+    class Iterator:
+        def __init__(self, tree, node, capacity):
+            self.tree = tree
+            self.capacity = capacity
+            self.visit = deque()
+
+            if capacity > 0:
+                self.visit.append((node, 0, 0))
+
+        def __iter__(self):
+            return self
+
+        def __next__(self):
+            if len(self.visit) == 0:
+                raise StopIteration
+
+            node   = self.visit[0][0]
+            i      = self.visit[0][1]
+            depth  = self.visit[0][2]
+            parent = self.tree[node]['parent']
+            self.visit.popleft()
+
+            value = self.tree[node]['value']
+            left  = self.tree[node]['child'][0]
+            right = self.tree[node]['child'][1]
+
+            if right < self.capacity:
+                self.visit.appendleft((right, 1, depth + 1))
+            if left < self.capacity:
+                self.visit.appendleft((left,  0, depth + 1))
+
+            index = '⠀' * depth * 2 # Uses Braille Space, otherwise it would get eaten as whitespace by parsers
+            if i == 0 and parent != 18446744073709551615 and self.tree[parent]['right'] != 18446744073709551615:
+                index += '├'
+            else:
+                index += '└'
+
+            index += '─'
+            index += '[{}]'.format(node)
+            return index, value
+
+
+    def __init__(self, val):
+        self.tree = val['_table']['_data']
+        self.size = val['_size']
+        self.root = val['_root']
+        self.capacity = val['_table']['_capacity']
+
+    def to_string(self):
+        if self.size == 0:
+            return "{ empty }"
+        return "{ size = " + str(self.size) + " }"
+
+    def children(self):
+        return self.Iterator(self.tree, self.root, self.capacity)
+
+
+# SEQUENCE =============================================================================================================
+
+class SequencePrinter:
+    """Print a fennec::sequence"""
+
+    class Iterator:
+        def __init__(self, node):
+            self.visit = deque()
+
+            if node is not None:
+                self.visit.append((node, 0, 0))
+
+        def __iter__(self):
+            return self
+
+        def __next__(self):
+            if len(self.visit) == 0:
+                raise StopIteration
+
+            node   = self.visit[0][0]
+            i      = self.visit[0][1]
+            depth  = self.visit[0][2]
+            self.visit.popleft()
+
+            value = node['key']
+            left  = node['child'][0]
+            right = node['child'][1]
+            print("it: ", node, " ", left, " ", right);
+
+            if right != 0:
+                self.visit.appendleft((right, 1, depth + 1))
+            if left != 0:
+                self.visit.appendleft((left,  0, depth + 1))
+
+            index = '⠀' * depth * 2 # Uses Braille Space, otherwise it would get eaten as whitespace by parsers
+            if i == 0:
+                index += '├'
+            else:
+                index += '└'
+
+            index += '─'
+            index += '[{}]'.format(node)
+            return index, value
+
+
+    def __init__(self, val):
+        self.size = val['_size']
+        self.root = val['_root']
+
+    def to_string(self):
+        if self.size == 0:
+            return "{ empty }"
+        return "{ size = " + str(self.size) + " }"
+
+    def children(self):
+        print("root: ", self.root)
+        return self.Iterator(self.root)
+
+
 # Graph ================================================================================================================
 
 class GraphPrinter:
@@ -396,10 +590,10 @@ class GraphPrinter:
 
     class Iterator:
         def __init__(self, val):
-            self.node_pool = val['_node_pool']['_table']['_alloc']['_data']
+            self.node_pool = val['_vertex_pool']['_table']['_alloc']['_data']
-            self.max_nodes = val['_node_pool']['_table']['_alloc']['_capacity']
+            self.max_nodes = val['_vertex_pool']['_table']['_alloc']['_capacity']
-            self.conn_map  = val['_conn_map']['_alloc']['_data']
+            self.conn_map  = val['_edge_map']['_alloc']['_data']
-            self.max_conn  = val['_conn_map']['_size']
+            self.max_conn  = val['_edge_map']['_size']
             self.index     = 0
 
         def __iter__(self):
@@ -447,7 +641,7 @@ class GraphPrinter:
 
     def __init__(self, val):
         self.val = val
-        self.size = val['_node_pool']['_size']
+        self.size = val['_vertex_pool']['_size']
 
     def to_string(self):
         if self.size == 0:
@@ -464,18 +658,21 @@ class GraphPrinter:
 def register_printers():
     print("registering containers")
     pp = gdb.printing.RegexpCollectionPrettyPrinter("fennec::containers")
-    pp.add_printer('fennec::array',       '^fennec::array<.*>$',       ArrayPrinter)
+    pp.add_printer('fennec::array',          '^fennec::array<.*>$',          ArrayPrinter)
-    pp.add_printer('fennec::deque',       '^fennec::deque<.*>$',       DequePrinter)
+    pp.add_printer('fennec::deque',          '^fennec::deque<.*>$',          DequePrinter)
-    pp.add_printer('fennec::dynarray',    '^fennec::dynarray<.*>$',    DynArrayPrinter)
+    pp.add_printer('fennec::dynarray',       '^fennec::dynarray<.*>$',       DynArrayPrinter)
-    pp.add_printer('fennec::graph',       '^fennec::graph<.*>$',       GraphPrinter)
+    pp.add_printer('fennec::graph',          '^fennec::graph<.*>$',          GraphPrinter)
-    pp.add_printer('fennec::list',        '^fennec::list<.*>$',        ListPrinter)
+    pp.add_printer('fennec::list',           '^fennec::list<.*>$',           ListPrinter)
-    pp.add_printer('fennec::map',         '^fennec::map<.*>$',         MapPrinter)
+    pp.add_printer('fennec::map',            '^fennec::map<.*>$',            MapPrinter)
-    pp.add_printer('fennec::object_pool', '^fennec::object_pool<.*>$', ObjectPoolPrinter)
+    pp.add_printer('fennec::object_pool',    '^fennec::object_pool<.*>$',    ObjectPoolPrinter)
-    pp.add_printer('fennec::optional',    '^fennec::optional<.*>$',    OptionalPrinter)
+    pp.add_printer('fennec::optional',       '^fennec::optional<.*>$',       OptionalPrinter)
-    pp.add_printer('fennec::pair',        '^fennec::pair<.*>$',        PairPrinter)
+    pp.add_printer('fennec::pair',           '^fennec::pair<.*>$',           PairPrinter)
-    pp.add_printer('fennec::set',         '^fennec::set<.*>$',         SetPrinter)
+    pp.add_printer('fennec::set',            '^fennec::set<.*>$',            SetPrinter)
-    pp.add_printer('fennec::rdtree',      '^fennec::rdtree<.*>$',      RDTreePrinter)
+    pp.add_printer('fennec::rdtree',         '^fennec::rdtree<.*>$',         RDTreePrinter)
-    pp.add_printer('fennec::tuple',       '^fennec::tuple<.*>$',       TuplePrinter)
+    pp.add_printer('fennec::bintree',        '^fennec::bintree<.*>$',        BinTreePrinter)
+    pp.add_printer('fennec::sequence',       '^fennec::sequence<.*>$',       SequencePrinter)
+    pp.add_printer('fennec::priority_queue', '^fennec::priority_queue<.*>$', PriorityQueuePrinter)
+    pp.add_printer('fennec::tuple',          '^fennec::tuple<.*>$',          TuplePrinter)
     return pp
 
 printer = register_printers()

gdb/fennec/filesystem.py

@@ -1,6 +1,6 @@
 # ======================================================================================================================
 #  fennec, a free and open source game engine
-#  Copyright © 2025  Medusa Slockbower
+#  Copyright © 2025 - 2026  Medusa Slockbower
 #
 #  This program is free software: you can redistribute it and/or modify
 #  it under the terms of the GNU General Public License as published by

gdb/fennec/math.py

@@ -1,6 +1,6 @@
 # ======================================================================================================================
 #  fennec, a free and open source game engine
-#  Copyright © 2025  Medusa Slockbower
+#  Copyright © 2025 - 2026  Medusa Slockbower
 #
 #  This program is free software: you can redistribute it and/or modify
 #  it under the terms of the GNU General Public License as published by
@@ -24,7 +24,7 @@ from . import utility
 class VectorPrinter:
     def __init__(self, val):
         self.val  = val
-        self.base = val['data']['elements']
+        self.base = val['data']['data']
         self.len  = self.base.type.range()[1] + 1
 
     def to_string(self):
@@ -51,7 +51,7 @@ class VectorPrinter:
 class QuaternionPrinter:
     def __init__(self, val):
         self.val  = val
-        self.base = val['data']['elements']
+        self.base = val['data']['data']
 
     def to_string(self):
         res = ("< "
@@ -72,7 +72,7 @@ class QuaternionPrinter:
 # VECTOR =================================================================================================================
 class MatrixPrinter:
     def __init__(self, val):
-        self.columns     = val['data']['elements']
+        self.columns     = val['data']['data']
         self.num_columns = self.columns.type.range()[1] + 1
         self.num_rows    = val.type.template_argument(1)
 

gdb/fennec/memory.py

@@ -1,6 +1,6 @@
 # ======================================================================================================================
 #  fennec, a free and open source game engine
-#  Copyright © 2025  Medusa Slockbower
+#  Copyright © 2025 - 2026  Medusa Slockbower
 #
 #  This program is free software: you can redistribute it and/or modify
 #  it under the terms of the GNU General Public License as published by

gdb/fennec/strings.py

@@ -1,6 +1,6 @@
 # ======================================================================================================================
 #  fennec, a free and open source game engine
-#  Copyright © 2025  Medusa Slockbower
+#  Copyright © 2025 - 2026  Medusa Slockbower
 #
 #  This program is free software: you can redistribute it and/or modify
 #  it under the terms of the GNU General Public License as published by

gdb/fennec/utility.py

@@ -1,6 +1,6 @@
 # ======================================================================================================================
 #  fennec, a free and open source game engine
-#  Copyright © 2025  Medusa Slockbower
+#  Copyright © 2025 - 2026  Medusa Slockbower
 #
 #  This program is free software: you can redistribute it and/or modify
 #  it under the terms of the GNU General Public License as published by

include/fennec/containers/array.h

@@ -1,6 +1,6 @@
 // =====================================================================================================================
 //  fennec, a free and open source game engine
-//  Copyright © 2025  Medusa Slockbower
+//  Copyright © 2025 - 2026  Medusa Slockbower
 //
 //  This program is free software: you can redistribute it and/or modify
 //  it under the terms of the GNU General Public License as published by
@@ -17,14 +17,14 @@
 // =====================================================================================================================
 
 ///
-/// \file array.h
+/// \file fennec/containers/array.h
 /// \brief A header containing the definition for a static/stack allocated array
 ///
 ///
 /// \details
 /// \author Medusa Slockbower
 ///
-/// \copyright Copyright © 2025 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
+/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
 ///
 ///
 
@@ -34,6 +34,7 @@
 
 #include <fennec/lang/types.h>
 #include <fennec/lang/assert.h>
+#include <fennec/lang/metasequences.h>
 
 namespace fennec
 {
@@ -43,115 +44,151 @@ namespace fennec
 /// \brief Data Structure that defines a compile-time allocated array
 ///
 /// \details
-/// | Property   | Value      |
+/// | Property    | Value      |
-/// |:----------:|:----------:|
+/// |:-----------:|:----------:|
-/// | stable     |      ✅     |
+/// | stable      |     ✅     |
-/// | dynamic    |      ⛔     |
+/// | dynamic     |     ⛔     |
-/// | homogenous |      ✅     |
+/// | homogeneous |     ✅     |
-/// | distinct   |      ⛔     |
+/// | distinct    |     ⛔     |
-/// | ordered    |      ⛔     |
+/// | ordered     |     ⛔     |
-/// | space      | \f$O(N)\f$ |
+/// | space       | \f$O(N)\f$ |
-/// | linear     |      ✅     |
+/// | linear      |     ✅     |
-/// | access     | \f$O(1)\f$ |
+/// | access      | \f$O(1)\f$ |
-/// | find       | \f$O(N)\f$ |
+/// | find        | \f$O(N)\f$ |
-/// | insertion  |      ⛔     |
+/// | insertion   |     ⛔     |
-/// | deletion   |      ⛔     |
+/// | deletion    |     ⛔     |
+/// | space       | \f$O(N)\f$ |
 ///
 /// \tparam ValueT value type
-/// \tparam ElemV number of elements
+/// \tparam N number of elements
-template<typename ValueT, size_t ElemV>
+template<typename ValueT, size_t N>
 struct array {
 
 // Definitions =========================================================================================================
 public:
-	using value_t = ValueT; ///< Alias for `ValueT`
 
-// Public Members ======================================================================================================
+	/// \name Definitions
-
-	/// \name Public Members
 	/// @{
 
-	///
+	using value_t = ValueT; //!< Alias for \f$ValueT\f$
-	/// \brief backing c-style array handle
+
-	value_t data[ElemV];
+	/// @}
+
+
+
+// Public Member Variables =============================================================================================
+public:
+
+	/// \name Member Variables
+	/// @{
+
+	value_t data[N]; //!< Backing c-style array handle
 
 	/// @}
 
 
 
 // Properties ==========================================================================================================
+public:
 
 	/// \name Properties
 	/// @{
 
 	///
-	/// \brief returns the number of elements in the array
+	/// \brief Returns the number of elements in the array.
-	/// \returns the number of elements in the array
+	/// \returns \f$N\f$
-	[[nodiscard]] constexpr size_t size() const { return ElemV; }
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	[[nodiscard]] constexpr size_t size() const { return N; }
 
 	///
-	/// \brief returns **true** when the array is empty
+	/// \brief Returns \f$true\f$ when the array is empty
-	/// \return \f$ElemV == 0\f$
+	/// \returns \f$ElemV == 0\f$
-	[[nodiscard]] constexpr bool_t empty() const { return ElemV == 0; }
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	[[nodiscard]] constexpr bool_t is_empty() const { return N == 0; }
 
 	/// @}
 
 
 
 // Access ==============================================================================================================
+public:
 
 	/// \name Element Access
 	/// @{
 
 	///
-	/// \copydetails array::operator[](size_t) const
-	constexpr value_t& operator[](size_t i) {
-		assertd(i < ElemV, "Array Out of Bounds");
-		return data[i];
-	}
-
-	///
-	/// \brief access specified element
 	/// \details Returns a reference to the element at \c i
 	/// \param i index of the element to return
 	/// \return reference to the requested element
 	///
-	/// \par Time-Complexity
+	/// \par Complexity
-	/// Constant
+	/// \f$O(1)\f$
 	///
-	/// \par Space-Complexity
+	constexpr value_t& operator[](size_t i) {
-	/// Constant
+		assertd(i < N, "Array Out of Bounds");
-	constexpr const value_t& operator[](size_t i) const {
-		assertd(i < ElemV, "Array Out of Bounds");
 		return data[i];
 	}
 
 	///
-	/// \brief Access the first element
+	/// \brief Indexed access
-	/// \returns A reference to the element at `elements[0]`
+	/// \details Returns a reference to the element at \c i
+	/// \param i index of the element to return
+	/// \return reference to the requested element
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	constexpr const value_t& operator[](size_t i) const {
+		assertd(i < N, "Array Out of Bounds");
+		return data[i];
+	}
+
+	///
+	/// \returns A reference to \f$data[0]\f$
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr value_t& front() {
 		return data[0];
 	}
 
 	///
-	/// \brief Const Access the first element
+	/// \brief Access the first element
-	/// \returns A const-qualified reference to the element at `elements[0]`
+	/// \returns A const-qualified reference to \f$data[0]\f$
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr const value_t& front() const {
 		return data[0];
 	}
 
 	///
-	/// \brief Access the first element
+	/// \returns A reference to \f$data[N - 1]\f$
-	/// \returns A reference to the element at `elements[ElemV - 1]`
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr value_t& back() {
-		return data[ElemV - 1];
+		return data[N - 1];
 	}
 
 	///
-	/// \brief Const Access the first element
+	/// \brief Access the last element
-	/// \returns A const-qualified reference to the element at `elements[ElemV - 1]`
+	/// \returns A const-qualified reference to \f$data[N - 1]\f$
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr const value_t& back() const {
-		return data[ElemV - 1];
+		return data[N - 1];
 	}
 
 	/// @}
@@ -159,66 +196,90 @@ public:
 
 
 // Comparison ==========================================================================================================
+public:
 
 	/// \name Comparison Operators
 	/// @{
 
 	///
 	/// \brief Checks if all elements in the arrays are equal
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
+	///
 	friend constexpr bool_t operator==(const array& lhs, const array& rhs) {
-		return array::_compare(lhs, rhs, make_index_sequence<ElemV>{});
+		return array::_compare(lhs, rhs, make_index_metasequence<N>{});
 	}
 
 	///
 	/// \brief Checks if any element in the arrays is not equal
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
+	///
 	friend constexpr bool_t operator!=(const array& lhs, const array& rhs) {
-		return not array::_compare(lhs, rhs, make_index_sequence<ElemV>{});
+		return not array::_compare(lhs, rhs, make_index_metasequence<N>{});
 	}
 
 	/// @}
 
 
 // Iteration ===========================================================================================================
+public:
 
 	/// \name Iteration
 	/// @{
 
 	///
-	/// \brief C++ Iterator Specification `begin()`
 	/// \returns A pointer to the first element of the array
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr value_t* begin() {
 		return data;
 	}
 
 	///
-	/// \brief C++ Iterator Specification `end()`
+	/// \brief C++ Iterator Specification \f$begin()\f$
-	/// \returns A pointer to one after the end of the array
-	constexpr value_t* end() {
-		return data + ElemV;
-	}
-
-
-
-	///
-	/// \brief Const C++ Iterator Specification `begin()`
 	/// \returns A const-qualified pointer to the first element of the array
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr const value_t* begin() const {
 		return data;
 	}
 
 	///
-	/// \brief Const C++ Iterator Specification `end()`
+	/// \returns A pointer to one after the end of the array
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	constexpr value_t* end() {
+		return data + N;
+	}
+
+	///
+	/// \brief C++ Iterator Specification \f$end()\f$
 	/// \returns A const-qualified pointer to one after the end of the array
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr const value_t* end() const {
-		return data + ElemV;
+		return data + N;
 	}
 
 	/// @}
 
+
+// Private Helpers =====================================================================================================
 private:
 	template<size_t...i>
-	static bool _compare(const array& lhs, const array& rhs, const_index_sequence<i...>) {
+	static bool _compare(const array& lhs, const array& rhs, index_metasequence<i...>) {
-		return ((lhs[i] == rhs[i]) && ...);
+		return ((lhs[i] == rhs[i]) and ...);
 	}
 };
 

include/fennec/containers/bitfield.h

@@ -0,0 +1,323 @@
+// =====================================================================================================================
+//  fennec, a free and open source game engine
+//  Copyright © 2025 - 2026  Medusa Slockbower
+//
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+// =====================================================================================================================
+
+///
+/// \file fennec/containers/bitfield.h
+/// \brief
+///
+///
+/// \details
+/// \author Medusa Slockbower
+///
+/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
+///
+///
+
+#ifndef FENNEC_CONTAINERS_BITFIELD_H
+#define FENNEC_CONTAINERS_BITFIELD_H
+
+#include <fennec/containers/array.h>
+#include <fennec/lang/types.h>
+#include <fennec/lang/utility.h>
+
+namespace fennec
+{
+
+///
+/// \brief Bitfield Container with basic Bit Ops
+///
+/// \details
+/// | Property    | Value      |
+/// |:-----------:|:----------:|
+/// | stable      |     ⛔     |
+/// | dynamic     |     ⛔     |
+/// | homogeneous |     ✅     |
+/// | distinct    |     ⛔     |
+/// | ordered     |     ⛔     |
+/// | space       | \f$O(N)\f$ |
+/// | linear      |     ✅     |
+/// | access      | \f$O(1)\f$ |
+/// | find        | \f$O(N)\f$ |
+/// | insertion   |     ⛔     |
+/// | deletion    |     ⛔     |
+/// | space       | \f$O(N)\f$ |
+///
+/// \tparam N The number of bits in the bitfield
+template<size_t N>
+struct bitfield {
+
+// Constants ===========================================================================================================
+public:
+
+	/// \name Constants
+	/// @{
+
+	static constexpr size_t bits  = N;           //!< The number of bits in the bitfield
+	static constexpr size_t bytes = (N + 7) / 8; //!< The number of bytes that hold the bitfield
+
+	/// @}
+
+
+// Constructors & Destructor ===========================================================================================
+public:
+
+	/// \name Constructors & Destructor
+	/// @{
+
+	///
+	/// \brief Default constructor.
+	/// \details Initializes all bits with \f$0\f$.
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
+	///
+	constexpr bitfield()
+		: _bytes() {
+	}
+
+	///
+	/// \brief Boolean array constructor.
+	/// \param arr An array of boolean values resembling each bit.
+	/// \details Initializes each bit with the respective boolean value in \f$arr\f$
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
+	///
+	explicit constexpr bitfield(const bool (&arr)[N])
+		: _bytes() {
+		for (size_t i = 0; i < arr; ++i) {
+			this->store(i, arr[i]);
+		}
+	}
+
+	///
+	/// \brief Index array constructor.
+	/// \param arr An array of indices.
+	/// \details Sets the bits of each index provided in \f$arr\f$.
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
+	///
+	template<size_t I>
+	explicit constexpr bitfield(const size_t (&arr)[I])
+		: _bytes() {
+		for (size_t i : arr) {
+			this->set(i);
+		}
+	}
+
+	///
+	/// \param args A set of indices.
+	/// \details This substitution assumes \f$ArgsT\ldots\f$ can be taken as an array of indices. <br>
+	///          Sets the bits of each index provided in \f$args\ldots\f$.
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
+	///
+	template<typename...ArgsT>
+	constexpr bitfield(ArgsT&&...args)
+		: _bytes() {
+		(this->store(fennec::forward<ArgsT>(args), true), ...);
+	}
+
+	///
+	/// \brief Variadic array constructor
+	/// \param args A set of boolean values.
+	/// \details This substitution assumes \f$ArgsT\ldots\f$ can be taken as an array of booleans. <br>
+	///          Initializes each bit with the respective boolean in \f$args\ldots\f$. <br>
+	///          Does not necessitate the number of arguments be equal to the number of bits.
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
+	///
+	template<typename...ArgsT> requires((is_bool_v<ArgsT> or is_convertible_v<ArgsT, bool>) and ...)
+	constexpr bitfield(ArgsT&&...args)
+		: _bytes() {
+		size_t i = 0;
+		(this->store(i++, fennec::forward<ArgsT>(args)), ...);
+	}
+
+	///
+	/// \brief copy constructor
+	/// \param bf bitfield to copy
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
+	///
+	bitfield(const bitfield& bf)
+		: _bytes(bf._bytes) {
+	}
+
+	///
+	/// \brief move constructor
+	/// \param bf bitfield to move
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	bitfield(bitfield&& bf) noexcept
+		: _bytes(bf._bytes) {
+	}
+
+	///
+	/// \brief destructor
+	constexpr ~bitfield() = default;
+
+	/// @}
+
+
+// Assignment ==========================================================================================================
+public:
+
+	/// \name Assignment Operators
+	/// @{
+
+	///
+	/// \brief copy assignment
+	/// \param bf bitfield to copy
+	/// \returns a reference to self
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
+	///
+	bitfield& operator=(const bitfield& bf) = default;
+
+	///
+	/// \brief move assignment
+	/// \param bf bitfield to move
+	/// \returns a reference to self
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	bitfield& operator=(bitfield&& bf) noexcept = default;
+
+	/// @}
+
+
+// Access & Modifiers ==================================================================================================
+public:
+
+	/// \name Access & Modifiers
+	/// @{
+
+	///
+	/// \brief test a bit
+	/// \param i the index of the bit
+	/// \returns the value stored in the bit as a boolean
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	bool test(size_t i) const {
+		assertd(i < bits, "Index out of Bounds!");
+		size_t b = i / 8;
+		size_t o = i % 8;
+		return _bytes[b] & (1 << o);
+	}
+
+	///
+	/// \brief set a bit
+	/// \param i the index of the bit
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	void set(size_t i) {
+		assertd(i < bits, "Index out of Bounds!");
+		size_t b = i / 8;
+		size_t o = i % 8;
+		_bytes[b] |= (1 << o);
+	}
+
+	///
+	/// \brief clear a bit
+	/// \param i the index of the bit
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	void clear(size_t i) {
+		assertd(i < bits, "Index out of Bounds!");
+		size_t b = i / 8;
+		size_t o = i % 8;
+		_bytes[b] &= ~(1 << o);
+	}
+
+	///
+	/// \brief toggle a bit
+	/// \param i the index of the bit
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	void toggle(size_t i) {
+		assertd(i < bits, "Index out of Bounds!");
+		size_t b = i / 8;
+		size_t o = i % 8;
+		_bytes[b] ^= (1 << o);
+	}
+
+	///
+	/// \brief store \f$v\f$ in bit \f$i\f$
+	/// \param i the index of the bit
+	/// \param v the value to store
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	void store(size_t i, bool v) {
+		assertd(i < bits, "Index out of Bounds!");
+		size_t b = i / 8;
+		size_t o = i % 8;
+		(_bytes[b] &= ~((1 << o))) |= ((v << o));
+	}
+
+	///
+	/// \brief not operator
+	/// \returns a bitfield containing the bit-wise inverse
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
+	///
+	bitfield operator~() const {
+		bitfield res = *this;
+		res._inv_helper(make_index_metasequence_t<bytes>{});
+		return res;
+	}
+
+	/// @}
+
+
+// Private Member Variables ============================================================================================
+private:
+	array<uint8_t, bytes> _bytes;
+
+
+// Private Helpers =====================================================================================================
+private:
+	template<size_t...I>
+	void _inv_helper(index_metasequence<I...>) {
+		((_bytes[I] = ~_bytes[I]), ...);
+	}
+};
+
+
+}
+
+#endif // FENNEC_CONTAINERS_BITFIELD_H

include/fennec/containers/containers.h

@@ -1,6 +1,6 @@
 // =====================================================================================================================
 //  fennec, a free and open source game engine
-//  Copyright © 2025  Medusa Slockbower
+//  Copyright © 2025 - 2026  Medusa Slockbower
 //
 //  This program is free software: you can redistribute it and/or modify
 //  it under the terms of the GNU General Public License as published by
@@ -17,14 +17,14 @@
 // =====================================================================================================================
 
 ///
-/// \file containers.h
+/// \file fennec/containers/containers.h
 /// \brief fennec containers library main header
 ///
 ///
 /// \details
 /// \author Medusa Slockbower
 ///
-/// \copyright Copyright © 2025 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
+/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
 ///
 ///
 
@@ -40,40 +40,58 @@
 ///
 /// \code #include <fennec/containers/containers.h> \endcode
 ///
-/// \section fennec_containers_cppstdlib C++ Standard Template Library
+/// \section fennec_containers_container_section_properties Container Properties
+///
+/// | Property        | Meaning                                                                                        |
+/// |:----------------|:-----------------------------------------------------------------------------------------------|
+/// | **stable**      | Any pointer reference to an element remains constant for the lifetime of the container.        |
+/// | **dynamic**     | Memory for this container is allocated on the heap.                                            |
+/// | **homogeneous** | The types of all elements are either identical, or inherit the same base type.                 |
+/// | **distinct**    | Elements are guaranteed to be unique in their value.                                           |
+/// | **ordered**     | Elements are guaranteed to be in order, such that for any index \f$i\f$, \f$E_i < E_{i + 1}\f$ |
+/// | **space**       | The amount of memory allocated with respect to the number of elements, in big-O notation.      |
+/// | **linear**      | Each element is sequential in terms of access.                                                 |
+/// | **access**      | The runtime of the access operators and functions, in big-O notation.                          |
+/// | **find**        | The runtime of finding an element in the container, in big-O notation.                         |
+/// | **insertion**   | The runtime of inserting an element in the container, in big-O notation.                       |
+/// | **deletion**    | The runtime of erasing an element in the container, in big-O notation.                         |
+/// | **space**       | The space complexity of the container.                                                         |
+///
+///
+/// \section fennec_containers_section_cppstdlib C++ Standard Template Library
 ///
 /// | Symbol                                                                      | Implemented | Passed |
 /// |:----------------------------------------------------------------------------|:-----------:|:------:|
-/// | \ref fennec::any               "fennec::any"                                |      ⛔      |   ⛔    |
+/// | \ref fennec::generic           "fennec::generic" `std::any`                 |      🚧     |   🚧   |
-/// | \ref fennec::array             "fennec::array"                              |      ✅      |   ✅    |
+/// | \ref fennec::array             "fennec::array"                              |      ✅     |   ✅   |
-/// | \ref fennec::bitset            "fennec::bitset"                             |      ⛔      |   ⛔    |
+/// | \ref fennec::bitfield          "fennec::bitfield" `std::bitset`             |      🚧     |   🚧   |
-/// | \ref fennec::deque             "fennec::deque"                              |      ⛔      |   ⛔    |
+/// | \ref fennec::deque             "fennec::deque"                              |      🚧     |   🚧   |
 /// | \ref fennec::dynarray          "fennec::dynarray" `std::vector`             |      🚧     |   🚧   |
-/// | \ref fennec::list              "fennec::list"                               |      ✅      |   ✅    |
+/// | \ref fennec::list              "fennec::list"                               |      ✅     |   ✅   |
-/// | \ref fennec::map               "fennec::map" `std::unordered_map`           |      ✅      |   ✅    |
+/// | \ref fennec::map               "fennec::map" `std::unordered_map`           |      ✅     |   ✅   |
-/// | \ref fennec::map_sequence      "fennec::map_sequence" `std::map`            |      ⛔      |   ⛔    |
+/// | \ref fennec::map_sequence      "fennec::map_sequence" `std::map`            |      ⛔     |   ⛔   |
-/// | \ref fennec::multiset          "fennec::multiset" `std::unordered_multiset` |      ⛔      |   ⛔    |
+/// | \ref fennec::multiset          "fennec::multiset" `std::unordered_multiset` |      ⛔     |   ⛔   |
-/// | \ref fennec::multisequence     "fennec::multisequence" `std::multiset`      |      ⛔      |   ⛔    |
+/// | \ref fennec::multisequence     "fennec::multisequence" `std::multiset`      |      ⛔     |   ⛔   |
-/// | \ref fennec::multimap          "fennec::multimap" `std::unordered_multimap` |      ⛔      |   ⛔    |
+/// | \ref fennec::multimap          "fennec::multimap" `std::unordered_multimap` |      ⛔     |   ⛔   |
-/// | \ref fennec::multimap_sequence "fennec::multimap_sequence" `std::multimap`  |      ⛔      |   ⛔    |
+/// | \ref fennec::multimap_sequence "fennec::multimap_sequence" `std::multimap`  |      ⛔     |   ⛔   |
-/// | \ref fennec::optional          "fennec::optional"                           |      ✅      |   ✅    |
+/// | \ref fennec::optional          "fennec::optional"                           |      ✅     |   ✅   |
-/// | \ref fennec::pair              "fennec::pair"                               |      ✅      |   ✅    |
+/// | \ref fennec::pair              "fennec::pair"                               |      ✅     |   ✅   |
-/// | \ref fennec::sequence          "fennec::sequence" `std::set`                |      ⛔      |   ⛔    |
+/// | \ref fennec::sequence          "fennec::sequence" `std::set`                |      🚧     |   🚧   |
-/// | \ref fennec::set               "fennec::set" `std::unordered_set`           |      ✅      |   ✅    |
+/// | \ref fennec::set               "fennec::set" `std::unordered_set`           |      ✅     |   ✅   |
 /// | \ref fennec::tuple             "fennec::tuple"                              |      🚧     |   🚧   |
-/// | \ref fennec::variant           "fennec::variant"                            |      ⛔      |   ⛔    |
+/// | \ref fennec::variant           "fennec::variant"                            |      🚧     |   🚧   |
 ///
 ///
-/// \section fennec_containers_fennec fennec
+/// \section fennec_containers_section_fennec fennec
 ///
 /// | Symbol                   | Implemented | Passed |
 /// |:-------------------------|:-----------:|:------:|
 /// | \ref fennec::graph       |      🚧     |   🚧   |
 /// | \ref fennec::object_pool |      🚧     |   🚧   |
-/// | \ref fennec::rdtree      |      ✅      |   ✅    |
+/// | \ref fennec::rdtree      |      ✅     |   ✅   |
 ///
 ///
-/// \copyright Copyright © 2025 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
+/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
 ///
 
 #include <fennec/containers/traversal.h>

include/fennec/containers/deque.h

@@ -1,6 +1,6 @@
 // =====================================================================================================================
 //  fennec, a free and open source game engine
-//  Copyright © 2025  Medusa Slockbower
+//  Copyright © 2025 - 2026  Medusa Slockbower
 //
 //  This program is free software: you can redistribute it and/or modify
 //  it under the terms of the GNU General Public License as published by
@@ -17,14 +17,14 @@
 // =====================================================================================================================
 
 ///
-/// \file deque.h
+/// \file fennec/containers/deque.h
 /// \brief A header containing the definition for a double-ended queue
 ///
 ///
 /// \details
 /// \author Medusa Slockbower
 ///
-/// \copyright Copyright © 2025 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
+/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
 ///
 ///
 
@@ -46,46 +46,42 @@ namespace fennec
 /// This behaves the similar to fennec::list, however it does not allow arbitrary access, insertion, or deletion.
 /// It is one of the few data structures in this library that is stable, i.e. pointers to elements do not change.
 ///
-/// | Property   | Value      |
+/// | Property    | Value      |
-/// |:----------:|:----------:|
+/// |:-----------:|:----------:|
-/// | stable     |      ✅     |
+/// | stable      |     ✅     |
-/// | dynamic    |      ✅     |
+/// | dynamic     |     ✅     |
-/// | homogenous |      ✅     |
+/// | homogeneous |     ✅     |
-/// | distinct   |      ⛔     |
+/// | distinct    |     ⛔     |
-/// | ordered    |      ⛔     |
+/// | ordered     |     ⛔     |
-/// | space      | \f$O(N)\f$ |
+/// | space       | \f$O(N)\f$ |
-/// | linear     |      ⛔     |
+/// | linear      |     ⛔     |
-/// | access     | \f$O(1)\f$ |
+/// | access      | \f$O(1)\f$ |
-/// | find       | \f$O(N)\f$ |
+/// | find        | \f$O(N)\f$ |
-/// | insertion  | \f$O(1)\f$ |
+/// | insertion   | \f$O(1)\f$ |
-/// | deletion   | \f$O(1)\f$ |
+/// | deletion    | \f$O(1)\f$ |
+/// | space       | \f$O(N)\f$ |
 ///
 /// \tparam TypeT value type
 template<typename TypeT, typename AllocT = allocator<TypeT>>
 struct deque {
 
 // Definitions =========================================================================================================
-public:
-	using value_t = TypeT; ///< Alias for the value type
-	class iterator;
-
 private:
-	struct node {
+	struct node;
-		value_t value;
-		node *prev, *next;
-
-		template<typename...ArgsT>
-		node(node* prev, node* next, ArgsT&&...args)
-			: value(fennec::forward<ArgsT>(args)...)
-			, prev(prev), next(next) {
-		}
-
-		~node() = default;
-	};
 
 public:
-	using alloc_t = allocator_traits<AllocT>::template rebind<node>;
+
-	using elem_t  = node*;
+	/// \name Definitions
+	/// @{
+
+	using value_t = TypeT; //!< Alias for the value type
+	using alloc_t = allocator_traits<AllocT>::template rebind<node>; //!< The underlying allocator type
+	using elem_t  = node*;                                           //!< The underlying element type
+
+	/// @}
+
+
+	class iterator;
 
 
 // Constructors ========================================================================================================
@@ -95,6 +91,10 @@ public:
 
 	///
 	/// \brief Default Constructor, initializes an empty deque
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	deque()
 		: _alloc()
 		, _first(nullptr)
@@ -105,6 +105,10 @@ public:
 	///
 	/// \brief Alloc Constructor, initializes an empty deque with the specified allocator
 	/// \param alloc the allocator to copy
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	deque(const alloc_t& alloc)
 		: _alloc(alloc)
 		, _first(nullptr)
@@ -115,6 +119,10 @@ public:
 	///
 	/// \brief Copy Constructor
 	/// \param deque the deque to copy
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
+	///
 	deque(const deque& deque)
 		: _alloc(deque._alloc)
 		, _first(nullptr)
@@ -130,6 +138,10 @@ public:
 	///
 	/// \brief Deque Move Constructor
 	/// \param deque the deque to move
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	deque(deque&& deque) noexcept
 		: _alloc(deque._alloc)
 		, _first(deque._first)
@@ -141,6 +153,10 @@ public:
 
 	///
 	/// \brief Destructor, calls deque::clear
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
+	///
 	~deque() {
 		clear();
 	}
@@ -153,13 +169,21 @@ public:
 	/// @{
 
 	///
-	/// \returns `true` when the deque is empty, `false` otherwise
+	/// \returns \f$true\f$ when the deque is empty, \f$false\f$ otherwise
-	constexpr bool empty() const {
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	constexpr bool is_empty() const {
 		return _size == 0;
 	}
 
 	///
-	/// \returns the number of elements in size()
+	/// \returns the number of elements in the deque
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr size_t size() const {
 		return _size;
 	}
@@ -174,29 +198,45 @@ public:
 
 	///
 	/// \returns a reference to the first element in the deque
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	value_t& front() {
-		assert(not empty(), "Attempted to access an empty deque.");
+		assert(not is_empty(), "Attempted to access an empty deque.");
 		return _first->value;
 	}
 
 	///
 	/// \returns a const-qualified reference to the first element in the deque
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	const value_t& front() const {
-		assert(not empty(), "Attempted to access an empty deque.");
+		assert(not is_empty(), "Attempted to access an empty deque.");
 		return _first->value;
 	}
 
 	///
 	/// \returns a reference to the last element in the deque
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	value_t& back() {
-		assert(not empty(), "Attempted to access an empty deque.");
+		assert(not is_empty(), "Attempted to access an empty deque.");
 		return _last->value;
 	}
 
 	///
 	/// \returns a const-qualified reference to the last element in the deque
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	const value_t& back() const {
-		assert(not empty(), "Attempted to access an empty deque.");
+		assert(not is_empty(), "Attempted to access an empty deque.");
 		return _last->value;
 	}
 
@@ -211,6 +251,10 @@ public:
 	///
 	/// \brief Push Front Move, moves a value to the front of the deque
 	/// \param elem the value to move
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	void push_front(value_t&& elem) {
 		this->_push_front(elem);
 	}
@@ -218,6 +262,10 @@ public:
 	///
 	/// \brief Push Front Copy, copies a value to the front of the deque
 	/// \param elem the value to copy
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	void push_front(const value_t& elem) {
 		this->_push_front(elem);
 	}
@@ -226,6 +274,10 @@ public:
 	/// \brief Emplace Front, constructs a new value at the front of the deque
 	/// \tparam ArgsT Argument types
 	/// \param args Arguments used to construct the value
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	template<typename...ArgsT>
 	void emplace_front(ArgsT&&...args) {
 		this->_push_front(fennec::forward<ArgsT>(args)...);
@@ -235,6 +287,10 @@ public:
 	///
 	/// \brief Push Back Move, moves a value to the back of the deque
 	/// \param elem the value to move
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	void push_back(value_t&& elem) {
 		this->_push_back(elem);
 	}
@@ -242,6 +298,10 @@ public:
 	///
 	/// \brief Push Back Copy, copies a value to the back of the deque
 	/// \param elem the value to copy
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	void push_back(const value_t& elem) {
 		this->_push_back(elem);
 	}
@@ -250,6 +310,10 @@ public:
 	/// \brief Emplace Back, constructs a new value at the back of the deque
 	/// \tparam ArgsT Argument types
 	/// \param args Arguments used to construct the value
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	template<typename...ArgsT>
 	void emplace_back(ArgsT&&...args) {
 		this->_push_back(fennec::forward<ArgsT>(args)...);
@@ -257,6 +321,10 @@ public:
 
 	///
 	/// \brief Clears the contents of the deque
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
+	///
 	void clear() {
 		elem_t it = _first;
 		while (it) {
@@ -272,6 +340,10 @@ public:
 
 	///
 	/// \brief Erase the First Element
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	void pop_front() {
 		if (_first == nullptr) {
 			return;
@@ -286,6 +358,10 @@ public:
 
 	///
 	/// \brief Erase the Last Element
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	void pop_back() {
 		if (_last == nullptr) {
 			return;
@@ -307,11 +383,16 @@ public:
 	 * TODO: Decide whether you should be able to iterate over a deque
 	 */
 
+
+// Private Member Variables ============================================================================================
 private:
 	alloc_t _alloc;
 	node   *_first, *_last;
 	size_t  _size;
 
+
+// Private Helpers =====================================================================================================
+private:
 	template<typename...ArgsT>
 	void _push_front(ArgsT&&...args) {
 		elem_t next = _first;
@@ -337,6 +418,22 @@ private:
 		}
 		++_size;
 	}
+
+
+// Private Definitions =================================================================================================
+private:
+	struct node {
+		value_t value;
+		node *prev, *next;
+
+		template<typename...ArgsT>
+		node(node* prev, node* next, ArgsT&&...args)
+			: value(fennec::forward<ArgsT>(args)...)
+			, prev(prev), next(next) {
+		}
+
+		~node() = default;
+	};
 };
 
 

include/fennec/containers/detail/_tuple.h

@@ -1,6 +1,6 @@
 // =====================================================================================================================
 //  fennec, a free and open source game engine
-//  Copyright © 2025  Medusa Slockbower
+//  Copyright © 2025 - 2026  Medusa Slockbower
 //
 //  This program is free software: you can redistribute it and/or modify
 //  it under the terms of the GNU General Public License as published by
@@ -18,14 +18,14 @@
 
 #ifndef FENNEC_CONTAINERS_DETAIL_TUPLE_H
 #define FENNEC_CONTAINERS_DETAIL_TUPLE_H
-#include <fennec/lang/const_sequences.h>
+#include <fennec/lang/metasequences.h>
 #include <fennec/lang/utility.h>
 
 namespace fennec::detail
 {
 
 
-template <std::size_t I, typename T>
+template <size_t I, typename T>
 struct _tuple_leaf
 {
     template <typename ArgT>
@@ -43,7 +43,7 @@ template <typename, typename...>
 struct _tuple;
 
 template <size_t...IndicesV, typename...TypesT>
-struct _tuple<const_index_sequence<IndicesV...>, TypesT...> : _tuple_leaf<IndicesV, TypesT>...
+struct _tuple<index_metasequence<IndicesV...>, TypesT...> : _tuple_leaf<IndicesV, TypesT>...
 {
     template <typename...ArgsT>
     constexpr _tuple(ArgsT&&... args)

include/fennec/containers/dynarray.h

@@ -1,6 +1,6 @@
 // =====================================================================================================================
 //  fennec, a free and open source game engine
-//  Copyright © 2025  Medusa Slockbower
+//  Copyright © 2025 - 2026  Medusa Slockbower
 //
 //  This program is free software: you can redistribute it and/or modify
 //  it under the terms of the GNU General Public License as published by
@@ -17,20 +17,21 @@
 // =====================================================================================================================
 
 ///
-/// \file dynarray.h
+/// \file fennec/containers/dynarray.h
 /// \brief A header containing the definition for a dynamically allocated array
 ///
 ///
 /// \details
 /// \author Medusa Slockbower
 ///
-/// \copyright Copyright © 2025 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
+/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
 ///
 ///
 
 #ifndef FENNEC_CONTAINERS_DYNARRAY_H
 #define FENNEC_CONTAINERS_DYNARRAY_H
 
+#include <fennec/containers/initializer_list.h>
 #include <fennec/lang/utility.h>
 #include <fennec/memory/allocator.h>
 #include <fennec/memory/new.h>
@@ -42,40 +43,51 @@ namespace fennec
 ///
 /// \brief Wrapper for dynamically sized and allocated arrays
 /// \details
-/// | Property   | Value      |
+/// | Property    | Value      |
-/// |:----------:|:----------:|
+/// |:-----------:|:----------:|
-/// | stable     |      ⛔     |
+/// | stable      |     ⛔     |
-/// | dynamic    |      ✅     |
+/// | dynamic     |     ✅     |
-/// | homogenous |      ✅     |
+/// | homogeneous |     ✅     |
-/// | distinct   |      ⛔     |
+/// | distinct    |     ⛔     |
-/// | ordered    |      ⛔     |
+/// | ordered     |     ⛔     |
-/// | space      | \f$O(N)\f$ |
+/// | space       | \f$O(N)\f$ |
-/// | linear     |      ✅     |
+/// | linear      |     ✅     |
-/// | access     | \f$O(1)\f$ |
+/// | access      | \f$O(1)\f$ |
-/// | find       | \f$O(N)\f$ |
+/// | find        | \f$O(N)\f$ |
-/// | insertion  | \f$O(N)\f$ |
+/// | insertion   | \f$O(N)\f$ |
-/// | deletion   | \f$O(N)\f$ |
+/// | deletion    | \f$O(N)\f$ |
+/// | space       | \f$O(N)\f$ |
 ///
 /// This structure prefers shallow moves and deep copies.
 ///
 /// \tparam TypeT value type
 template<class TypeT, class Alloc = allocator<TypeT>>
-class dynarray {
+struct dynarray {
-public:
 
 // Definitions =========================================================================================================
+public:
 
-	using value_t = TypeT; ///< Alias for the value type
+	/// \name Definitions
-	using alloc_t = Alloc; ///< Alias for the allocator type
+	/// @{
+
+	using value_t = TypeT; //!< Alias for the value type
+	using alloc_t = Alloc; //!< Alias for the allocator type
+
+	/// @}
 
 
 // Constructors ========================================================================================================
+public:
 
 	/// \name Constructors & Destructor
 	/// @{
 
 	///
 	/// \brief Default Constructor, initializes an empty allocation.
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr dynarray()
 		: _alloc(8)
 		, _size(0) {
@@ -85,23 +97,22 @@ public:
 	/// \brief Alloc Constructor, initialize empty allocation with allocator instance.
 	/// \param alloc An allocator object to copy, for instances where the allocator needs to be initialized with some
 	///        data.
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	explicit constexpr dynarray(const alloc_t& alloc)
 		: _alloc(8, alloc)
 		, _size(0) {
 	}
 
 	///
-	/// \brief Alloc Move Constructor, initialize empty allocation with allocator instance.
+	/// \brief Sized Allocation, initializes a dynarray with \f$n\f$ elements using the default constructor.
-	/// \param alloc An allocator object to copy, for instances where the allocator needs to be initialized with some
-	///        data.
-	explicit constexpr dynarray(alloc_t&& alloc) noexcept
-		: _alloc(8, alloc)
-		, _size(0) {
-	}
-
-	///
-	/// \brief Sized Allocation, initializes a dynarray with `n` elements using the default constructor.
 	/// \param n The number of elements.
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
+	///
 	explicit constexpr dynarray(size_t n)
 		: _alloc(n)
 		, _size(n)
@@ -113,10 +124,14 @@ public:
 	}
 
 	///
-	/// \brief Sized Allocation Alloc Constructor, initializes a dynarray with allocator `alloc` and `n` elements
+	/// \brief Sized Allocation Alloc Constructor, initializes a dynarray with allocator \f$alloc\f$ and \f$n\f$ elements
 	///        using the default constructor.
 	/// \param n The number of elements
 	/// \param alloc The allocator object to copy
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
+	///
 	constexpr dynarray(size_t n, const alloc_t& alloc)
 		: _alloc(n, alloc)
 		, _size(n) {
@@ -127,24 +142,14 @@ public:
 	}
 
 	///
-	/// \brief Sized Allocation Alloc Move Constructor, initializes a dynarray with allocator `alloc` and `n` elements
+	/// \brief Sized Allocation Copy Constructor, Create an allocation of size \f$n\f$ elements, with each element
-	///        using the default constructor.
-	/// \param n The number of elements
-	/// \param alloc The allocator object to copy
-	constexpr dynarray(size_t n, alloc_t&& alloc)
-		: _alloc(n, alloc)
-		, _size(n) {
-		value_t* addr = _alloc.data();
-		for(; n > 0; --n, ++addr) {
-			fennec::construct(addr);
-		}
-	}
-
-	///
-	/// \brief Sized Allocation Copy Constructor, Create an allocation of size `n` elements, with each element
 	///        constructed using the copy constructor
 	/// \param n the number of elements
 	/// \param val the value to copy
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
+	///
 	constexpr dynarray(size_t n, const TypeT& val)
 		: _alloc(n)
 		, _size(n) {
@@ -154,15 +159,15 @@ public:
 		}
 	}
 
-	// This constructor should not be invokable since moving is a single object operation and will cause undefined
-	// behaviour when moving to multiple elements
-	constexpr dynarray(size_t n, TypeT&&) = delete;
-
 	///
 	/// \brief Emplace Constructor
 	/// \tparam ArgsT A sequence of argument types
 	/// \param n The number of objects to create
 	/// \param args The arguments to create each object with
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
+	///
 	template<typename...ArgsT>
 	constexpr explicit dynarray(size_t n, ArgsT&&...args)
 		: _alloc(n)
@@ -172,9 +177,83 @@ public:
 		}
 	}
 
+	///
+	/// \brief Array Copy Constructor
+	/// \tparam N The length of the array, automatically deduced
+	/// \param arr The array to copy
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
+	///
+	template<size_t N>
+	constexpr dynarray(const TypeT (&arr)[N])
+		: _alloc(N)
+		, _size(N) {
+		for (size_t i = 0; i < N; ++i) {
+			_alloc[i] = arr[i];
+		}
+	}
+
+	///
+	/// \brief Array Move Constructor
+	/// \tparam N The length of the array, automatically deduced
+	/// \param arr The array to move
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
+	///
+	template<size_t N>
+	constexpr dynarray(TypeT (&&arr)[N])
+		: _alloc(N)
+		, _size(N) {
+		for (size_t i = 0; i < N; ++i) {
+			_alloc[i] = fennec::move(arr[i]);
+		}
+	}
+
+	///
+	/// \brief Conversion Constructor, copies elements of conv as this \f$value_t\f$
+	/// \tparam OTypeT The other value type
+	/// \tparam OAlloc The other allocator type
+	/// \param conv The dynarray to convert
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
+	///
+	template<typename OTypeT, class OAlloc>
+	constexpr dynarray(const dynarray<OTypeT, OAlloc>& conv)
+		: _alloc(conv.size())
+		, _size(conv.size()) {
+		size_t i = 0;
+		for (const auto& it : conv) {
+			fennec::construct(&_alloc[i++], it);
+		}
+	}
+
+	///
+	/// \brief Initializer List Constructor
+	/// \param l List of elements to initialize with
+	/// \param alloc An allocator object to copy
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
+	///
+	constexpr dynarray(initializer_list<value_t> l, const alloc_t& alloc = alloc_t())
+		: _alloc(l.size(), alloc)
+		, _size(l.size()) {
+		size_t i = 0;
+		for (auto& it : l) {
+			fennec::construct(&_alloc[i++], fennec::move(it));
+		}
+	}
+
 	///
 	/// \brief Copy Constructor, uses the copy constructor to copy each element
 	/// \param arr the dynarray to copy
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
+	///
 	constexpr dynarray(const dynarray& arr)
 		: _alloc(arr._size)
 		, _size(arr._size) {
@@ -186,6 +265,10 @@ public:
 	///
 	/// \brief Move Constructor, takes ownership of the allocation
 	/// \param arr the dynarray to move
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr dynarray(dynarray&& arr) noexcept
 		: _alloc(fennec::move(arr._alloc))
 		, _size(arr._size) {
@@ -194,6 +277,10 @@ public:
 
 	///
 	/// \brief Default Destructor, destructs all elements and frees the underlying allocation
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
+	///
 	constexpr ~dynarray() {
 		value_t* addr = _alloc.data();
 		if (addr == nullptr) return;
@@ -204,7 +291,15 @@ public:
 
 	/// @}
 
+
+private:
+	// This constructor should not be invokable since moving is a single object operation and will cause undefined
+	// behaviour when moving to multiple elements
+	constexpr dynarray(size_t n, TypeT&& val) = delete;
+
+
 // Assignment ==========================================================================================================
+public:
 
 	/// \name Properties
 	/// @{
@@ -212,10 +307,14 @@ public:
 	///
 	/// \brief Copy Assignment Operator
 	/// \param arr the array to copy
-	/// \returns A dynarray after having copied each element of `arr`
+	/// \returns A dynarray after having copied each element of \f$arr\f$
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
+	///
 	constexpr dynarray& operator=(const dynarray& arr) {
 		this->clear();
-		_alloc.creallocate(_size = arr._size);
+		_alloc.reallocate(_size = arr._size);
 		for (size_t i = 0; i < _size; ++i) {
 			fennec::construct(&_alloc[i], fennec::copy(arr[i]));
 		}
@@ -225,7 +324,11 @@ public:
 	///
 	/// \brief Move Assignment Operator
 	/// \param arr the array to move
-	/// \returns A dynarray after having taken ownership of the contents of `arr`
+	/// \returns A dynarray after having taken ownership of the contents of \f$arr\f$
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr dynarray& operator=(dynarray&& arr) noexcept {
 		this->clear();
 		_alloc = fennec::move(arr._alloc);
@@ -234,28 +337,79 @@ public:
 		return *this;
 	}
 
+	///
+	/// \brief Array Copy Assignment Operator
+	/// \tparam N the length of the array
+	/// \param arr the array to copy
+	/// \returns A dynarray after having copied each element of \f$arr\f$
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
+	///
+	template<size_t N>
+	constexpr dynarray& operator=(const TypeT (&arr)[N]) {
+		this->clear();
+		_alloc.reallocate(_size = N);
+		for (size_t i = 0; i < _size; ++i) {
+			fennec::construct(&_alloc[i], fennec::copy(arr[i]));
+		}
+		return *this;
+	}
+
+	///
+	/// \brief Array Copy Assignment Operator
+	/// \tparam N the length of the array
+	/// \param arr the array to copy
+	/// \returns A dynarray after having moved each element of \f$arr\f$
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
+	///
+	template<size_t N>
+	constexpr dynarray& operator=(TypeT (&&arr)[N]) {
+		this->clear();
+		_alloc.reallocate(_size = N);
+		for (size_t i = 0; i < _size; ++i) {
+			fennec::construct(&_alloc[i], fennec::move(arr[i]));
+		}
+		return *this;
+	}
+
 	/// @}
 
 // Properties ==========================================================================================================
+public:
 
 	/// \name Properties
 	/// @{
 
 	///
 	/// \returns The size of the dynarray in elements
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr size_t size() const {
 		return _size;
 	}
 
 	///
 	/// \returns The current capacity, in elements, of the underlying allocation
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr size_t capacity() const {
 		return _alloc.capacity();
 	}
 
 	///
 	/// \returns True when there are no elements active, otherwise false
-	constexpr bool empty() const {
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	constexpr bool is_empty() const {
 		return _size == 0;
 	}
 
@@ -263,6 +417,7 @@ public:
 
 
 // Element Access ======================================================================================================
+public:
 
 	/// \name Access
 	/// @{
@@ -270,49 +425,94 @@ public:
 	///
 	/// \brief Array Access Operator
 	/// \param i The index to access
-	/// \returns A reference to the element at index `i`
+	/// \returns A reference to the element at index \f$i\f$
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr TypeT& operator[](size_t i) {
 		assertd(i < _size, "Array Out of Bounds");
-		return _alloc.data()[i];
+		return _alloc[i];
 	}
 
 	///
 	/// \brief Array Access Operator (const)
 	/// \param i The index to access
-	/// \returns A const qualified reference to the element at index `i`
+	/// \returns A const qualified reference to the element at index \f$i\f$
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr const TypeT& operator[](size_t i) const {
 		assertd(i < _size, "Array Out of Bounds");
-		return _alloc.data()[i];
+		return _alloc[i];
 	}
 
 	///
 	/// \returns Reference to the first element in the dynarray
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr TypeT& front() {
 		return this->operator[](0);
 	}
 
 	///
 	/// \returns A const-qualified reference to the first element in the dynarray
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr const TypeT& front() const {
 		return this->operator[](0);
 	}
 
 	///
 	/// \returns A reference to the last element in the dynarray
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr TypeT& back() {
 		return this->operator[](size() - 1);
 	}
 
 	///
 	/// \returns A const-qualified reference to the last element in the dynarray
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr const TypeT& back() const {
 		return this->operator[](size() - 1);
 	}
 
+	///
+	/// \returns A pointer to the underlying allocation
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	constexpr TypeT* data() {
+		return _alloc.data();
+	}
+
+	///
+	/// \returns A pointer to the underlying allocation
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	constexpr const TypeT* data() const {
+		return _alloc.data();
+	}
+
 	/// @}
 
 
 // Modifiers ===========================================================================================================
+public:
 
 	/// \name Modifiers
 	/// @{
@@ -321,6 +521,10 @@ public:
 	/// \brief Move Insertion
 	/// \param i index to insert at
 	/// \param val the value to initialize with
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
+	///
 	constexpr void insert(size_t i, TypeT&& val) {
 
 		// Grow if the size has reached the capacity of the allocation
@@ -345,6 +549,10 @@ public:
 	/// \brief Copy Insertion
 	/// \param i index to insert at
 	/// \param val the value to initialize with
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
+	///
 	constexpr void insert(size_t i, const TypeT& val) {
 
 		// Grow if the size has reached the capacity of the allocation
@@ -371,6 +579,10 @@ public:
 	/// \param i index to insert at
 	/// \param args Arguments to construct with
 	/// \tparam ArgsT Argument types
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
+	///
 	template<typename...ArgsT>
 	constexpr void emplace(size_t i, ArgsT&&...args) {
 
@@ -395,6 +607,10 @@ public:
 	///
 	/// \brief Push Back Copy
 	/// \param val Value to initialize with
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr void push_back(const TypeT& val) {
 		dynarray::insert(_size, val);
 	}
@@ -402,6 +618,10 @@ public:
 	///
 	/// \brief Push Back Move
 	/// \param val Value to initialize with
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr void push_back(TypeT&& val) {
 		dynarray::insert(_size, fennec::forward<TypeT>(val));
 	}
@@ -410,6 +630,10 @@ public:
 	/// \brief Emplace Back
 	/// \tparam ArgsT Argument Types
 	/// \param args Arguments to construct with
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	template<typename...ArgsT>
 	constexpr void emplace_back(ArgsT...args) {
 		dynarray::emplace(_size, fennec::forward<ArgsT>(args)...);
@@ -417,6 +641,10 @@ public:
 
 	///
 	/// \brief Erase last element
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr void pop_back() {
 		fennec::destruct(&_alloc[--_size]);
 	}
@@ -424,20 +652,66 @@ public:
 	///
 	/// \brief Resize the dynarray, invoking the default constructor for all new elements
 	/// \param n The new size in elements
+	///
+	/// \details if \f$n\f$ is less than the current size, any elements that would be removed are destructed
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
+	///
 	constexpr void resize(size_t n) {
-		_alloc.creallocate(n);
+		_reduce(n);
+		_alloc.reallocate(n);
 
-		while (_size < n) {
+		for (size_t i = _size; i < n; ++i) {
-			emplace_back();
+			fennec::construct(&_alloc[i]);
 		}
+
+		_size = n;
+	}
+
+	///
+	/// \brief Resize the dynarray, invoking the copy constructor for all new elements
+	/// \param n The new size in elements
+	/// \param val The value to fill with
+	///
+	/// \details if \f$n\f$ is less than the current size, any elements that would be removed are destructed
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
+	///
+	constexpr void resize(size_t n, const TypeT& val) {
+		_reduce(n);
+		_alloc.reallocate(n);
+
+		for (size_t i = _size; i < n; ++i) {
+			fennec::construct(&_alloc[i], val);
+		}
+
+		_size = n;
+	}
+
+	///
+	/// \brief Reserve the array, allocating new space without initialization
+	/// \param n The new capacity in elements
+	///
+	/// \details if \f$n\f$ is less than the current size, any elements that would be removed are destructed
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
+	///
+	constexpr void reserve(size_t n) {
+		_reduce(n);
+		_alloc.reallocate(n);
 	}
 
 	///
 	/// \brief Clears the contents of the dynarray, destructing all elements and releasing the allocation.
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
+	///
 	constexpr void clear() {
-		while (_size > 0) {
+		_reduce(0);
-			fennec::destruct(&_alloc[--_size]);
-		}
 		_alloc.deallocate();
 	}
 
@@ -445,39 +719,68 @@ public:
 
 
 // Iteration ===========================================================================================================
+public:
 
 	/// \name Iteration
 	/// @{
 
 	///
-	/// \brief "Iterator" Begin Function
 	/// \returns A pointer to the first element in the dynarray
-	constexpr TypeT* begin() { return _alloc.data(); }
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	constexpr TypeT* begin() { return _alloc; }
 
 	///
-	/// \brief "Iterator" End Function
+	/// \brief C++ Iterator Specification \f$begin()\f$
-	/// \return A pointer to the address after the last element in the dynarray
-	constexpr TypeT* end()   { return begin() + _size; }
-
-	///
-	/// \brief Const "Iterator" Begin Function
 	/// \returns A const qualified pointer to the first element in the dynarray
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr const TypeT* begin() const { return _alloc; }
 
+
 	///
-	/// \brief Const "Iterator" End Function
+	/// \return A pointer to the address after the last element in the dynarray
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	constexpr TypeT* end() { return begin() + _size; }
+
+	///
+	/// \brief C++ Iterator Specification \f$end()\f$
 	/// \return A const qualified pointer to the address after the last element in the dynarray
-	constexpr const TypeT* end()   const { return begin() + _size; }
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	constexpr const TypeT* end() const { return begin() + _size; }
 
 	/// @}
 
+// Public Member Variables =============================================================================================
 private:
-	constexpr void _grow() {
-		_alloc.creallocate(_alloc.capacity() * 2);
-	}
-
 	allocation<value_t, alloc_t> _alloc;
 	size_t _size;
+
+
+// Private Helpers =====================================================================================================
+private:
+
+	// helper to double the capacity of the allocation
+	constexpr void _grow() {
+		_alloc.reallocate(_alloc.capacity() * 2);
+	}
+
+	// helper to destruct elements past n
+	constexpr void _reduce(size_t n) {
+		while (_size > n) {
+			fennec::destruct(&_alloc[--_size]);
+		}
+	}
 };
 
 }

include/fennec/containers/generic.h

@@ -0,0 +1,363 @@
+// =====================================================================================================================
+//  fennec, a free and open source game engine
+//  Copyright © 2025 - 2026  Medusa Slockbower
+//
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+// =====================================================================================================================
+
+///
+/// \file fennec/containers/generic.h
+/// \brief
+///
+///
+/// \details
+/// \author Medusa Slockbower
+///
+/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
+///
+///
+
+#ifndef FENNEC_CONTAINERS_GENERIC_H
+#define FENNEC_CONTAINERS_GENERIC_H
+
+#include <fennec/memory/allocator.h>
+#include <fennec/rtti/type.h>
+
+namespace fennec
+{
+
+///
+/// \brief A struct capable of holding a single object of any type
+/// \details
+/// | Property    | Value      |
+/// |:-----------:|:----------:|
+/// | stable      |     ✅     |
+/// | dynamic     |     ⛔     |
+/// | homogeneous |     ⛔     |
+/// | distinct    |     ⛔     |
+/// | ordered     |     ⛔     |
+/// | space       | \f$O(1)\f$ |
+/// | linear      |     ✅     |
+/// | access      | \f$O(1)\f$ |
+/// | find        |     ⛔     |
+/// | insertion   | \f$O(1)\f$ |
+/// | deletion    | \f$O(1)\f$ |
+/// | space       | \f$O(1)\f$ |
+struct generic {
+
+// Definitions =========================================================================================================
+private:
+
+	// based on GCC
+	enum op_ : uint8_t {
+		op_clone,
+		op_destroy,
+		op_type,
+	};
+
+	using manager_t = void* (*)(uint8_t, void*);
+
+
+// Constructors & Destructor ===========================================================================================
+public:
+
+	/// \name Constructors & Destructor
+	/// @{
+
+	///
+	/// \brief Default Constructor
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	generic()
+		: _handle(nullptr)
+		, _manage(nullptr) {
+	}
+
+	///
+	/// \brief Copy Constructor
+	/// \param gen The generic object to copy
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	generic(const generic& gen)
+		: _handle(nullptr)
+		, _manage(gen._manage) {
+		if (_manage) {
+			_handle = _manage(op_clone, gen._handle);
+		}
+	}
+
+	///
+	/// \brief Move Constructor
+	/// \param gen The generic object to move
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	generic(generic&& gen)
+		: _handle(gen._handle)
+		, _manage(gen._manage) {
+		gen._handle = nullptr;
+		gen._manage = nullptr;
+	}
+
+	///
+	/// \brief Value Constructor
+	/// \tparam T The type of the value
+	/// \param x The value
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	template<typename T>
+	generic(T&& x)
+		: _handle(new T(fennec::forward<T>(x)))
+		, _manage(_manage_impl<T>) {
+	}
+
+	///
+	/// \brief Emplace Constructor
+	/// \tparam T The type to construct
+	/// \tparam ArgsT The argument types
+	/// \param args The argument values
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	template<typename T, typename...ArgsT>
+	generic(type_identity<T>, ArgsT&&...args)
+		: _handle(new T(fennec::forward<ArgsT>(args)...))
+		, _manage(_manage_impl<T>) {
+	}
+
+	///
+	/// \brief Destructor
+	~generic() {
+		reset();
+	}
+
+	/// @}
+
+
+// Properties ==========================================================================================================
+public:
+
+	/// \name Properties
+	/// @{
+
+	///
+	/// \brief runtime type acquisition
+	/// \returns a runtime type struct referencing the held type
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	type type() const {
+		return *static_cast<fennec::type*>(_manage(op_type, nullptr));
+	}
+
+	///
+	/// \returns \f$true\f$ if there is a held value, \f$false\f$ otherwise
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	bool has_value() const {
+		return _handle != nullptr;
+	}
+
+	/// @}
+
+
+// Assignment ==========================================================================================================
+public:
+
+	/// \name Assignment Operators
+	/// @{
+
+	///
+	/// \brief copy assignment
+	/// \param gen the generic to copy
+	/// \returns a reference to self after copying the contents of \f$gen\f$
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	generic& operator=(const generic& gen) {
+		if (this == &gen) { // self-assignment case
+			return *this;
+		}
+
+		reset();
+		_manage = gen._manage;
+		_handle = _manage(op_clone, gen._handle);
+		return *this;
+	}
+
+	///
+	/// \brief move assignment
+	/// \param gen the generic to move
+	/// \returns a reference to self after swapping contents with \f$gen\f$
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	generic& operator=(generic&& gen) noexcept {
+		swap(gen);
+		return *this;
+	}
+
+	///
+	/// \brief value assignment
+	/// \tparam T the type of the value
+	/// \param x the value to assign
+	/// \returns a reference to self after having assigned \f$x\f$
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	template<typename T>
+	generic& operator=(T&& x) {
+		reset();
+		_handle = new T(fennec::forward<T>(x));
+		_manage = _manage_impl<T>();
+		return *this;
+	}
+
+	/// @}
+
+
+// Modifiers ===========================================================================================================
+public:
+
+	/// \name Modifiers
+	/// @{
+
+	///
+	/// \brief emplace value
+	///
+	/// \details constructs a new value of type \f$T\f$ using \f$args\ldots\f$
+	/// \tparam T the type to construct
+	/// \tparam ArgsT the argument types
+	/// \param args the argument values
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	template<typename T, typename...ArgsT>
+	void emplace(ArgsT&&...args) {
+		reset();
+		_handle = new T(fennec::forward<ArgsT>(args)...);
+		_manage = _manage_impl<T>;
+	}
+
+	///
+	/// \brief reset value
+	/// \details clears the held value using the appropriate destructor
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	void reset() {
+		if (_manage) {
+			_handle = _manage(op_destroy, _handle);
+			_manage = nullptr;
+		}
+	}
+
+	///
+	/// \brief C++ 11 Swap Specification
+	/// \param gen the generic to swap with
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	void swap(generic& gen) noexcept {
+		fennec::swap(_handle, gen._handle);
+		fennec::swap(_manage, gen._manage);
+	}
+
+	/// @}
+
+
+// Casting =============================================================================================================
+public:
+
+	/// \name Casting
+	/// @{
+
+	///
+	/// \brief cast value
+	///
+	/// \details equivalent to \f$reinterpret_cast\f$
+	/// \tparam T The type to cast to
+	/// \returns The contents of generic after having cast to \f$T\f$
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	template<typename T, typename U = remove_cvref_t<T>>
+	T cast() {
+		return static_cast<T>(*static_cast<U*>(_handle));
+	}
+
+	///
+	/// \details equivalent to \f$reinterpret_cast\f$
+	/// \tparam T The type to cast to
+	/// \returns The contents of generic after having cast to \f$T\f$
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	template<typename T, typename U = remove_cvref_t<T>>
+	T cast() const {
+		return static_cast<T>(*static_cast<U*>(_handle));
+	}
+
+	/// @}
+
+
+// Private Member Variables ============================================================================================
+private:
+	void*     _handle;
+	manager_t _manage;
+
+
+// Private Helpers =====================================================================================================
+private:
+	template<typename T>
+	static void* _manage_impl(uint8_t op, void* hnd) {
+		static fennec::type t = type::get<T>();
+		T* ptr = hnd;
+
+		switch (op) {
+			case op_clone:
+				return new T(*ptr);
+			case op_destroy:
+				delete ptr;
+				return nullptr;
+			case op_type:
+				return &t;
+			default:
+				return nullptr;
+		}
+	}
+};
+
+}
+
+#endif // FENNEC_CONTAINERS_GENERIC_H

include/fennec/containers/graph.h

@@ -1,6 +1,6 @@
 // =====================================================================================================================
 //  fennec, a free and open source game engine
-//  Copyright © 2025  Medusa Slockbower
+//  Copyright © 2025 - 2026  Medusa Slockbower
 //
 //  This program is free software: you can redistribute it and/or modify
 //  it under the terms of the GNU General Public License as published by
@@ -17,14 +17,14 @@
 // =====================================================================================================================
 
 ///
-/// \file graph.h
+/// \file fennec/containers/graph.h
 /// \brief A header containing the definition for a graph of vertices connected by edges
 ///
 ///
 /// \details
 /// \author Medusa Slockbower
 ///
-/// \copyright Copyright © 2025 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
+/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
 ///
 ///
 
@@ -55,19 +55,20 @@ namespace fennec
 /// \brief Graph Data Structure, describes sets of arbitrarily connected vertices
 ///
 /// \details
-/// | Property   | Value      |
+/// | Property    | Value          |
-/// |:----------:|:----------:|
+/// |:-----------:|:--------------:|
-/// | stable     |      ⛔     |
+/// | stable      |       ⛔       |
-/// | dynamic    |      ✅     |
+/// | dynamic     |       ✅       |
-/// | homogenous |      ✅     |
+/// | homogeneous |       ✅       |
-/// | distinct   |      ⛔     |
+/// | distinct    |       ⛔       |
-/// | ordered    |      ⛔     |
+/// | ordered     |       ⛔       |
-/// | space      | \f$O(N)\f$ |
+/// | space       |   \f$O(N)\f$   |
-/// | linear     |      ✅     |
+/// | linear      |       ✅       |
-/// | access     | \f$O(1)\f$ |
+/// | access      |   \f$O(1)\f$   |
-/// | find       | \f$O(1)\f$ |
+/// | find        |   \f$O(1)\f$   |
-/// | insertion  | \f$O(1)\f$ |
+/// | insertion   |   \f$O(1)\f$   |
-/// | deletion   | \f$O(N)\f$ |
+/// | deletion    |   \f$O(M)\f$   |
+/// | space       | \f$O(N + M)\f$ |
 ///
 /// Graphs contain vertices and edges. Graphs are either directed
 /// or undirected. This structure allows the creation of both directed and undirected edges. As
@@ -79,11 +80,11 @@ namespace fennec
 /// A directed graph is weakly connected if replacing all of its directed edges with undirected edges would
 /// produce a connected graph. We will call this "disjointed"
 ///
-/// A directed graph is semi-connected if there is a directed path p for `u` → `v` *or* `v` → `u` for every
+/// A directed graph is semi-connected if there is a directed path p for \f$u\f$ → \f$v\f$ *or* \f$v\f$ → \f$u\f$ for every
-/// pair of vertices `u, v`. We will call this "unilateral"
+/// pair of vertices \f$[u, v]\f$. We will call this "unilateral"
 ///
-/// A directed graph is strongly-connected if there is a directed path p for `u` → `v` *and* `v` → `u` for every pair
+/// A directed graph is strongly-connected if there is a directed path p for \f$u\f$ → \f$v\f$ *and* \f$v\f$ → \f$u\f$ for every pair
-/// of vertices `u, v`. We will call this "connected"
+/// of vertices \f$[u, v]\f$. We will call this "connected"
 ///
 /// \tparam VertexT The type associated with each vertex
 /// \tparam EdgeT The type associated with each edge
@@ -92,13 +93,24 @@ struct graph {
 public:
 // Definitions =========================================================================================================
 
-	using edge_t        = EdgeT;                         ///< Alias for the edge type
+	/// \name Definitions
-	using vertex_t      = VertexT;                       ///< Alias for the vertex type
+	/// @{
-	using vertex_pool_t = object_pool<vertex_t>;         ///< Alias for a pool of vertices
-	using edge_map_t    = dynarray<map<size_t, size_t>>; ///< Alias for edge mapping
-	using edge_pool_t   = object_pool<edge_t>;           ///< Alias for a pool of edges
 
-	static constexpr size_t npos = -1; ///< Constant for a non-existent vertex
+	using edge_t        = EdgeT;                         //!< Alias for the edge type
+	using vertex_t      = VertexT;                       //!< Alias for the vertex type
+	using vertex_pool_t = object_pool<vertex_t>;         //!< Alias for a pool of vertices
+	using edge_map_t    = dynarray<map<size_t, size_t>>; //!< Alias for edge mapping
+	using edge_pool_t   = object_pool<edge_t>;           //!< Alias for a pool of edges
+
+	/// @}
+
+
+	/// \name Constants
+	/// @{
+
+	static constexpr size_t npos = -1; //!< Constant for a non-existent vertex
+
+	/// @}
 
 
 // Constructors ========================================================================================================
@@ -108,10 +120,18 @@ public:
 
 	///
 	/// \brief Default Constructor, initializes empty graph
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr graph() = default;
 
 	///
 	/// \brief Destructor
+	///
+	/// \par Complexity
+	/// \f$O(N + M)\f$
+	///
 	constexpr ~graph() = default;
 
 	/// @}
@@ -124,12 +144,20 @@ public:
 	/// \brief Copy Assignment Operator
 	/// \param g The graph to copy
 	/// \returns A reference to this after assigning g
+	///
+	/// \par Complexity
+	/// \f$O(N + M)\f$
+	///
 	constexpr graph& operator=(const graph& g) = default;
 
 	///
 	/// \brief Move Assignment Operator
 	/// \param g The graph to copy
 	/// \returns A reference to this after assigning g
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr graph& operator=(graph&& g) = default;
 
 	/// @}
@@ -142,55 +170,83 @@ public:
 
 	///
 	/// \returns The number of vertices in the graph
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr size_t num_vertices() const {
 		return _vertex_pool.size();
 	}
 
 	///
 	/// \returns The number of edges in the graph
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr size_t num_edges() const {
-		return _conn_pool.size();
+		return _edge_pool.size();
 	}
 
 	///
 	/// \returns The capacity of the vertex pool
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr size_t capacity() const {
 		return _vertex_pool.capacity();
 	}
 
 	///
-	/// \returns `true` when there are no vertices in the graph, `false` otherwise
+	/// \returns \f$true\f$ when there are no vertices in the graph, \f$false\f$ otherwise
-	constexpr bool empty() const {
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	constexpr bool is_empty() const {
 		return num_vertices() == 0;
 	}
 
 	///
-	/// \brief Checks if there exists an edge `e` that starts from `a` and ends at `b`
+	/// \brief Checks if there exists an edge \f$e\f$ that starts from \f$a\f$ and ends at \f$b\f$
 	/// \param a The first vertex
 	/// \param b The second vertex
-	/// \returns `true` if the edge exists, `false` otherwise
+	/// \returns \f$true\f$ if the edge exists, \f$false\f$ otherwise
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr bool exists(size_t a, size_t b) const {
-		return _conn_map[a][b] != nullptr;
+		return _edge_map[a][b] != nullptr;
 	}
 
 	///
-	/// \brief Checks if there exists an edge `e0` that starts from `a` and ends at `b` and `e1` that starts from `b`
+	/// \brief Checks if there exists an edge \f$e0\f$ that starts from \f$a\f$ and ends at \f$b\f$ and \f$e1\f$ that starts from \f$b\f$
-	///        and ends at `a`
+	///        and ends at \f$a\f$
 	/// \param a The first vertex
 	/// \param b The second vertex
-	/// \returns `true` if both edges exist, `false` otherwise
+	/// \returns \f$true\f$ if both edges exist, \f$false\f$ otherwise
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr bool is_symmetric(size_t a, size_t b) const {
 		return exists(a, b) and exists(b, a);
 	}
 
 	///
-	/// \brief Checks if there exists an edge `e` between `a` and `b`
+	/// \brief Checks if there exists an edge \f$e\f$ between \f$a\f$ and \f$b\f$
 	/// \param a The first vertex
 	/// \param b The second vertex
-	/// \returns `true` if both edges exist, `false` otherwise
+	/// \returns \f$true\f$ if both edges exist, \f$false\f$ otherwise
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr bool is_undirected(size_t a, size_t b) const {
-		const auto* e0 = _conn_map[a][b];
+		const auto* e0 = _edge_map[a][b];
-		const auto* e1 = _conn_map[b][a];
+		const auto* e1 = _edge_map[b][a];
 		if (not (e0 != nullptr && e1 != nullptr)) {
 			return false;
 		}
@@ -211,6 +267,10 @@ public:
 	/// \brief vertex Access Operator
 	/// \param vertex The id of the vertex
 	/// \returns A reference to the value stored in the vertex
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr vertex_t& operator[](size_t vertex) {
 		return _vertex_pool[vertex];
 	}
@@ -219,6 +279,10 @@ public:
 	/// \brief vertex Const Access Operator
 	/// \param vertex The id of the vertex
 	/// \returns A reference to the value stored in the vertex
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr const vertex_t& operator[](size_t vertex) const {
 		return _vertex_pool[vertex];
 	}
@@ -227,14 +291,18 @@ public:
 	/// \brief edge Access Operator
 	/// \param a The id of the first vertex
 	/// \param b The id of the second vertex
-	/// \returns A pointer to the value stored in the edge, `nullptr` if not found
+	/// \returns A pointer to the value stored in the edge, \f$nullptr\f$ if not found
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr edge_t* operator[](size_t a, size_t b) {
-		if (empty()) {
+		if (is_empty()) {
 			return nullptr;
 		}
-		edge_t* it = _conn_map[a][b];
+		edge_t* it = _edge_map[a][b];
 		if (it) {
-			return _conn_pool[*it];
+			return _edge_pool[*it];
 		}
 		return nullptr;
 	}
@@ -243,44 +311,56 @@ public:
 	/// \brief edge Const Access Operator
 	/// \param a The id of the first vertex
 	/// \param b The id of the second vertex
-	/// \returns A const-qualified pointer to the value stored in the edge, `nullptr` if not found
+	/// \returns A const-qualified pointer to the value stored in the edge, \f$nullptr\f$ if not found
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr const edge_t* operator[](size_t a, size_t b) const {
-		if (empty()) {
+		if (is_empty()) {
 			return nullptr;
 		}
-		const edge_t* it = _conn_map[a][b];
+		const edge_t* it = _edge_map[a][b];
 		if (it) {
-			return _conn_pool[*it];
+			return _edge_pool[*it];
 		}
 		return nullptr;
 	}
 
 	///
-	/// \brief Getter for a list of vertices `x` that `vertex` has an edge to `x...`
+	/// \brief Getter for a list of vertices \f$x\f$ that \f$vertex\f$ has an edge to \f$x\ldots\f$
 	/// \param vertex The id of the vertex
-	/// \returns A list containing all vertices `x` with edges from `vertex` to `x...`
+	/// \returns A list containing all vertices \f$x\f$ with edges from \f$vertex\f$ to \f$x\ldots\f$
+	///
+	/// \par Complexity
+	/// \f$O(M)\f$
+	///
 	list<size_t> outgoing(size_t vertex) {
 		list<size_t> res;
-		if (empty() || vertex >= _conn_map.size()) {
+		if (is_empty() || vertex >= _edge_map.size()) {
 			return res;
 		}
-		for (const auto& it : _conn_map[vertex]) {
+		for (const auto& it : _edge_map[vertex]) {
 			res.push_back(it.first);
 		}
 		return res;
 	}
 
 	///
-	/// \brief Getter for a list of vertices `x` that `vertex` has an edge from `x...`
+	/// \brief Getter for a list of vertices \f$x\f$ that \f$vertex\f$ has an edge from \f$x\ldots\f$
 	/// \param vertex The id of the vertex
-	/// \returns A list containing all vertices `x` with edges from `x...` to `vertex`
+	/// \returns A list containing all vertices \f$x\f$ with edges from \f$x\ldots\f$ to \f$vertex\f$
+	///
+	/// \par Complexity
+	/// \f$O(M)\f$
+	///
 	list<size_t> incoming(size_t vertex) {
 		list<size_t> res;
-		if (empty() || vertex >= _conn_map.size()) {
+		if (is_empty() || vertex >= _edge_map.size()) {
 			return res;
 		}
-		for (size_t n = 0; n < _conn_map.size(); ++n) {
+		for (size_t n = 0; n < _edge_map.size(); ++n) {
-			if (_conn_map[n][vertex]) {
+			if (_edge_map[n][vertex]) {
 				res.push_back(n);
 			}
 		}
@@ -288,16 +368,20 @@ public:
 	}
 
 	///
-	/// \brief Getter for a list of vertices `x` that `vertex` has an edge to and from `x...`
+	/// \brief Getter for a list of vertices \f$x\f$ that \f$vertex\f$ has an edge to and from \f$x\ldots\f$
 	/// \param vertex The id of the vertex
-	/// \returns A list containing all vertices `x` that have symmetric edges with `vertex`
+	/// \returns A list containing all vertices \f$x\f$ that have symmetric edges with \f$vertex\f$
+	///
+	/// \par Complexity
+	/// \f$O(M)\f$
+	///
 	list<size_t> symmetric(size_t vertex) {
 		list<size_t> res;
-		if (empty() || vertex >= _conn_map.size()) {
+		if (is_empty() || vertex >= _edge_map.size()) {
 			return res;
 		}
-		for (const auto& it : _conn_map[vertex]) {
+		for (const auto& it : _edge_map[vertex]) {
-			if (_conn_map[it.first][vertex]) {
+			if (_edge_map[it.first][vertex]) {
 				res.push_back(it.first);
 			}
 		}
@@ -305,20 +389,24 @@ public:
 	}
 
 	///
-	/// \brief Getter for a list of vertices `x` that `vertex` has an edge to and from `x...` and share the same value
+	/// \brief Getter for a list of vertices \f$x\f$ that \f$vertex\f$ has an edge to and from \f$x\ldots\f$ and share the same value
 	/// \details
 	/// "Joined" edges may also be referred to as "undirected." A joined, or undirected, edge may be
 	/// turned into a directed edge by changing the weight object associated with the edge, or by
 	/// removing one of the sub-edges.
 	/// \param vertex The id of the vertex
-	/// \returns A list containing all vertices `x` that have symmetric edges with `vertex`
+	/// \returns A list containing all vertices \f$x\f$ that have symmetric edges with \f$vertex\f$
+	///
+	/// \par Complexity
+	/// \f$O(M)\f$
+	///
 	list<size_t> undirected(size_t vertex) {
 		list<size_t> res;
-		if (empty() || vertex >= _conn_map.size()) {
+		if (is_empty() || vertex >= _edge_map.size()) {
 			return res;
 		}
-		for (const auto& it : _conn_map[vertex]) {
+		for (const auto& it : _edge_map[vertex]) {
-			const auto* at = _conn_map[it.first][vertex];
+			const auto* at = _edge_map[it.first][vertex];
 			if (at != nullptr && *at == it.second) {
 				res.push_back(it.first);
 			}
@@ -331,11 +419,15 @@ public:
 	///        Use this when you want to iterate over edges that start from this vertex.
 	/// \param vertex The id of the vertex
 	/// \returns A pointer to a map containing edges mapped from this vertex
+	///
+	/// \par Complexity
+	/// \f$O(M)\f$
+	///
 	const auto* edges(size_t vertex) {
-		if (empty() || vertex >= _conn_map.size()) {
+		if (is_empty() || vertex >= _edge_map.size()) {
 			return nullptr;
 		}
-		return &_conn_map[vertex];
+		return &_edge_map[vertex];
 	}
 
 	/// @}
@@ -350,6 +442,10 @@ public:
 	/// \brief Move a new vertex into the graph
 	/// \param vertex The vertex to move into the graph
 	/// \returns The id of the new vertex
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr size_t insert(vertex_t&& vertex) {
 		return this->_insert(fennec::forward<vertex_t>(vertex));
 	}
@@ -358,6 +454,10 @@ public:
 	/// \brief Copy a new vertex into the graph
 	/// \param vertex The vertex to copy into the graph
 	/// \returns The id of the new vertex
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr size_t insert(const vertex_t& vertex) {
 		return this->_insert(vertex);
 	}
@@ -367,6 +467,10 @@ public:
 	/// \tparam ArgsT The types of the arguments
 	/// \param args The arguments to construct the vertex with
 	/// \returns The id of the new vertex
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	template<typename...ArgsT>
 	constexpr size_t emplace(ArgsT&&...args) {
 		return this->_insert(fennec::forward<ArgsT>(args)...);
@@ -375,109 +479,133 @@ public:
 	///
 	/// \brief Erase a vertex from the graph
 	/// \param vertex The id of the vertex to erase
+	///
+	/// \par Complexity
+	/// \f$O(M)\f$
+	///
 	constexpr void erase(size_t vertex) {
 		cut(vertex);
 		_vertex_pool.erase(vertex);
 	}
 
 	///
-	/// \brief Form an edge from vertex `a` to vertex `b`
+	/// \brief Form an edge from vertex \f$a\f$ to vertex \f$b\f$
 	/// \tparam ArgsT The argument types
 	/// \param a The first vertex id
 	/// \param b The second vertex id
 	/// \param args The arguments to construct the edge with
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	template<typename...ArgsT>
 	constexpr void make_edge(size_t a, size_t b, ArgsT&&...args) {
 		if (a == b) {
 			return;
 		}
 
-		if (_conn_map.size() < _vertex_pool.capacity()) {
+		if (_edge_map.size() < _vertex_pool.capacity()) {
-			_conn_map.resize(_vertex_pool.capacity());
+			_edge_map.resize(_vertex_pool.capacity());
 		}
 
-		auto it = _conn_map[a][b];
+		auto it = _edge_map[a][b];
 		size_t conn;
 		if (it != nullptr) {
 			conn = *it;
-			_conn_pool[conn] = vertex_t(fennec::forward<ArgsT>(args)...);
+			_edge_pool[conn] = vertex_t(fennec::forward<ArgsT>(args)...);
 		} else {
-			conn = _conn_pool.emplace(fennec::forward<ArgsT>(args)...);
+			conn = _edge_pool.emplace(fennec::forward<ArgsT>(args)...);
 		}
-		_conn_map[a].emplace(b, conn);
+		_edge_map[a].emplace(b, conn);
 	}
 
 	///
-	/// \brief Form an undirected edge between vertex `a` and vertex `b`
+	/// \brief Form an undirected edge between vertex \f$a\f$ and vertex \f$b\f$
 	/// \tparam ArgsT The argument types
 	/// \param a The first vertex id
 	/// \param b The second vertex id
 	/// \param args The arguments to construct the edge with
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	template<typename...ArgsT>
 	constexpr void make_edge2(size_t a, size_t b, ArgsT&&...args) {
 		if (a == b) {
 			return;
 		}
 
-		if (_conn_map.size() < _vertex_pool.capacity()) {
+		if (_edge_map.size() < _vertex_pool.capacity()) {
-			_conn_map.resize(_vertex_pool.capacity());
+			_edge_map.resize(_vertex_pool.capacity());
 		}
 
-		auto it = _conn_map[a][b];
+		auto it = _edge_map[a][b];
 		size_t conn;
 		if (it != nullptr) {
 			conn = *it;
-			_conn_pool[conn] = vertex_t(fennec::forward<ArgsT>(args)...);
+			_edge_pool[conn] = vertex_t(fennec::forward<ArgsT>(args)...);
 		} else {
-			conn = _conn_pool.emplace(fennec::forward<ArgsT>(args)...);
+			conn = _edge_pool.emplace(fennec::forward<ArgsT>(args)...);
 		}
 
-		_conn_map[a].emplace(b, conn);
+		_edge_map[a].emplace(b, conn);
-		_conn_map[b].emplace(a, conn);
+		_edge_map[b].emplace(a, conn);
 	}
 
 	///
-	/// \brief Disconnect an edge from vertex `a` to vertex `b`
+	/// \brief Disconnect an edge from vertex \f$a\f$ to vertex \f$b\f$
 	/// \param a The first vertex id
 	/// \param b The second vertex id
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr void cut_edge(size_t a, size_t b) {
 
 		// Find the edge object
-		const auto* it = _conn_map[a][b];
+		const auto* it = _edge_map[a][b];
 		if (not it) {
 			return;
 		}
 		size_t    c = *it;
 
 		// Check if undirected
-		const auto* at = _conn_map[b][a];
+		const auto* at = _edge_map[b][a];
 		if (not at || *at != c) {
-			_conn_pool.erase(c);
+			_edge_pool.erase(c);
 		}
 
 		// Erase the edge mapping
-		_conn_map[a].erase(b);
+		_edge_map[a].erase(b);
 	}
 
 	///
-	/// \brief Disconnect both directed edges between vertices `a` and `b`
+	/// \brief Disconnect both directed edges between vertices \f$a\f$ and \f$b\f$
 	/// \param a The first vertex id
 	/// \param b The second vertex id
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr void cut_edge2(size_t a, size_t b) {
-		const auto* ita = _conn_map[a][b];
+		const auto* ita = _edge_map[a][b];
-		const auto* itb = _conn_map[a][b];
+		const auto* itb = _edge_map[a][b];
 		if (not (ita || itb)) {
 			return;
 		}
-		if (ita) _conn_pool.erase(*ita);
+		if (ita) _edge_pool.erase(*ita);
-		if (itb) _conn_pool.erase(*itb);
+		if (itb) _edge_pool.erase(*itb);
-		_conn_map[a].erase(b);
+		_edge_map[a].erase(b);
-		_conn_map[b].erase(a);
+		_edge_map[b].erase(a);
 	}
 
 	///
-	/// \brief Break *all* edges to and from `n`
+	/// \brief Break *all* edges connected to \f$n\f$
 	/// \param n The vertex id
+	///
+	/// \par Complexity
+	/// \f$O(M)\f$
+	///
 	void cut(size_t n) {
 		for (const auto it : outgoing(n)) {
 			cut_edge(n, it);
@@ -489,10 +617,14 @@ public:
 
 	///
 	/// \brief Clear the graph, destructing all vertices and edges.
+	///
+	/// \par Complexity
+	/// \f$O(N + M)\f$
+	///
 	void clear() {
 		_vertex_pool.clear();
-		_conn_pool.clear();
+		_edge_pool.clear();
-		_conn_map.clear();
+		_edge_map.clear();
 	}
 
 	/// @}
@@ -503,8 +635,8 @@ public:
 
 private:
 	vertex_pool_t _vertex_pool;
-	edge_pool_t _conn_pool;
+	edge_pool_t   _edge_pool;
-	edge_map_t  _conn_map;
+	edge_map_t    _edge_map;
 
 	template<typename...ArgsT>
 	size_t _insert(ArgsT&&...args) {

include/fennec/containers/initializer_list.h

@@ -0,0 +1,63 @@
+// =====================================================================================================================
+//  fennec, a free and open source game engine
+//  Copyright © 2025 - 2026  Medusa Slockbower
+//
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+// =====================================================================================================================
+
+///
+/// \file fennec/containers/initializer_list.h
+/// \brief
+///
+///
+/// \details
+/// \author Medusa Slockbower
+///
+/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
+///
+///
+
+#ifndef FENNEC_CONTAINERS_INITIALIZER_LIST_H
+#define FENNEC_CONTAINERS_INITIALIZER_LIST_H
+
+// Since initializer lists are completely intertwined with the compiler, and this is part of the c++ standard
+// (specifically standard, and not the standard template library) we need to use std::initializer_list.
+// We can at least alias it for proper naming conventions.
+
+#include <initializer_list>
+
+namespace fennec
+{
+
+using std::initializer_list;
+
+///
+/// \param inls the initializer list
+/// \returns A const qualified pointer to the first element in \f$inls\f$
+template<typename T>
+constexpr const T* begin(initializer_list<T> inls) noexcept {
+	return inls.begin();
+}
+
+///
+/// \param inls the initializer list
+/// \returns A const qualified pointer to one past the last element in \f$inls\f$
+template<typename T>
+constexpr const T* end(initializer_list<T> inls) noexcept {
+	return inls.end();
+}
+
+}
+
+#endif // FENNEC_CONTAINERS_INITIALIZER_LIST_H

include/fennec/containers/list.h

@@ -1,6 +1,6 @@
 // =====================================================================================================================
 //  fennec, a free and open source game engine
-//  Copyright © 2025  Medusa Slockbower
+//  Copyright © 2025 - 2026  Medusa Slockbower
 //
 //  This program is free software: you can redistribute it and/or modify
 //  it under the terms of the GNU General Public License as published by
@@ -17,14 +17,14 @@
 // =====================================================================================================================
 
 ///
-/// \file list.h
+/// \file fennec/containers/list.h
 /// \brief A header containing the definition for a linked list of values
 ///
 ///
 /// \details
 /// \author Medusa Slockbower
 ///
-/// \copyright Copyright © 2025 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
+/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
 ///
 ///
 
@@ -48,55 +48,77 @@ namespace fennec
 /// This data-structure behaves like a linked list, but does not use pointers. Instead, it is in-array. This creates the
 /// following properties:
 ///
-/// | Property   | Value      |
+/// | Property    | Value      |
-/// |:----------:|:----------:|
+/// |:-----------:|:----------:|
-/// | stable     |      ⛔     |
+/// | stable      |     ⛔     |
-/// | dynamic    |      ✅     |
+/// | dynamic     |     ✅     |
-/// | homogenous |      ✅     |
+/// | homogeneous |     ✅     |
-/// | distinct   |      ⛔     |
+/// | distinct    |     ⛔     |
-/// | ordered    |      ⛔     |
+/// | ordered     |     ⛔     |
-/// | space      | \f$O(N)\f$ |
+/// | space       | \f$O(N)\f$ |
-/// | linear     |      ✅     |
+/// | linear      |     ✅     |
-/// | access     | \f$O(1)\f$ |
+/// | access      | \f$O(N)\f$ |
-/// | find       | \f$O(N)\f$ |
+/// | find        | \f$O(N)\f$ |
-/// | insertion  | \f$O(N)\f$ |
+/// | insertion   | \f$O(N)\f$ |
-/// | deletion   | \f$O(N)\f$ |
+/// | deletion    | \f$O(N)\f$ |
+/// | space       | \f$O(N)\f$ |
+///
+/// \note Access, Insertion, and Deletion are \f$O(N)\f$ using the index pattern,
+///       using the iterator pattern yields \f$O(1)\f$ runtime.
 ///
 /// \tparam TypeT value type
 template<class TypeT, class Alloc = allocator<TypeT>>
 struct list {
 
 // Definitions =========================================================================================================
-
 private:
 	struct node;
 
 public:
+
+	/// \name Definitions
+	/// @{
+
 	/// \brief Alias for the allocator type, rebound to list nodes
 	using alloc_t = typename allocator_traits<Alloc>::template rebind<node>;
 
-	using value_t = TypeT; ///< Alias for the value type
+	using value_t = TypeT; //!< Alias for the value type
 
-	static constexpr size_t npos = -1; ///< Constant representing a non-existant position
+	static constexpr size_t npos = -1; //!< Constant representing a non-existant position
 
-	class iterator; ///< Iterator type for forward iteration over the list
+	/// @}
-	class const_iterator; ///< Iterator type for forward iteration over a constant list
+
+	class iterator;
+	class const_iterator;
+
+private:
+	using table_t = dynarray<node, alloc_t>;
+	using freed_t = dynarray<size_t>;
 
 
 // Constructors & Destructor ===========================================================================================
+public:
 
 	/// \name Constructors & Destructor
 	/// @{
 
 	///
 	/// \brief Default Constructor, initializes an empty list.
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr list()
 		: _table(), _freed(), _root(npos), _last(npos), _size(0) {
 	}
 
 	///
-	/// \brief Copy Constructor, copies all elements in `l` with optimized layout
+	/// \brief Copy Constructor, copies all elements in \f$l\f$ with optimized layout
 	/// \param l The list to copy
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
+	///
 	constexpr list(const list& l)
 		: list() {
 		for (const value_t& it : l) {
@@ -108,6 +130,10 @@ public:
 	///
 	/// \brief Move Constructor, takes ownership of the list
 	/// \param l The list to move
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr list(list&& l) noexcept
 		: _table(fennec::move(l._table))
 		, _freed(fennec::move(l._freed))
@@ -118,66 +144,99 @@ public:
 
 	///
 	/// \brief Destructor, destructs all elements then releases the allocation.
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
+	///
 	constexpr ~list() {
-		for (size_t i = 0; i < capacity(); ++i) {
+		clear();
-			_table[i].value = nullopt;
-		}
 	}
 
 	/// @}
 
 // Assignment ==========================================================================================================
+public:
 
-	/// \name Assignment
+	/// \name Assignment Operators
 	/// @{
 
 	///
 	/// \brief Copy Assignment Operator
 	/// \param l the list to copy
-	/// \returns `this` after having copied all elements of `l`
+	/// \returns \f$this\f$ after having copied all elements of \f$l\f$
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
+	///
 	constexpr list& operator=(const list& l) {
 		this->clear();
 		for (const value_t& it : l) {
 			this->push_back(it);
 		}
+		return *this;
 	}
 
 	///
 	/// \brief Move Assignment Operator
 	/// \param l the list to copy
-	/// \returns `this` after having taken ownership over the contents of `l`
+	/// \returns \f$this\f$ after having taken ownership over the contents of \f$l\f$
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr list& operator=(list&& l) noexcept {
 		this->clear();
 		_table = fennec::move(l._table);
 		_freed = fennec::move(l._freed);
 		_root  = l._root; _last = l._last;
 		_size  = l._size;
+		return *this;
 	}
 
 	/// @}
 
 
 // Properties ==========================================================================================================
+public:
 
 	/// \name Properties
 	/// @{
 
 	///
 	/// \returns The size of the list in elements.
-	constexpr size_t size() const { return _size; }
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	constexpr size_t size() const {
+		return _size;
+	}
 
 	///
 	/// \returns The capacity of the list in elements.
-	constexpr size_t capacity() const { return _table.capacity(); }
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	constexpr size_t capacity() const {
+		return _table.size();
+	}
 
 	///
-	/// \returns `true` when the list is empty, `false` otherwise.
+	/// \returns \f$true\f$ when the list is empty, \f$false\f$ otherwise.
-	constexpr bool empty() const { return _root == npos; }
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	constexpr bool is_empty() const {
+		return _root == npos;
+	}
 
 	/// @}
 
 
 // Access ==============================================================================================================
+public:
 
 	/// \name Access
 	/// @{
@@ -185,9 +244,11 @@ public:
 	///
 	/// \brief Array Access Operator
 	/// \param i Index to access
-	/// \returns A reference to the element at `i`
+	/// \returns A reference to the element at \f$i\f$
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
 	///
-	/// \details \f$O(N)\f$
 	constexpr value_t& operator[](int i) {
 		assertd(i >= 0 && size_t(i) < _size, "Index out of Bounds");
 		size_t n = _walk(i);
@@ -198,9 +259,11 @@ public:
 	///
 	/// \brief Const Array Access Operator
 	/// \param i Index to access
-	/// \returns A const-qualified reference to the element at `i`
+	/// \returns A const-qualified reference to the element at \f$i\f$
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
 	///
-	/// \details \f$O(N)\f$
 	constexpr const value_t& operator[](int i) const {
 		assertd(i >= 0 && size_t(i) < _size, "Index out of Bounds");
 		size_t n = _walk(i);
@@ -211,6 +274,10 @@ public:
 	///
 	/// \brief Access Front Element
 	/// \returns A reference to the first element in the list
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr value_t& front() {
 		return *_table[_root].value;
 	}
@@ -218,6 +285,10 @@ public:
 	///
 	/// \brief Const Access Front Element
 	/// \returns A const-qualified reference to the first element in the list
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr const value_t& front() const {
 		return *_table[_root].value;
 	}
@@ -225,6 +296,10 @@ public:
 	///
 	/// \brief Access Back Element
 	/// \returns A reference to the last element in the list
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr value_t& back() {
 		return *_table[_last].value;
 	}
@@ -232,6 +307,10 @@ public:
 	///
 	/// \brief Const Access Back Element
 	/// \returns A const-qualified reference to the last element in the list
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr const value_t& back() const {
 		return *_table[_last].value;
 	}
@@ -240,6 +319,7 @@ public:
 
 
 // Modifiers ===========================================================================================================
+public:
 
 	/// \name Modifiers
 	/// @{
@@ -248,9 +328,12 @@ public:
 	/// \brief Copy Insertion
 	/// \param it Location to insert at
 	/// \param x value to copy
+	/// \returns The id of the inserted node
 	///
-	/// \details \f$O(1)\f$
+	/// \par Complexity
-	constexpr size_t insert(const iterator& it, const value_t& x) {
+	/// \f$O(1)\f$
+	///
+	constexpr iterator insert(const iterator& it, const value_t& x) {
 		return this->_insert(it._n, x);
 	}
 
@@ -258,9 +341,12 @@ public:
 	/// \brief Move Insertion
 	/// \param it Location to insert at
 	/// \param x value to move
+	/// \returns The id of the inserted node
 	///
-	/// \details \f$O(1)\f$
+	/// \par Complexity
-	constexpr size_t insert(const iterator& it, value_t&& x) {
+	/// \f$O(1)\f$
+	///
+	constexpr iterator insert(const iterator& it, value_t&& x) {
 		return this->_insert(it._n, fennec::forward<value_t>(x));
 	}
 
@@ -268,9 +354,12 @@ public:
 	/// \brief Copy Insertion
 	/// \param i Index to insert at
 	/// \param x value to copy
+	/// \returns The id of the inserted node
 	///
-	/// \details \f$O(N)\f$
+	/// \par Complexity
-	constexpr size_t insert(size_t i, const value_t& x) {
+	/// \f$O(N)\f$
+	///
+	constexpr iterator insert(size_t i, const value_t& x) {
 		assert(i <= size(), "Index out of Bounds");
 
 		size_t n = _walk(min(i, size_t(size() - 1)));
@@ -281,9 +370,12 @@ public:
 	/// \brief Move Insertion
 	/// \param i Index to insert at
 	/// \param x value to move
+	/// \returns The id of the inserted node
 	///
-	/// \details \f$O(N)\f$
+	/// \par Complexity
-	constexpr size_t insert(size_t i, value_t&& x) {
+	/// \f$O(N)\f$
+	///
+	constexpr iterator insert(size_t i, value_t&& x) {
 		assert(i <= size(), "Index out of Bounds");
 
 		size_t n = _walk(min(i, size_t(size() - 1)));
@@ -295,27 +387,55 @@ public:
 	/// \tparam ArgsT Argument types
 	/// \param i Index to insert at
 	/// \param args Arguments to construct with
+	/// \returns The id of the inserted node
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
 	///
-	/// \details \f$O(N)\f$
 	template<typename...ArgsT>
-	constexpr size_t emplace(size_t i, ArgsT&&...args) {
+	constexpr iterator emplace(size_t i, ArgsT&&...args) {
 		assert(i <= size(), "Index out of Bounds");
 
 		size_t n = _walk(min(i, size_t(size() - 1)));
 		return this->_insert(n, fennec::forward<ArgsT>(args)...);
 	}
 
+	///
+	/// \brief Emplace Insertion
+	/// \tparam ArgsT Argument types
+	/// \param it Location to insert at
+	/// \param args Arguments to construct with
+	/// \returns The id of the inserted node
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	template<typename...ArgsT>
+	constexpr iterator emplace(const iterator& it, ArgsT&&...args) {
+		return this->_insert(it._n, fennec::forward<ArgsT>(args)...);
+	}
+
 	///
 	/// \brief Push Front Copy
 	/// \param x Value to copy
-	constexpr size_t push_front(const value_t& x) {
+	/// \returns The id of the inserted node
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	constexpr iterator push_front(const value_t& x) {
 		return this->_insert(_root, x);
 	}
 
 	///
 	/// \brief Push Front Move
 	/// \param x Value to move
-	constexpr size_t push_front(value_t&& x) {
+	/// \returns The id of the inserted node
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	constexpr iterator push_front(value_t&& x) {
 		return this->_insert(_root, fennec::forward<value_t>(x));
 	}
 
@@ -323,22 +443,37 @@ public:
 	/// \brief Emplace Front
 	/// \param args Arguments to construct with
 	/// \tparam  ArgsT Argument types
+	/// \returns The id of the inserted node
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	template<typename...ArgsT>
-	constexpr size_t emplace_front(ArgsT&&...args) {
+	constexpr iterator emplace_front(ArgsT&&...args) {
 		return this->_insert(_root, fennec::forward<ArgsT>(args)...);
 	}
 
 	///
 	/// \brief Push Back Copy
 	/// \param x Value to copy
-	constexpr size_t push_back(const value_t& x) {
+	/// \returns The id of the inserted node
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	constexpr iterator push_back(const value_t& x) {
 		return this->_insert(npos, x);
 	}
 
 	///
 	/// \brief Push Back Move
 	/// \param x Value to move
-	constexpr size_t push_back(value_t&& x) {
+	/// \returns The id of the inserted node
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	constexpr iterator push_back(value_t&& x) {
 		return this->_insert(npos, fennec::forward<value_t>(x));
 	}
 
@@ -346,14 +481,23 @@ public:
 	/// \brief Emplace Back
 	/// \param args Arguments to construct with
 	/// \tparam  ArgsT Argument types
+	/// \returns The id of the inserted node
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	template<typename...ArgsT>
-	constexpr size_t emplace_back(ArgsT&&...args) {
+	constexpr iterator emplace_back(ArgsT&&...args) {
 		return this->_insert(npos, fennec::forward<ArgsT>(args)...);
 	}
 
 	///
 	/// \brief Erase Element
 	/// \param i Index to erase
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
+	///
 	constexpr void erase(size_t i) {
 		assert(i < size(), "Index out of Bounds!");
 		size_t n = _walk(i);
@@ -363,105 +507,156 @@ public:
 	///
 	/// \brief Erase Element
 	/// \param it Location to Erase
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr void erase(const iterator& it) {
-		_erase(it._n);
+		this->_erase(it._n);
 	}
 
 	///
 	/// \brief Pop Front, erases first element
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr void pop_front() {
 		_erase(_root);
 	}
 
 	///
 	/// \brief Pop Back, erases first element
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr void pop_back() {
 		_erase(_last);
 	}
 
 	///
 	/// \brief Clears the list, destructing all elements in order
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
+	///
 	constexpr void clear() {
 		size_t i = _root;
 		while (i != npos) {
-			fennec::destruct(_table[i]);
+			_table[i].value = nullopt;
 			i = this->_next(i);
 		}
-		_table.deallocate(_table);
+		_table.clear();
+		_root = npos;
+		_size = 0;
 	}
 
 	/// @}
 
-// ITERATOR ============================================================================================================
+// Iterator ============================================================================================================
+public:
 
 	/// \name Iteration
 	/// @{
 
 	///
-	/// \brief C++ Iterator Specification `begin()`
 	/// \returns An iterator for the first element in the list
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr iterator begin() {
 		return iterator(this, _root);
 	}
 
 	///
-	/// \brief C++ Iterator Specification `end()`
+	/// \brief C++ Iterator Specification \f$begin()\f$
-	/// \returns An iterator for the end of the list
-	constexpr iterator end() {
-		return iterator(this, npos);
-	}
-
-	///
-	/// \brief Const C++ Iterator Specification `begin()`
 	/// \returns A const iterator for the first element in the list
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr const_iterator begin() const {
 		return const_iterator(this, _root);
 	}
 
 	///
-	/// \brief Const C++ Iterator Specification `end()`
+	/// \returns An iterator for the end of the list
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	constexpr iterator end() {
+		return iterator(this, npos);
+	}
+
+	///
+	/// \brief Const C++ Iterator Specification \f$end()\f$
 	/// \returns A const iterator for the end of the list
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr const_iterator end() const {
 		return const_iterator(this, npos);
 	}
 
-	/// @}
-
 	///
-	/// \brief Iterator Class
+	/// \brief C++ Iterator Specification \f$iterator\f$
 	class iterator {
 	public:
+		///
+		/// \brief destructor
 		~iterator() {
 			_list = nullptr;
 		}
 
-		// prefix operator
+		///
+		/// \brief prefix increment operator
+		/// \param rhs the iterator to increment
+		/// \returns \f$rhs\f$ after having moved to the next element in the list
 		constexpr friend iterator& operator++(iterator& rhs) {
-			if (rhs._list->_next(rhs._n) < rhs._list->capacity()) {
+			rhs._n = rhs._list->_next(rhs._n);
-				return rhs;
-			}
-			rhs._n = npos;
 			return rhs;
 		}
 
+		///
+		/// \brief postfix increment operator
+		/// \param lhs the iterator to increment
+		/// \returns \f$lhs\f$ before having moved to the next element in the list
 		constexpr friend iterator operator++(iterator& lhs, int) {
 			iterator prev = lhs;
 			++lhs;
 			return prev;
 		}
 
+		///
+		/// \brief dereference operator
+		/// \returns a reference to the value pointed by the iterator
 		constexpr value_t& operator*() {
 			return *(_list->_table[_n].value);
 		}
 
+		///
+		/// \brief pointer access operator
+		/// \returns a pointer to the value pointed by the iterator
 		constexpr value_t* operator->() {
 			return &*(_list->_table[_n].value);
 		}
 
+		///
+		/// \brief iterator equality operator
+		/// \param it the iterator to compare with
+		/// \returns \f$true\f$ if the iterators are identical, \f$false\f$ otherwise
 		constexpr bool operator==(const iterator& it) {
 			return _list == it._list and _n == it._n;
 		}
 
+		///
+		/// \brief iterator inequality operator
+		/// \param it the iterator to compare with
+		/// \returns \f$true\f$ if the iterators are different, \f$false\f$ otherwise
 		constexpr bool operator!=(const iterator& it) {
 			return _list != it._list or _n != it._n;
 		}
@@ -481,11 +676,16 @@ public:
 	/// \brief Iterator Class for Const Access
 	class const_iterator {
 	public:
+		///
+		/// \brief destructor
 		~const_iterator() {
 			_list = nullptr;
 		}
 
-		// prefix operator
+		///
+		/// \brief prefix increment operator
+		/// \param rhs the iterator to increment
+		/// \returns \f$rhs\f$ after having moved to the next element in the list
 		constexpr friend const_iterator& operator++(const_iterator& rhs) {
 			if (rhs._list->_next(rhs._n) < rhs._list->capacity()) {
 				return rhs;
@@ -494,24 +694,42 @@ public:
 			return rhs;
 		}
 
+		///
+		/// \brief postfix increment operator
+		/// \param lhs the iterator to increment
+		/// \returns \f$lhs\f$ before having moved to the next element in the list
 		constexpr friend const_iterator operator++(const_iterator& lhs, int) {
 			const_iterator prev = lhs;
 			++lhs;
 			return prev;
 		}
 
+		///
+		/// \brief dereference operator
+		/// \returns a reference to the value pointed by the iterator
 		constexpr const value_t& operator*() {
 			return *(_list->_table[_n].value);
 		}
 
+		///
+		/// \brief pointer access operator
+		/// \returns a pointer to the value pointed by the iterator
 		constexpr const value_t* operator->() {
 			return &*(_list->_table[_n].value);
 		}
 
+		///
+		/// \brief iterator equality operator
+		/// \param it the iterator to compare with
+		/// \returns \f$true\f$ if the iterators are identical, \f$false\f$ otherwise
 		constexpr bool operator==(const const_iterator& it) {
 			return _list == it._list and _n == it._n;
 		}
 
+		///
+		/// \brief iterator inequality operator
+		/// \param it the iterator to compare with
+		/// \returns \f$true\f$ if the iterators are different, \f$false\f$ otherwise
 		constexpr bool operator!=(const const_iterator& it) {
 			return _list != it._list or _n != it._n;
 		}
@@ -527,15 +745,21 @@ public:
 		}
 	};
 
+	/// @}
+
+// Private Member Variables ============================================================================================
 private:
-	allocation<node, alloc_t> _table;
+	table_t _table;
-	dynarray<size_t> _freed;
+	freed_t _freed;
 	size_t _root, _last, _size;
 
 	friend class iterator;
 
+
+// Private Helpers =====================================================================================================
+private:
 	constexpr void _expand() {
-		_table.creallocate(fennec::max(_table.capacity(), size_t(1)) * 2);
+		_table.resize(fennec::max(_table.size(), size_t(4)) * 2);
 	}
 
 	struct node {
@@ -548,18 +772,6 @@ private:
 			, next(npos) {
 		}
 
-		constexpr node(size_t p, size_t n)
-			: value()
-			, prev(p)
-			, next(n) {
-		}
-
-		constexpr node(size_t p, size_t n, value_t&& val)
-			: value(fennec::forward<value_t>(val))
-			, prev(p)
-			, next(n) {
-		}
-
 		constexpr ~node() = default;
 
 		constexpr void clear() {
@@ -587,7 +799,7 @@ private:
 	}
 
 	constexpr size_t _next_free() {
-		if (not _freed.empty()) {
+		if (not _freed.is_empty()) {
 			size_t n = _freed.back();
 			_freed.pop_back();
 			return n;
@@ -596,20 +808,20 @@ private:
 	}
 
 	template<typename...ArgsT>
-	constexpr size_t _insert(size_t n, ArgsT&&...args) {
+	constexpr iterator _insert(size_t n, ArgsT&&...args) {
 		if (size() == capacity()) {
 			_expand();
 		}
 
 		size_t i = _next_free();
 		++_size;
-		fennec::construct(&_table[i].value, fennec::forward<ArgsT>(args)...);
+		_table[i].value.emplace(fennec::forward<ArgsT>(args)...);
 
 		if (_root == npos) {
 			_table[i].prev = npos;
 			_table[i].next = npos;
 			_root = _last = i;
-			return i;
+			return iterator(this, i);
 		}
 
 		if (n == npos) {
@@ -617,20 +829,20 @@ private:
 			_table[i].prev = _last;
 			_table[i].next = npos;
 			_last = i;
-			return i;
+			return iterator(this, i);
 		}
 
 		_table[i].prev = _prev(n);
 		_table[i].next = n;
 		_table[n].prev = i;
 		_root = n == _root ? i : _root;
-		return i;
+		return iterator(this, i);
 	}
 
 	constexpr void _erase(size_t n) {
 		if (n == npos) return;
 
-		fennec::destruct(&_table[n].value);
+		_table[n].value = nullopt;
 		_freed.push_back(n);
 		--_size;
 

include/fennec/containers/map.h

@@ -1,6 +1,6 @@
 // =====================================================================================================================
 //  fennec, a free and open source game engine
-//  Copyright © 2025  Medusa Slockbower
+//  Copyright © 2025 - 2026  Medusa Slockbower
 //
 //  This program is free software: you can redistribute it and/or modify
 //  it under the terms of the GNU General Public License as published by
@@ -17,14 +17,14 @@
 // =====================================================================================================================
 
 ///
-/// \file map.h
+/// \file fennec/containers/map.h
 /// \brief A header containing the definition for a mapping of keys to values
 ///
 ///
 /// \details
 /// \author Medusa Slockbower
 ///
-/// \copyright Copyright © 2025 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
+/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
 ///
 ///
 
@@ -56,21 +56,24 @@ namespace fennec
 */
 
 ///
-/// \brief Data Structure defining a mapping of `key` \f$KeyT\f$ to `value` \f$ValueT\f$
+/// \brief Data Structure defining a mapping of \f$key\f$ \f$KeyT\f$ to \f$value\f$ \f$ValueT\f$
 /// \details
-/// | Property   | Value      |
+/// | Property    | Value      |
-/// |:----------:|:----------:|
+/// |:-----------:|:----------:|
-/// | stable     |      ⛔     |
+/// | stable      |     ⛔     |
-/// | dynamic    |      ✅     |
+/// | dynamic     |     ✅     |
-/// | homogenous |      ✅     |
+/// | homogeneous |     ✅     |
-/// | distinct   |      ✅     |
+/// | distinct    |     ✅     |
-/// | ordered    |      ⛔     |
+/// | ordered     |     ⛔     |
-/// | space      | \f$O(N)\f$ |
+/// | space       | \f$O(N)\f$ |
-/// | linear     |      ✅     |
+/// | linear      |     ⛔     |
-/// | access     | \f$O(1)\f$ |
+/// | access      | \f$O(1)\f$ |
-/// | find       | \f$O(1)\f$ |
+/// | find        | \f$O(1)\f$ |
-/// | insertion  | \f$O(1)\f$ |
+/// | insertion   | \f$O(1)\f$ |
-/// | deletion   | \f$O(1)\f$ |
+/// | deletion    | \f$O(1)\f$ |
+/// | space       | \f$O(N)\f$ |
+///
+/// \note These runtimes are amortized, in theory the worst case is \f$O(N)\f$, but that is highly improbable.
 ///
 /// \tparam KeyT The Key Type
 /// \tparam ValueT The Value Type
@@ -81,32 +84,50 @@ struct map {
 
 // Definitions =========================================================================================================
 public:
-	struct key_hash; ///< Hash for node keys
-	struct key_equals; ///< Comparison for node keys
-	using key_t = KeyT; ///< The key type
-	using value_t = ValueT; ///< The value type
-	using elem_t = pair<KeyT, ValueT>; ///< then node type
-	using alloc_t = typename allocator_traits<Alloc>::template rebind<elem_t>; ///< Rebinds the allocator type to nodes
-	using hash_t = Hash; ///< The hash type
-	using set_t = set<elem_t, key_hash, key_equals, alloc_t>; ///< The underlying set
-	using iterator = set_t::iterator; ///< Iterator type
 
-	// We only want to hash the key
+	/// \name Definitions
+	/// @{
+
+	struct key_hash;                                                           //!< Hash for node keys
+	struct key_equals;                                                         //!< Comparison for node keys
+	using key_t = KeyT;                                                        //!< The key type
+	using value_t = ValueT;                                                    //!< The value type
+	using elem_t = pair<KeyT, ValueT>;                                         //!< then node type
+	using alloc_t = typename allocator_traits<Alloc>::template rebind<elem_t>; //!< Rebinds the allocator type to nodes
+	using hash_t = Hash;                                                       //!< The hash type
+	using set_t = set<elem_t, key_hash, key_equals, alloc_t>;                  //!< The underlying set
+	using iterator = set_t::iterator;                                          //!< Iterator type
+
+	///
+	/// \brief key hash helper
 	struct key_hash : hash_t {
+		///
+		/// \brief C++ 11 Hash Specification \f$operator()\f$
+		/// \param p the pair to hash
+		/// \returns the hash of the key
 		constexpr size_t operator()(const elem_t& p) const {
 			return hash_t::operator()(p.first);
 		}
 	};
 
-	// We only want to compare the keys
+	///
+	/// \brief key comparison helper
 	struct key_equals : equality<KeyT> {
+		///
+		/// \brief C++ 11 Compare Specification \f$operator()\f$
+		/// \param a the first pair
+		/// \param b the second pair
+		/// \returns \f$true\f$ if the keys are equal, \f$false\f$ otherwise
 		constexpr bool operator()(const elem_t& a, const elem_t& b) const {
 			return equality<KeyT>::operator()(a.first, b.first);
 		}
 	};
 
+	/// @}
+
 
 // Constructors & Destructor ===========================================================================================
+public:
 
 	/// \name Constructors & Destructor
 	/// @{
@@ -123,6 +144,7 @@ public:
 
 
 // Properties ==========================================================================================================
+public:
 
 	/// \name Properties
 	/// @{
@@ -134,8 +156,8 @@ public:
 	}
 
 	///
-	/// \returns `true` when there are no elements in the set, `false` otherwise
+	/// \returns \f$true\f$ when there are no elements in the set, \f$false\f$ otherwise
-	constexpr size_t empty() const {
+	constexpr size_t is_empty() const {
 		return _set.size();
 	}
 
@@ -149,6 +171,7 @@ public:
 
 
 // Access ==============================================================================================================
+public:
 
 	/// \name Access
 	/// @{
@@ -156,7 +179,11 @@ public:
 	///
 	/// \brief Key Access Operator
 	/// \param key Key value to access
-	/// \returns A pointer to the value associated with `key`, `nullptr` if `key` is not present.
+	/// \returns A pointer to the value associated with \f$key\f$, \f$nullptr\f$ if \f$key\f$ is not present.
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr value_t* operator[](const KeyT& key) {
 		auto it = _set.at(this->_find(key));
 		return it ? &it->second : nullptr;
@@ -165,7 +192,11 @@ public:
 	///
 	/// \brief Key Const Access Operator
 	/// \param key Key value to access
-	/// \returns A const-qualified pointer to the value associated with `key`, `nullptr` if `key` is not present.
+	/// \returns A const-qualified pointer to the value associated with \f$key\f$, \f$nullptr\f$ if \f$key\f$ is not present.
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr const value_t* operator[](const KeyT& key) const {
 		auto it = _set.at(this->_find(key));
 		return it ? &it->second : nullptr;
@@ -173,9 +204,13 @@ public:
 
 	///
 	/// \brief Argument Key Access Operator
-	/// \tparam ArgT Argument Type
+	/// \tparam ArgsT Argument Types
-	/// \param arg Argument to construct the key with
+	/// \param args Arguments to construct the key with
-	/// \returns A pointer to the value associated with `key`, `nullptr` if `key` is not present.
+	/// \returns A pointer to the value associated with \f$key\f$, \f$nullptr\f$ if \f$key\f$ is not present.
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	template<typename...ArgsT>
 	constexpr value_t* operator[](ArgsT&&...args) {
 		auto it = _set.at(this->_find(fennec::forward<ArgsT>(args)...));
@@ -186,7 +221,11 @@ public:
 	/// \brief Argument Key Const Access Operator
 	/// \tparam ArgsT Argument Type
 	/// \param args Argument to construct the key with
-	/// \returns A const-qualified pointer to the value associated with `key`, `nullptr` if `key` is not present.
+	/// \returns A const-qualified pointer to the value associated with \f$key\f$, \f$nullptr\f$ if \f$key\f$ is not present.
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	template<typename...ArgsT>
 	constexpr const value_t* operator[](ArgsT&&...args) const {
 		auto it = _set.at(this->_find(fennec::forward<ArgsT>(args)...));
@@ -197,6 +236,7 @@ public:
 
 
 // Modifiers ===========================================================================================================
+public:
 
 	/// \name Modifiers
 	/// @{
@@ -204,13 +244,22 @@ public:
 	///
 	/// \brief Key-Value Insertion
 	/// \param pair a pair containing the key and its value
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr void insert(elem_t&& pair) {
 		this->_insert(fennec::forward<elem_t>(pair));
 	}
 
 	///
 	/// \brief Key-Value Insertion
+	/// \param key key to insert
 	/// \param args Arguments for constructing the key-value pair
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	template<typename...ArgsT>
 	constexpr void emplace(const KeyT& key, ArgsT&&...args) {
 		this->_insert(key, fennec::forward<ArgsT>(args)...);
@@ -219,6 +268,10 @@ public:
 	///
 	/// \brief Key-Value Insertion
 	/// \param args Arguments for constructing the key-value pair
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	template<typename...ArgsT>
 	constexpr void emplace(ArgsT&&...args) {
 		this->_insert(fennec::forward<ArgsT>(args)...);
@@ -227,6 +280,10 @@ public:
 	///
 	/// \brief Erase a key
 	/// \param key key to erase
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr void erase(KeyT&& key) {
 		_set.erase(this->_find(fennec::forward<KeyT>(key)));
 	}
@@ -234,6 +291,10 @@ public:
 	///
 	/// \brief Erase a key
 	/// \param key key to erase
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr void erase(const KeyT& key) {
 		_set.erase(this->_find(key));
 	}
@@ -242,6 +303,10 @@ public:
 	/// \brief Argument Erase
 	/// \tparam ArgsT Argument Types
 	/// \param args Arguments to construct a key to erase
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	template<typename...ArgsT>
 	constexpr void erase(ArgsT&&...args) {
 		_set.erase(this->_find(fennec::forward<ArgsT>(args)...));
@@ -249,6 +314,10 @@ public:
 
 	///
 	/// \brief Clears the map destructing all elements
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	void clear() {
 		_set.clear();
 	}
@@ -257,21 +326,30 @@ public:
 
 
 // Iteration ===========================================================================================================
+public:
 
 	/// \name Iteration
 	/// @{
 
 	///
-	/// \brief C++ Iterator Specification `begin()`
+	/// \brief C++ Iterator Specification \f$begin()\f$
 	/// \returns an iterator at the start of the map
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr iterator begin() {
 		return _set.begin();
 	}
 
 
 	///
-	/// \brief C++ Iterator Specification `end()`
+	/// \brief C++ Iterator Specification \f$end()\f$
 	/// \returns an iterator at the end of the map
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr iterator end() {
 		return _set.end();
 	}
@@ -279,9 +357,13 @@ public:
 	/// @}
 
 
+// Private Member Variables ============================================================================================
 private:
 	 set_t _set;
 
+
+// Private Helpers =====================================================================================================
+private:
 	template<typename...ArgsT>
 	set_t::iterator _find(ArgsT&&...args) const {
 		union U { // Hacky way of avoiding constructing the value, TODO: Check for warnings on other compilers
@@ -291,7 +373,9 @@ private:
 			~U() {
 				fennec::destruct(&root);
 			}
-		} trick = { .root = { KeyT(fennec::forward<ArgsT>(args)...), 0 } };
+		} trick = {
+			.root = { KeyT(fennec::forward<ArgsT>(args)...), 0 }
+		};
 		return _set.find(trick.val);
 	}
 

include/fennec/containers/multiset.h

@@ -1,586 +0,0 @@
-// =====================================================================================================================
-//  fennec, a free and open source game engine
-//  Copyright © 2025  Medusa Slockbower
-//
-//  This program is free software: you can redistribute it and/or modify
-//  it under the terms of the GNU General Public License as published by
-//  the Free Software Foundation, either version 3 of the License, or
-//  (at your option) any later version.
-//
-//  This program is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//  GNU General Public License for more details.
-//
-//  You should have received a copy of the GNU General Public License
-//  along with this program.  If not, see <https://www.gnu.org/licenses/>.
-// =====================================================================================================================
-
-///
-/// \file multiset.h
-/// \brief A header containing the definition for a set of repeating values
-///
-///
-/// \details
-/// \author Medusa Slockbower
-///
-/// \copyright Copyright © 2025 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
-///
-///
-
-#ifndef FENNEC_CONTAINERS_MULTISET_H
-#define FENNEC_CONTAINERS_MULTISET_H
-
-// https://programming.guide/robin-hood-hashing.html
-
-#include <fennec/containers/optional.h>
-#include <fennec/containers/multiset.h>
-#include <fennec/lang/compare.h>
-#include <fennec/math/ext/primes.h>
-#include <fennec/memory/allocator.h>
-#include <fennec/lang/hashing.h>
-
-namespace fennec
-{
-
-///
-///
-/// \brief A Data Structure that defines a set of elements that may repeat
-/// \details
-/// | Property   | Value      |
-/// |:----------:|:----------:|
-/// | stable     |      ⛔     |
-/// | dynamic    |      ✅     |
-/// | homogenous |      ✅     |
-/// | distinct   |      ⛔     |
-/// | ordered    |      ⛔     |
-/// | space      | \f$O(N)\f$ |
-/// | linear     |      ✅     |
-/// | access     | \f$O(1)\f$ |
-/// | find       | \f$O(1)\f$ |
-/// | insertion  | \f$O(1)\f$ |
-/// | deletion   | \f$O(1)\f$ |
-///
-/// \tparam TypeT The type to contain
-template<typename TypeT, class Hash = hash<TypeT>, class Equals = equality<TypeT>, class Alloc = allocator<TypeT>>
-struct multiset {
-
-// Definitions =========================================================================================================
-public:
-	using alloc_t = typename allocator_traits<Alloc>::template rebind<TypeT>;
-	using hash_t = Hash;
-	using equal_t = Equals;
-	using elem_t = TypeT;
-
-	class iterator;
-	class value_iterator;
-	static constexpr size_t npos = -1;
-	static constexpr double default_load = 0.8;
-
-private:
-	struct node {
-		optional<elem_t> value;
-		int psl;
-
-		constexpr node() = default;
-		constexpr ~node() = default;
-	};
-
-// Constructors ========================================================================================================
-public:
-
-	/// \name Constructors & Destructor
-	/// @{
-
-	///
-	/// \brief Default Constructor, initializes empty multiset
-	constexpr multiset()
-		: _alloc()
-		, _hash()
-		, _size(0)
-		, _sumpsl(0)
-		, _load(default_load) {
-	};
-
-	///
-	/// \brief Hash Copy Constructor, initializes empty multiset with a hash
-	constexpr multiset(const hash_t& hash)
-		: _alloc()
-		, _hash(hash)
-		, _size(0)
-		, _sumpsl(0)
-		, _load(default_load) {
-	}
-
-	///
-	/// \brief Hash Move Constructor, initializes empty multiset with a hash
-	constexpr multiset(hash_t&& hash) noexcept
-		: _alloc()
-		, _hash(hash)
-		, _size(0)
-		, _sumpsl(0)
-		, _load(default_load) {
-	}
-
-	///
-	/// \brief Alloc Copy Constructor, initializes empty multiset with an allocator
-	constexpr multiset(const alloc_t& alloc)
-		: _alloc(alloc)
-		, _hash()
-		, _size(0)
-		, _sumpsl(0)
-		, _load(default_load) {
-	}
-
-	///
-	/// \brief Alloc Move Constructor, initializes empty multiset with an allocator
-	constexpr multiset(alloc_t&& alloc) noexcept
-		: _alloc(alloc)
-		, _hash()
-		, _size(0)
-		, _sumpsl(0)
-		, _load(default_load) {
-	}
-
-	///
-	/// \brief Hash Alloc Copy Constructor, initializes empty multiset with a hash and allocator
-	constexpr multiset(const hash_t& hash, const alloc_t& alloc)
-		: _alloc(alloc)
-		, _hash(hash)
-		, _size(0)
-		, _sumpsl(0)
-		, _load(default_load) {
-	}
-
-	///
-	/// \brief Hash Copy Alloc Move Constructor, initializes empty multiset with a hash and allocator
-	constexpr multiset(const hash_t& hash, alloc_t&& alloc) noexcept
-		: _alloc(alloc)
-		, _hash(hash)
-		, _size(0)
-		, _sumpsl(0)
-		, _load(default_load) {
-	}
-
-	///
-	/// \brief Hash Move Alloc Move Constructor, initializes empty multiset with a hash and allocator
-	constexpr multiset(hash_t&& hash, alloc_t&& alloc) noexcept
-		: _alloc(alloc)
-		, _hash(hash)
-		, _size(0)
-		, _sumpsl(0)
-		, _load(default_load) {
-	}
-
-	///
-	/// \brief Hash Move Alloc Copy Constructor, initializes empty multiset with a hash and allocator
-	constexpr multiset(hash_t&& hash, const alloc_t& alloc) noexcept
-		: _alloc(alloc)
-		, _hash(hash)
-		, _size(0)
-		, _sumpsl(0)
-		, _load(default_load) {
-	}
-
-	///
-	/// \brief Set Copy Constructor
-	/// \param multiset Set to copy
-	constexpr multiset(const multiset& multiset)
-		: _alloc( multiset._alloc)
-		, _hash( multiset._hash)
-		, _size( multiset._size)
-		, _sumpsl( multiset._sumpsl)
-		, _load( multiset._load) {
-	}
-
-	///
-	/// \brief Set Move Constructor
-	/// \param multiset Set to move
-	constexpr multiset(multiset&& multiset) noexcept
-		: _alloc(fennec::move( multiset._alloc))
-		, _hash(fennec::move( multiset._hash))
-		, _size(fennec::move( multiset._size))
-		, _sumpsl( multiset._sumpsl)
-		, _load( multiset._load) {
-	}
-
-	///
-	/// \brief Destructor, destructs all elements and releases the allocation
-	constexpr ~multiset() {
-		for (size_t i = 0; i < capacity(); ++i) {
-			_alloc[i].value = nullopt;
-		}
-	}
-
-	/// @}
-
-
-// Properties ==========================================================================================================
-
-	/// \name Properties
-	/// @{
-
-	///
-	/// \returns Size of the multiset in elements
-	constexpr size_t size() const {
-		return _size;
-	}
-
-	///
-	/// \returns `true` when the set is empty, `false` otherwise
-	constexpr bool empty() const {
-		return _size == 0;
-	}
-
-	///
-	/// \returns Capacity of the multiset in elements
-	constexpr size_t capacity() const {
-		return _alloc.capacity();
-	}
-
-	/// @}
-
-
-// Access ==============================================================================================================
-
-	/// \name Access
-	/// @{
-
-	///
-	/// \brief Find an Element
-	/// \param val Value to find
-	/// \returns An iterator at the location of the first instance of `value`
-	constexpr iterator find(const elem_t& val, size_t c = 0) const {
-		if (capacity() == 0) {
-			return end();
-		}
-		size_t s = _hash(val) % capacity();              // Initial search index
-		int    psl = (_size != 0) ? _sumpsl / _size : 0; // Initial psl
-		size_t i = (s + psl) % capacity();               // Median search
-		size_t n = 0;
-
-		// Check the first element;
-		if (_alloc[i].psl >= psl && _alloc[i].value) {
-			if (*_alloc[i].value == val) {
-				return iterator(this, i);
-			}
-		}
-
-		// Loop while there is a value and its psl is greater than our probe
-		while (c > 0) {
-			++n;
-			size_t i0 = (i + capacity() - n) % capacity(); // Prevent index underflow
-			size_t i1 = (i + n) % capacity();
-			int    p0 = psl - n, p1 = psl + n;
-			bool   c0  = p0 >= 0 && _alloc[i0].psl >= p0, c1 = _alloc[i1].psl >= p1; // Check that we are in range
-
-			if (c0 && _alloc[i0].value) {
-				if (*_alloc[i0].value == val) {
-					if (c-- == 0) {
-						return iterator(this, i0);
-					}
-				}
-			}
-
-			if (c1 && _alloc[i1].value) {
-				if (*_alloc[i1].value == val) {
-					if (c-- == 0) {
-						return iterator(this, i1);
-					}
-				}
-			}
-
-			if (not(c0 or c1)) {
-				break;
-			}
-		}
-
-		return iterator(this, npos);
-	}
-
-	///
-	/// \brief Check if a multiset contains a value
-	/// \param val Value to check
-	/// \returns `true` if `val` can be found, `false` otherwise
-	constexpr bool contains(const elem_t& val) const {
-		return this->find(val) != end();
-	}
-
-	///
-	/// \brief Iterator Access
-	/// \param it Location to access
-	/// \returns A pointer to the element, `nullptr` if not found.
-	///          The value should not be changed in a manner that will change the hash of the element.
-	constexpr elem_t* at(const iterator& it) {
-		if (it == end()) {
-			return nullptr;
-		}
-		if (not _alloc[it._i].value) {
-			return nullptr;
-		}
-		return &*_alloc[it._i].value;
-	}
-
-	///
-	/// \brief Iterator Const Access
-	/// \param it Location to access
-	/// \returns A const-qualified pointer to the element, `nullptr` if not found.
-	constexpr const elem_t* at(const iterator& it) const {
-		if (not _alloc[it._i].value) return nullptr;
-		return &*_alloc[it._i].value;
-	}
-
-	/// @}
-
-// Modifiers ===========================================================================================================
-
-	/// \name Modifiers
-	/// @{
-
-	///
-	/// \brief Move Insertion
-	/// \param val Value to insert
-	constexpr void insert(elem_t&& val) {
-		this->_insert(fennec::forward<elem_t>(val));
-	}
-
-	///
-	/// \brief Copy Insertion
-	/// \param val Value to insert
-	constexpr void insert(const elem_t& val) {
-		this->_insert(val);
-	}
-
-	///
-	/// \brief Emplace Insertion
-	/// \tparam ArgsT Argument types
-	/// \param args Arguments to construct with
-	template<typename...ArgsT>
-	constexpr void emplace(ArgsT&&...args) {
-		this->_insert(fennec::forward<ArgsT>(args)...);
-	}
-
-	///
-	/// \brief Element Erase
-	/// \param it Location to erase
-	constexpr void erase(iterator it) {
-		size_t i = it._i;
-		if (i >= capacity()) {
-			return;
-		} // These are separated due to compilers being inconsistent
-		if (not _alloc[i].value) {
-			return;
-		}
-
-		_alloc[i].value = nullopt;
-		_sumpsl -= _alloc[i].psl;
-		--_size;
-		size_t p = i;
-		while (_alloc[i = (i + 1) % capacity()].value) {
-			if (_alloc[i].psl == 0) break;
-
-			fennec::swap(_alloc[i - 1].value, _alloc[i].value);
-			--_alloc[p].psl, --_sumpsl;
-			p = i;
-		}
-	}
-
-	///
-	/// \brief Element Erase
-	/// \param val Value to erase
-	constexpr void erase(const elem_t& val) {
-		this->erase(this->find(val));
-	}
-
-	/// @}
-
-
-// ITERATOR ============================================================================================================
-
-	/// \name Iteration
-	/// @{
-
-	///
-	/// \brief C++ Iterator Specification `begin()`
-	/// \returns An iterator for all elements of the set in no particular order
-	constexpr iterator begin() const {
-		iterator it(this, 0);
-		if (not _alloc[it._i].value) {
-			++it;
-		}
-		return it;
-	}
-
-	///
-	/// \brief C++ Iterator Specification `end()`
-	/// \returns An iterator representing the end of the set
-	constexpr iterator end() const {
-		return iterator(this, npos);
-	}
-
-	/// @}
-
-	///
-	/// \brief Class for Iterating the Set
-	class iterator {
-	public:
-		constexpr ~iterator() {
-			_set = nullptr;
-		}
-
-		// prefix operator
-		constexpr iterator& operator++() {
-			while (++_i < _set->capacity()) {
-				if (_set->_alloc[_i].value) {
-					return *this;
-				}
-			}
-			_i = npos;
-			return *this;
-		}
-
-		constexpr iterator operator++(int) {
-			iterator prev = *this;
-			this->operator++();
-			return prev;
-		}
-
-		constexpr const elem_t& operator*() const {
-			return *_set->_alloc[_i].value;
-		}
-
-		constexpr const elem_t* operator->() const {
-			if (not _set->_alloc[_i].value) return nullptr;
-			return &*_set->_alloc[_i].value;
-		}
-
-		constexpr bool operator==(const iterator& it) const {
-			return _set == it._set and _i == it._i;
-		}
-
-		constexpr bool operator!=(const iterator& it) const {
-			return _set != it._set or _i != it._i;
-		}
-
-	private:
-		const multiset* _set;
-		size_t _i;
-		friend multiset;
-
-		constexpr iterator(const multiset* multiset, size_t i)
-			: _set(multiset)
-			, _i(i) {
-		}
-	};
-
-	class value_iterator {
-	public:
-		constexpr ~value_iterator() {
-			_set = nullptr;
-		}
-
-		// prefix operator
-		constexpr value_iterator& operator++() {
-			while (_psl <= _set->_alloc[_i].psl) {
-				if (not _set->_alloc[_i].value) {
-					break;
-				}
-			}
-			_i = npos;
-			return *this;
-		}
-
-		constexpr value_iterator operator++(int) {
-			value_iterator prev = *this;
-			this->operator++();
-			return prev;
-		}
-
-		constexpr const elem_t& operator*() const {
-			return *_set->_alloc[_i].value;
-		}
-
-		constexpr const elem_t* operator->() const {
-			if (not _set->_alloc[_i].value) return nullptr;
-			return &*_set->_alloc[_i].value;
-		}
-
-		constexpr bool operator==(const iterator& it) const {
-			return _set == it._set and _i == it._i;
-		}
-
-		constexpr bool operator!=(const iterator& it) const {
-			return _set != it._set or _i != it._i;
-		}
-
-	private:
-		const multiset* _set;
-		size_t _i;
-		int _psl;
-		elem_t _value;
-		friend multiset;
-
-		constexpr value_iterator(const multiset* multiset, size_t i, int psl, const elem_t& value)
-			: _set(multiset)
-			, _i(i)
-			, _value(value) {
-		}
-	};
-
-
-// PRIVATE =============================================================================================================
-
-private:
-	constexpr void _expand() {
-		multiset cpy; // Create a new multiset
-		cpy._alloc.callocate(
-			fennec::next_prime2(_alloc.capacity())
-		);
-
-		// rehash
-		for (size_t i = 0; i < capacity(); ++i) {
-			if (_alloc[i].value) {
-				cpy.insert(fennec::move(*_alloc[i].value));
-			}
-		}
-
-		// Swap buffers
-		fennec::swap(_alloc, cpy._alloc);
-	}
-
-	template<typename...ArgsT>
-	constexpr void _insert(ArgsT&&...args) {
-		if (_size == 0 or static_cast<float>(_size) / capacity() >= _load) { // expand when full
-			_expand();
-		}
-
-		elem_t value(fennec::forward<ArgsT>(args)...);
-		size_t i = _hash(value) % capacity(); // Initial search index
-		int psl = 0;
-		while (_alloc[i].value) { // Search for empty cell
-			if (_equal(*_alloc[i].value, value)) { // Check to see if this element is already inserted
-				return;
-			}
-			if (psl > _alloc[i].psl) { // When psl is higher, swap
-				_sumpsl += psl - _alloc[i].psl;
-				fennec::swap(_alloc[i].psl, psl);
-				fennec::swap(*_alloc[i].value, value);
-			}
-			i = (i + 1) % capacity(); ++psl;
-		}
-		_alloc[i].value = fennec::move(value);
-		_sumpsl += (_alloc[i].psl = psl);
-		++_size;
-	}
-
-	allocation<node, alloc_t> _alloc;
-	hash_t  _hash;
-	equal_t _equal;
-	size_t  _size;
-	size_t  _sumpsl;
-	float   _load;
-};
-
-}
-
-#endif // FENNEC_CONTAINERS_SET_H

include/fennec/containers/object_pool.h

@@ -1,6 +1,6 @@
 // =====================================================================================================================
 //  fennec, a free and open source game engine
-//  Copyright © 2025  Medusa Slockbower
+//  Copyright © 2025 - 2026  Medusa Slockbower
 //
 //  This program is free software: you can redistribute it and/or modify
 //  it under the terms of the GNU General Public License as published by
@@ -17,14 +17,14 @@
 // =====================================================================================================================
 
 ///
-/// \file object_pool.h
+/// \file fennec/containers/object_pool.h
 /// \brief A header containing the definition for a pool of objects associated by ids
 ///
 ///
 /// \details
 /// \author Medusa Slockbower
 ///
-/// \copyright Copyright © 2025 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
+/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
 ///
 ///
 
@@ -40,6 +40,22 @@ namespace fennec
 
 ///
 /// \brief Struct which holds a pool of objects associated with ids
+/// \details
+/// | Property    | Value      |
+/// |:-----------:|:----------:|
+/// | stable      |     ⛔     |
+/// | dynamic     |     ✅     |
+/// | homogeneous |     ✅     |
+/// | distinct    |     ⛔     |
+/// | ordered     |     ⛔     |
+/// | space       | \f$O(N)\f$ |
+/// | linear      |     ⛔     |
+/// | access      | \f$O(1)\f$ |
+/// | find        | \f$O(N)\f$ |
+/// | insertion   | \f$O(1)\f$ |
+/// | deletion    | \f$O(1)\f$ |
+/// | space       | \f$O(N)\f$ |
+///
 /// \tparam TypeT The value type
 /// \tparam AllocT The allocator type
 template<typename TypeT, typename AllocT = allocator<TypeT>>
@@ -47,24 +63,43 @@ struct object_pool {
 
 // Definitions =========================================================================================================
 public:
-	using value_t = TypeT;
+
-	using elem_t  = optional<TypeT>;
+	/// \name Definitions
-	using table_t = dynarray<elem_t, AllocT>;
+	/// @{
+
+	using value_t = TypeT;                    //!< The held object type
+	using elem_t  = optional<value_t>;        //!< The element type
+	using table_t = dynarray<elem_t, AllocT>; //!< The underlying table type
+	using freed_t = list<size_t, AllocT>;     //!< The underlying free queue
+
+	/// @}
+
+	class iterator;
+	class const_iterator;
 
 
 // Constructors & Destructor ===========================================================================================
+public:
 
 	/// \name Constructors & Destructor
 	/// @{
 
 	///
 	/// \brief Default Constructor, initializes an empty object pool
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr object_pool()
 		: _size(0) {
 	}
 
 	///
 	/// \brief Default Destructor, destructs objects then releases the allocation.
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
+	///
 	constexpr ~object_pool() = default;
 
 	/// @}
@@ -77,30 +112,46 @@ public:
 
 	///
 	/// \returns The number of active objects in the pool
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr size_t size() const {
 		return _size;
 	}
 
 	///
 	/// \returns The capacity of the underlying allocation
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr size_t capacity() const {
 		return _table.capacity();
 	}
 
 	///
-	/// \returns `true` when there are no objects in the pool, `false` otherwise
+	/// \returns \f$true\f$ when there are no objects in the pool, \f$false\f$ otherwise
-	constexpr bool empty() const {
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	constexpr bool is_empty() const {
 		return size() == 0;
 	}
 
 	///
-	/// \brief Retrieve the next id `i` that would be assigned to an object `o` were it added to the object pool
+	/// \brief Retrieve the next id \f$i\f$ that would be assigned to an object \f$o\f$ were it added to the object pool
 	///
 	/// \details This can be useful if there are constant members that need to be assigned at construction.
 	/// \returns The id of the next inserted node
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr size_t next_id() const {
 		size_t next = _size;
-		if (not _freed.empty()) {
+		if (not _freed.is_empty()) {
 			next = _freed.front();
 		}
 		return next;
@@ -116,23 +167,36 @@ public:
 	///
 	/// \brief Array Access Operator
 	/// \param i id of the object
-	/// \returns a reference to the object with id `i`
+	/// \returns a reference to the object with id \f$i\f$
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr value_t& operator[](size_t i) {
 		assert(i < capacity(), "Index out of Bounds!");
-		assert(_table[i], "Attempted to access Null Object.");
+		assert(_table[i], "Attempted to access null object.")
 		return *_table[i];
 	}
 
 	///
 	/// \brief Array Const Access Operator
 	/// \param i id of the object
-	/// \returns a const-qualified reference to the object with id `i`
+	/// \returns a const-qualified reference to the object with id \f$i\f$
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr const value_t& operator[](size_t i) const {
 		assert(i < capacity(), "Index out of Bounds!");
-		assert(_table[i], "Attempted to access Null Object.");
+		assert(_table[i], "Attempted to access null object.")
 		return *_table[i];
 	}
 
+	constexpr bool operator()(size_t i) const {
+		assert(i < capacity(), "Index out of Bounds!");
+		return _table[i];
+	}
+
 	/// @}
 
 
@@ -142,26 +206,38 @@ public:
 	/// @{
 
 	///
-	/// \brief Move Insertion, inserts `x` into the pool
+	/// \brief Move Insertion, inserts \f$x\f$ into the pool
 	/// \param x the object to move
 	/// \returns An integer corresponding to the id of the node
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr size_t insert(value_t&& x) {
 		return this->_insert(fennec::forward<value_t>(x));
 	}
 
 	///
-	/// \brief Move Insertion, inserts a copy of `x` into the pool
+	/// \brief Move Insertion, inserts a copy of \f$x\f$ into the pool
 	/// \param x the object to copy
 	/// \returns An integer corresponding to the id of the node
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr size_t insert(const value_t& x) {
 		return this->_insert(x);
 	}
 
 
 	///
-	/// \brief Emplacement, constructs a new object using `args...`
+	/// \brief Emplacement, constructs a new object using \f$args\ldots\f$
 	/// \param args The arguments to construct the new object with
 	/// \returns An integer corresponding to the id of the node
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	template<typename...ArgsT>
 	constexpr size_t emplace(ArgsT&&...args) {
 		return this->_insert(fennec::forward<ArgsT>(args)...);
@@ -170,22 +246,279 @@ public:
 	///
 	/// \brief Erase an object from the pool
 	/// \param i The id of the object
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr void erase(size_t i) {
 		_table[i] = nullopt;
 		_freed.push_back(i);
 		--_size;
 	}
 
+	///
+	/// \brief Clear the object pool
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
+	///
+	constexpr void clear() {
+		_table.clear();
+		_freed.clear();
+		_size = 0;
+	}
+
 	/// @}
 
+
+// Iterator ============================================================================================================
+
+	///
+	/// \returns an iterator at the start of the object pool
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	iterator begin() {
+		return iterator(this, 0);
+	}
+
+	///
+	/// \brief C++ Iterator Specification \f$begin()\f$
+	/// \returns an iterator at the start of the object pool
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	const_iterator begin() const {
+		return const_iterator(this, 0);
+	}
+
+	///
+	/// \returns an iterator at the start of the end of the object pool
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	iterator end() {
+		return iterator(this, _size);
+	}
+
+	///
+	/// \brief C++ Iterator Specification \f$end()\f$
+	/// \returns an iterator at the start of the end of the object pool
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	const_iterator end() const {
+		return const_iterator(this, _size);
+	}
+
+	///
+	/// \brief C++ Iterator Specification \f$iterator\f$
+	class iterator {
+	public:
+		///
+		/// \brief copy constructor
+		/// \param it the iterator to copy
+		iterator(const iterator& it) = default;
+
+		///
+		/// \brief move constructor
+		/// \param it the iterator to move
+		iterator(iterator&& it) noexcept = default;
+
+		///
+		/// \brief public destructor
+		~iterator() = default;
+
+
+		///
+		/// \brief copy assignment
+		/// \param it the iterator to copy
+		/// \returns a reference to self after having copied \f$it\f$
+		iterator& operator=(const iterator& it) = default;
+
+		///
+		/// \brief move assignment
+		/// \param it the iterator to move
+		/// \returns a reference to self after having moved \f$it\f$
+		iterator& operator=(iterator&& it) noexcept = default;
+
+		///
+		/// \brief postfix increment operator
+		/// \returns \f$it\f$ before having been incremented
+		friend iterator operator++(iterator& it, int) {
+			iterator ret = it;
+			++it.curr;
+			it._fix();
+			return ret;
+		}
+
+		///
+		/// \brief prefix increment operator
+		/// \returns \f$it\f$ after having moved to the next element
+		friend iterator& operator++(iterator& it) {
+			++it.curr;
+			it._fix();
+			return it;
+		}
+
+		///
+		/// \brief dereference operator
+		/// \returns a reference to the value pointed by the iterator
+		value_t& operator*() const {
+			return *pool->_table[curr];
+		}
+
+		///
+		/// \brief pointer access operator
+		/// \returns a pointer to the value pointed by the iterator
+		value_t* operator->() const {
+			return *pool->_table[curr];
+		}
+
+		///
+		/// \brief iterator equality operator
+		/// \param it the iterator to compare with
+		/// \returns \f$true\f$ if the iterators are identical, \f$false\f$ otherwise
+		bool operator==(const iterator& it) {
+			return pool == it.pool and curr == it.curr;
+		}
+
+		///
+		/// \brief iterator inequality operator
+		/// \param it the iterator to compare with
+		/// \returns \f$true\f$ if the iterators are different, \f$false\f$ otherwise
+		bool operator!=(const iterator& it) {
+			return pool != it.pool or curr != it.curr;
+		}
+
+	private:
+		object_pool* pool;
+		size_t       curr;
+
+		void _fix() {
+			while (curr < pool->_size and not pool->_table[curr]) {
+				++curr;
+			}
+		}
+
+		iterator(object_pool* pool, size_t start)
+			: pool(pool), curr(start) {
+			_fix();
+		}
+
+		friend struct object_pool;
+	};
+
+	///
+	/// \brief C++ Iterator Specification \f$const_iterator\f$
+	class const_iterator {
+	public:
+		///
+		/// \brief copy constructor
+		/// \param it the iterator to copy
+		const_iterator(const const_iterator&it ) = default;
+
+		///
+		/// \brief move constructor
+		/// \param it the iterator to move
+		const_iterator(const_iterator&& it) noexcept = default;
+
+		///
+		/// \brief public destructor
+		~const_iterator() = default;
+
+
+		///
+		/// \brief copy assignment
+		/// \param it the iterator to copy
+		/// \returns a reference to self after having copied \f$it\f$
+		const_iterator& operator=(const const_iterator& it) = default;
+
+		///
+		/// \brief move assignment
+		/// \param it the iterator to move
+		/// \returns a reference to self after having moved \f$it\f$
+		const_iterator& operator=(const_iterator&& it) noexcept = default;
+
+		///
+		/// \brief postfix increment operator
+		/// \returns \f$it\f$ before having been incremented
+		friend const_iterator operator++(const_iterator& it, int) {
+			const_iterator ret = it;
+			++it.curr;
+			it._fix();
+			return ret;
+		}
+
+		///
+		/// \brief prefix increment operator
+		/// \returns \f$it\f$ after having moved to the next element
+		friend const_iterator& operator++(const_iterator& it) {
+			++it.curr;
+			it._fix();
+			return it;
+		}
+
+		///
+		/// \brief dereference operator
+		/// \returns a reference to the value pointed by the iterator
+		const value_t& operator*() const {
+			return *pool->_table[curr];
+		}
+
+		///
+		/// \brief pointer access operator
+		/// \returns a pointer to the value pointed by the iterator
+		const value_t* operator->() const {
+			return *pool->_table[curr];
+		}
+
+		///
+		/// \brief iterator equality operator
+		/// \param it the iterator to compare with
+		/// \returns \f$true\f$ if the iterators are identical, \f$false\f$ otherwise
+		bool operator==(const const_iterator& it) {
+			return pool == it.pool and curr == it.curr;
+		}
+
+		///
+		/// \brief iterator inequality operator
+		/// \param it the iterator to compare with
+		/// \returns \f$true\f$ if the iterators are different, \f$false\f$ otherwise
+		bool operator!=(const const_iterator& it) {
+			return pool != it.pool or curr != it.curr;
+		}
+
+	private:
+		const object_pool* pool;
+		size_t             curr;
+
+		void _fix() {
+			while (curr < pool->_size and not pool->_table[curr]) {
+				++curr;
+			}
+		}
+
+		const_iterator(const object_pool* pool, size_t start)
+			: pool(pool), curr(start) {
+			_fix();
+		}
+
+		friend struct object_pool;
+	};
+
 private:
-	dynarray<elem_t, AllocT> _table;
+	table_t _table;
-	list<size_t> _freed;
+	freed_t _freed;
-	size_t      _size;
+	size_t  _size;
 
 	size_t _next_free() {
 		size_t next = _size;
-		if (not _freed.empty()) {
+		if (not _freed.is_empty()) {
 			next = _freed.front();
 			_freed.pop_front();
 		}
@@ -197,7 +530,7 @@ private:
 	size_t _insert(ArgsT&&...args) {
 		size_t i = _next_free();
 		if (i >= _table.size()) {
-			_table.emplace_back();
+			_table.resize(fennec::max(_table.size() * 2, size_t(8)));
 		}
 		_table[i].emplace(fennec::forward<ArgsT>(args)...);
 		return i;

include/fennec/containers/optional.h

@@ -1,6 +1,6 @@
 // =====================================================================================================================
 //  fennec, a free and open source game engine
-//  Copyright © 2025  Medusa Slockbower
+//  Copyright © 2025 - 2026  Medusa Slockbower
 //
 //  This program is free software: you can redistribute it and/or modify
 //  it under the terms of the GNU General Public License as published by
@@ -17,14 +17,14 @@
 // =====================================================================================================================
 
 ///
-/// \file optional.h
+/// \file fennec/containers/optional.h
 /// \brief A header containing the definition for a container with an optionally present variable
 ///
 ///
 /// \details
 /// \author Medusa Slockbower
 ///
-/// \copyright Copyright © 2025 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
+/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
 ///
 ///
 
@@ -38,24 +38,52 @@
 
 namespace fennec
 {
-
+///
+/// \brief struct to represent a \f$null\f$ `fennec::optional`
 struct nullopt_t {};
+
+///
+/// \brief value representing a \f$null\f$ `fennec::optional`
 constexpr nullopt_t nullopt_v = {};
 
+///
+/// \brief alias for representing a \f$null\f$ `fennec::optional`
 #define nullopt nullopt_v
 
 ///
 /// \brief Structure to hold an optional value.
+/// \details
+/// | Property    | Value      |
+/// |:-----------:|:----------:|
+/// | stable      |     ✅     |
+/// | dynamic     |     ⛔     |
+/// | homogeneous |     ✅     |
+/// | distinct    |     ⛔     |
+/// | ordered     |     ⛔     |
+/// | space       | \f$O(N)\f$ |
+/// | linear      |     ⛔     |
+/// | access      | \f$O(1)\f$ |
+/// | find        |     ⛔     |
+/// | insertion   | \f$O(1)\f$ |
+/// | deletion    | \f$O(1)\f$ |
+/// | space       | \f$O(1)\f$ |
+///
 /// \tparam T
 template<typename T>
 struct optional {
 
 // Definitions =========================================================================================================
 public:
-	using reference_t = T&;
+
-	using pointer_t = T*;
+	/// \name Definitions
-	using const_reference_t = T&;
+	/// @{
-	using const_pointer_t = const T*;
+
+	using reference_t = T&;           //!< reference type
+	using pointer_t = T*;             //!< pointer type
+	using const_reference_t = T&;     //!< const reference type
+	using const_pointer_t = const T*; //!< const pointer type
+
+	/// @}
 
 
 // Constructors ========================================================================================================
@@ -65,6 +93,10 @@ public:
 
 	///
 	/// \brief Default Constructor
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr optional()
 		: _root(0)
 		, _set(false) {
@@ -72,6 +104,10 @@ public:
 
 	///
 	/// \brief Default Constructor
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr optional(nullopt_t)
 		: _root(0)
 		, _set(false) {
@@ -80,6 +116,10 @@ public:
 	///
 	/// \brief Type Copy Constructor
 	/// \param val the value to initialize the underlying object with
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr optional(const T& val)
 		: _val(val)
 		, _set(true) {
@@ -88,6 +128,10 @@ public:
 	///
 	/// \brief Type Move Constructor
 	/// \param val the value to initialize the underlying object with
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr optional(T&& val)
 		: _val(fennec::forward<T>(val))
 		, _set(true) {
@@ -96,6 +140,10 @@ public:
 	///
 	/// \brief Copy Constructor
 	/// \param opt the optional to copy
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr optional(const optional& opt) requires is_copy_assignable_v<T>
 		: optional() {
 		_set = opt._set;
@@ -107,6 +155,10 @@ public:
 	///
 	/// \brief Move Constructor
 	/// \param opt the optional to move
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr optional(optional&& opt) noexcept requires is_move_assignable_v<T>
 		: optional() {
 		_set = opt._set;
@@ -116,12 +168,26 @@ public:
 		opt = nullopt;
 	}
 
+	///
+	/// \brief Emplace Constructor
+	/// \tparam ArgsT The argument types
+	/// \param args The argument values
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	template<typename...ArgsT>
 	constexpr optional(ArgsT&&...args)
 		: _val(fennec::forward<ArgsT>(args)...)
 		, _set(true) {
 	}
 
+	///
+	/// \brief destructor
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr ~optional() {
 		if constexpr(is_fundamental_v<T>) {
 			return;
@@ -140,14 +206,23 @@ public:
 	/// @{
 
 	///
-	/// \brief Implicit Boolean Check, returns `true` when there is a value contained
+	/// \brief Implicit Boolean Check
+	/// \returns \f$true\f$ when there is a value contained
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr operator bool() const {
 		return _set;
 	}
 
 	///
-	/// \returns `true` when there is no held value, `false` otherwise.
+	/// \returns \f$true\f$ when there is no held value, \f$false\f$ otherwise.
-	constexpr bool empty() const {
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	constexpr bool is_empty() const {
 		return not _set;
 	}
 
@@ -156,12 +231,16 @@ public:
 
 // Assignment Operators ================================================================================================
 
-	/// \name Assignment
+	/// \name Assignment Operators
 	/// @{
 
 	///
-	/// \brief Fundamental Type Assignment
+	/// \brief Null Assignment
-	/// \param val The value to set with
+	/// \returns A reference to self
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr optional& operator=(nullopt_t) {
 		if constexpr(not is_fundamental_v<T>) {
 			if (_set) {
@@ -176,6 +255,11 @@ public:
 	///
 	/// \brief Type Copy Assignment
 	/// \param val The value to set with
+	/// \returns A reference to self
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr optional& operator=(const T& val) requires is_copy_constructible_v<T> and is_copy_assignable_v<T> {
 		if (_set) {
 			_val = val;
@@ -189,6 +273,11 @@ public:
 	///
 	/// \brief Type Move Assignment
 	/// \param val The value to set with
+	/// \returns A reference to self
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr optional& operator=(T&& val) requires is_move_constructible_v<T> and is_move_assignable_v<T> {
 		if (_set) {
 			_val = fennec::forward<T>(val);
@@ -202,6 +291,11 @@ public:
 	///
 	/// \brief Copy Assignment
 	/// \param opt The optional to copy
+	/// \returns A reference to self
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr optional& operator=(const optional& opt) requires is_copy_constructible_v<T> and is_copy_assignable_v<T> {
 		if (_set != opt._set) {
 			_set = opt._set;
@@ -220,6 +314,11 @@ public:
 	///
 	/// \brief Move Assignment
 	/// \param opt The optional to move
+	/// \returns A reference to self
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr optional& operator=(optional&& opt) noexcept requires is_move_constructible_v<T> and is_move_assignable_v<T> {
 		if (_set != opt._set) {
 			_set = opt._set;
@@ -244,13 +343,21 @@ public:
 	/// @{
 
 	///
-	/// \returns A pointer to the value, `nullptr` if there is no value
+	/// \returns A pointer to the value, \f$nullptr\f$ if there is no value
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr pointer_t operator->() noexcept {
 		return _set ? &_val : nullptr;
 	}
 
 	///
-	/// \returns A const-qualified pointer to the value, `nullptr` if there is no value
+	/// \returns A const-qualified pointer to the value, \f$nullptr\f$ if there is no value
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr const_pointer_t operator->() const noexcept {
 		return _set ? &_val : nullptr;
 	}
@@ -258,6 +365,10 @@ public:
 	///
 	/// \brief Dereference Operator
 	/// \returns A reference to the value
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr T& operator*() & noexcept {
 		assertd(_set, "Attempted to reference the value of an unset optional");
 		return _val;
@@ -266,6 +377,10 @@ public:
 	///
 	/// \brief Const Dereference Operator
 	/// \returns A const-qualified reference to the value
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr const T& operator*() const& noexcept {
 		assertd(_set, "Attempted to reference the value of an unset optional");
 		return _val;
@@ -274,6 +389,10 @@ public:
 	///
 	/// \brief Dereference Operator
 	/// \returns A reference to the value
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr T&& operator*() && noexcept {
 		assertd(_set, "Attempted to reference the value of an unset optional");
 		return _val;
@@ -282,6 +401,10 @@ public:
 	///
 	/// \brief Const Dereference Operator
 	/// \returns A const-qualified reference to the value
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr const T&& operator*() const&& noexcept {
 		assertd(_set, "Attempted to reference the value of an unset optional");
 		return _val;
@@ -294,9 +417,50 @@ public:
 	/// \name Modifiers
 	/// @{
 
+	///
+	/// \brief Emplace Assignment, Move overload
+	/// \param val The object to take ownership of
+	/// \returns A reference to the held value
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	constexpr T& emplace(T&& val) {
+		if (_set) {
+			_val = fennec::forward<T>(val);
+		} else {
+			fennec::construct(&_val, fennec::forward<T>(val));
+			_set = true;
+		}
+		return _val;
+	}
+
+	///
+	/// \brief Emplace Assignment, Copy overload
+	/// \param val The object to copy
+	/// \returns A reference to the held value
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	constexpr T& emplace(const T& val) {
+		if (_set) {
+			_val = val;
+		} else {
+			fennec::construct(&_val, val);
+			_set = true;
+		}
+		return _val;
+	}
+
 	///
 	/// \brief Emplace Assignment
-	/// \val The optional to move
+	/// \param args The arguments to construct with
+	/// \returns A reference to the held value
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	template<typename...ArgsT>
 	constexpr T& emplace(ArgsT&&...args) {
 		if (_set) {
@@ -310,6 +474,10 @@ public:
 
 	///
 	/// \brief Reset the Optional
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	void reset() {
 		this->operator=(nullopt);
 	}

include/fennec/containers/pair.h

@@ -1,6 +1,6 @@
 // =====================================================================================================================
 //  fennec, a free and open source game engine
-//  Copyright © 2025  Medusa Slockbower
+//  Copyright © 2025 - 2026  Medusa Slockbower
 //
 //  This program is free software: you can redistribute it and/or modify
 //  it under the terms of the GNU General Public License as published by
@@ -17,14 +17,14 @@
 // =====================================================================================================================
 
 ///
-/// \file pair.h
+/// \file fennec/containers/pair.h
 /// \brief A header containing the definition for a container holding a pair of values
 ///
 ///
 /// \details
 /// \author Medusa Slockbower
 ///
-/// \copyright Copyright © 2025 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
+/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
 ///
 ///
 
@@ -42,33 +42,69 @@ namespace fennec
 
 ///
 /// \brief Struct for holding a pair of values
+/// \details
+/// | Property    | Value      |
+/// |:-----------:|:----------:|
+/// | stable      |     ✅     |
+/// | dynamic     |     ⛔     |
+/// | homogeneous |     ⛔     |
+/// | distinct    |     ⛔     |
+/// | ordered     |     ⛔     |
+/// | space       | \f$O(N)\f$ |
+/// | linear      |     ✅     |
+/// | access      | \f$O(1)\f$ |
+/// | find        |     ⛔     |
+/// | insertion   |     ⛔     |
+/// | deletion    |     ⛔     |
+/// | space       | \f$O(1)\f$ |
+///
 /// \tparam TypeT0 The type of the first value
 /// \tparam TypeT1 The type of the second value
 template<typename TypeT0, typename TypeT1>
 struct pair {
 
-// Members =============================================================================================================
+// Public Member Variables =============================================================================================
+public:
+
+	/// \name Member Variables
+	/// @{
+
+	TypeT0 first;  //!< The first value in the pair
+	TypeT1 second; //!< The second value in the pair
+
+	/// @}
 
-	TypeT0 first; ///< The first value in the pair
-	TypeT1 second; ///< The second value in the pair
 
 // Constructors ========================================================================================================
+public:
 
 	/// \name Constructors & Destructor
 	/// @{
 
 	///
 	/// \brief Default Constructor, invokes default constructor for both elements
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr pair() = default;
 
 	///
 	/// \brief Destructor, invokes destructor for both elements
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr ~pair() = default;
 
 	///
 	/// \brief Pair Copy Constructor
 	/// \param x Value to copy for the first element
 	/// \param y Value to copy for the first element
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr pair(const TypeT0& x, const TypeT1& y)
 		: first(x)
 		, second(y) {
@@ -78,6 +114,10 @@ struct pair {
 	/// \brief Pair Move Constructor
 	/// \param x Value to move for the first element
 	/// \param y Value to move for the first element
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr pair(TypeT0&& x, TypeT1&& y) noexcept
 		: first(fennec::forward<TypeT0>(x))
 		, second(fennec::forward<TypeT1>(y)) {
@@ -87,6 +127,10 @@ struct pair {
 	/// \brief Pair Implicit Constructor
 	/// \param arg1 Value to initialize the first element
 	/// \param arg2 Value to initialize the first element
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	template<typename Arg1T, typename Arg2T>
 	constexpr pair(Arg1T&& arg1, Arg2T&& arg2)
 		: first(fennec::forward<Arg1T>(arg1))
@@ -95,24 +139,61 @@ struct pair {
 
 	///
 	/// \brief Copy Constructor, copies both elements
-	constexpr pair(const pair&) = default;
+	/// \param pair The pair to copy
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	constexpr pair(const pair& pair)
+		: first(fennec::copy(pair.first))
+		, second(fennec::copy(pair.second)) {
+	}
 
 	///
 	/// \brief Move Constructor, moves both elements
-	constexpr pair(pair&&) noexcept = default;
+	/// \param pair The pair to move
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	constexpr pair(pair&& pair) noexcept
+		: first(fennec::move(pair.first))
+		, second(fennec::move(pair.second)) {
+	}
 
 	///
 	/// \brief Copy Assignment, copies both elements
-	constexpr pair& operator=(const pair&) = default;
+	/// \param pair The pair to copy
+	/// \returns A reference to self
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	constexpr pair& operator=(const pair& pair) {
+		first  = fennec::copy(pair.first);
+		second = fennec::copy(pair.second);
+		return *this;
+	}
 
 	///
 	/// \brief Move Assignment, moves both elements
-	constexpr pair& operator=(pair&&) noexcept = default;
+	/// \param pair The pair to move
+	/// \returns A reference to self
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	constexpr pair& operator=(pair&& pair) {
+		first  = fennec::move(pair.first);
+		second = fennec::move(pair.second);
+		return *this;
+	}
 
 	/// @}
 
 
 // Comparison ==========================================================================================================
+public:
 
 	/// \name Comparison
 	/// @{
@@ -120,7 +201,11 @@ struct pair {
 	///
 	/// \brief Equality Operator
 	/// \param p Pair to compare with
-	/// \returns `true` when both elements of each pair are equal
+	/// \returns \f$true\f$ when both elements of each pair are equal
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr bool operator==(const pair& p) const {
 		return first == p.first and second == p.second;
 	}
@@ -128,7 +213,11 @@ struct pair {
 	///
 	/// \brief Inequality Operator
 	/// \param p Pair to compare with
-	/// \returns `true` when either element of each pair are equal
+	/// \returns \f$true\f$ when either element of each pair are equal
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr bool operator!=(const pair& p) const {
 		return first != p.first or second != p.second;
 	}
@@ -136,8 +225,12 @@ struct pair {
 	///
 	/// \brief Less Than Operator
 	/// \param p Pair to compare with
-	/// \returns lexical comparison of both elements, i.e. returns `true` when the first element is less, or they are
+	/// \returns lexical comparison of both elements, i.e. returns \f$true\f$ when the first element is less, or they are
 	///          equal and the second element is less
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr bool operator<(const pair& p) const {
 		return first < p.first or (first == p.first and second < p.second);
 	}
@@ -145,8 +238,12 @@ struct pair {
 	///
 	/// \brief Less Equal Operator
 	/// \param p Pair to compare with
-	/// \returns lexical comparison of both elements, i.e. returns `true` when the first element is less, or they are
+	/// \returns lexical comparison of both elements, i.e. returns \f$true\f$ when the first element is less, or they are
 	///          equal and the second element is less or equal
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr bool operator<=(const pair& p) const {
 		return first < p.first or (first == p.first and second <= p.second);
 	}
@@ -154,8 +251,12 @@ struct pair {
 	///
 	/// \brief Greater Than Operator
 	/// \param p Pair to compare with
-	/// \returns lexical comparison of both elements, i.e. returns `true` when the first element is greater, or they are
+	/// \returns lexical comparison of both elements, i.e. returns \f$true\f$ when the first element is greater, or they are
 	///          equal and the second element is greater
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr bool operator>(const pair& p) const {
 		return first > p.first or (first == p.first and second > p.second);
 	}
@@ -163,8 +264,12 @@ struct pair {
 	///
 	/// \brief Greater Equal Operator
 	/// \param p Pair to compare with
-	/// \returns lexical comparison of both elements, i.e. returns `true` when the first element is greater, or they are
+	/// \returns lexical comparison of both elements, i.e. returns \f$true\f$ when the first element is greater, or they are
 	///          equal and the second element is greater or equal
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr bool operator>=(const pair& p) const {
 		return first > p.first or (first == p.first and second >= p.second);
 	}
@@ -172,8 +277,16 @@ struct pair {
 	/// @}
 };
 
+///
+/// \brief C++ 11 Hash Specification for `fennec::pair<TypeT0, TypeT1>`
+/// \tparam TypeT0 The first type of the pair
+/// \tparam TypeT1 The second type of the pair
 template<typename TypeT0, typename TypeT1>
 struct hash<pair<TypeT0, TypeT1>> : hash<TypeT0>, hash<TypeT1> {
+	///
+	/// \brief C++ 11 Hash Specification \f$operator()\f$
+	/// \param p The pair to hash
+	/// \returns a pairing of the hashes of both elements of \f$p\f$ using `fennec::pair_hash`
 	constexpr size_t operator()(const pair<TypeT0, TypeT1>& p) const {
 		return fennec::pair_hash( // pair the hashes of both elements
 			hash<TypeT0>::operator()(p.first),

include/fennec/containers/priority_queue.h

@@ -0,0 +1,289 @@
+// =====================================================================================================================
+//  fennec, a free and open source game engine
+//  Copyright © 2025 - 2026  Medusa Slockbower
+//
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+// =====================================================================================================================
+
+///
+/// \file fennec/containers/priority_queue.h
+/// \brief
+///
+///
+/// \details
+/// \author Medusa Slockbower
+///
+/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
+///
+///
+
+#ifndef FENNEC_CONTAINERS_PRIORITY_QUEUE_H
+#define FENNEC_CONTAINERS_PRIORITY_QUEUE_H
+
+#include <fennec/containers/object_pool.h>
+#include <fennec/lang/compare.h>
+#include <fennec/lang/types.h>
+#include <fennec/memory/allocator.h>
+
+// Binary heaps are just kinda busted.
+// In-array binary heaps are one of the most efficient data structures for computers
+// -> Cache Locality
+// -> log(n) runtime
+// -> No auxiliary structures or constant runtimes
+//
+// I tried just about every heap under the sun
+// -> strict fibonacci heap, got blown out of the water by std::priority_queue
+// -> fibonacci heap, got blown out of the water by std::priority_queue
+// -> binomial heap, on-par with std::set, blown out of the water by std::priority_queue
+//
+// Then I relented and fell back to ye old binary heap
+// This implementation roughly matches gcc's std::priority_queue
+
+namespace fennec
+{
+
+///
+/// \brief a priority queue data structure implemented using a binary heap
+/// \details
+/// | Property    | Value      |
+/// |:-----------:|:----------:|
+/// | stable      |     ⛔     |
+/// | dynamic     |     ✅     |
+/// | homogeneous |     ✅     |
+/// | distinct    |     ⛔     |
+/// | ordered     |     ✅     |
+/// | space       | \f$O(N)\f$ |
+/// | linear      |     ✅     |
+/// | access      | \f$O(1)\f$ |
+/// | find        |     ⛔     |
+/// | insertion   | \f$O(1)\f$ |
+/// | deletion    | \f$O(1)\f$ |
+/// | space       | \f$O(N)\f$ |
+///
+/// \tparam ValueT The value type
+/// \tparam CompareT The compare type, defaults to `fennec::less`
+/// \tparam AllocT The allocator type, defaults to `fennec::allocator`
+template<typename ValueT, class CompareT = less<ValueT>, class AllocT = allocator<ValueT>>
+struct priority_queue {
+
+// Definitions & Constants =============================================================================================
+public:
+
+	/// \name Definitions
+	/// @{
+
+	using value_t   = ValueT;                      //!< Alias for the value type
+	using compare_t = CompareT;                    //!< Alias for the compare type
+	using alloc_t   = allocation<value_t, AllocT>; //!< The underlying allocation type
+
+	/// @}
+
+	static constexpr size_t npos = -1; //!< value representing a null node
+
+private:
+	constexpr size_t left(size_t n) const {
+		n = n * 2 + 1;
+		return n >= _size ? npos : n;
+	}
+
+	constexpr size_t right(size_t n) const {
+		n = n * 2 + 2;
+		return n >= _size ? npos : n;
+	}
+
+	constexpr size_t parent(size_t n) const {
+		return n == 0 ? npos : (n - 1) / 2;
+	}
+
+
+// Constructors & Destructor ===========================================================================================
+public:
+
+	///
+	/// \brief default constructor
+	/// \details initializes an empty queue
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	constexpr priority_queue()
+		: _size(0) {
+	}
+
+	///
+	/// \brief destructor
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
+	///
+	constexpr ~priority_queue() {
+		while (_size > 0) {
+			--_size;
+			fennec::destruct(&_table[_size]);
+		}
+	}
+
+
+// Properties ==========================================================================================================
+public:
+
+	///
+	/// \returns the size of the queue
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	constexpr size_t size() const {
+		return _size;
+	}
+
+	///
+	/// \returns the capacity of the underlying allocation
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	constexpr size_t capacity() const {
+		return _table.capacity();
+	}
+
+	///
+	/// \returns \f$true\f$ if the queue holds no elements
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	constexpr bool is_empty() const {
+		return size() == 0;
+	}
+
+
+// Access ==============================================================================================================
+public:
+
+	///
+	/// \returns the value at the front of the queue
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	constexpr const value_t& front() const {
+		return _table[0];
+	}
+
+
+// Modifiers ===========================================================================================================
+public:
+
+	///
+	/// \brief push a new key into the queue
+	/// \param key the key to insert
+	///
+	/// \par Complexity
+	/// \f$O(\log N)\f$
+	///
+	constexpr void push(const value_t& key) {
+		this->_insert(key);
+	}
+
+	///
+	/// \param key the key to insert
+	///
+	/// \par Complexity
+	/// \f$O(\log N)\f$
+	///
+	constexpr void push(value_t&& key) {
+		this->_insert(fennec::forward<value_t>(key));
+	}
+
+	///
+	/// \brief emplace a new key into the queue
+	/// \tparam ArgsT the argument types
+	/// \param args the argument values
+	///
+	/// \par Complexity
+	/// \f$O(\log N)\f$
+	///
+	template<typename...ArgsT>
+	constexpr void emplace(ArgsT&&...args) {
+		this->_insert(fennec::forward<ArgsT>(args)...);
+	}
+
+	///
+	/// \brief pop the element at the front of the queue
+	///
+	/// \par Complexity
+	/// \f$O(\log N)\f$
+	///
+	constexpr void pop() {
+		fennec::swap(_table[0], _table[--_size]);
+		fennec::destruct(&_table[_size]);
+		_fix_erase(0);
+	}
+
+
+// Private Member Variables ============================================================================================
+private:
+	compare_t _compare;
+	alloc_t   _table;
+	size_t    _size;
+
+
+// Private Helpers =====================================================================================================
+private:
+
+	template<typename...ArgsT>
+	constexpr void _insert(ArgsT&&...args) {
+		if (_size == _table.capacity()) {
+			_expand();
+		}
+		fennec::construct(&_table[_size], fennec::forward<ArgsT>(args)...);
+		_fix_insert(_size++);
+	}
+
+	constexpr void _expand() {
+		_table.reallocate((_table.capacity() + 1) * 2 - 1);
+	}
+
+	constexpr size_t _min(size_t a, size_t b) {
+		if (a == npos) { return b; }
+		if (b == npos) { return a; }
+		return _compare(_table[a], _table[b]) ? a : b;
+	}
+
+	void _fix_insert(size_t n) {
+		size_t p = parent(n);
+		while (p != npos && _compare(_table[n], _table[p])) {
+			fennec::swap(_table[n], _table[p]);
+			n = p;
+			p = parent(n);
+		}
+	}
+
+	void _fix_erase(size_t n) {
+		size_t c = _min(left(n), right(n));
+		while (n != npos && c != npos && _compare(_table[c], _table[n])) {
+			fennec::swap(_table[c], _table[n]);
+			n = c;
+			c = _min(left(n), right(n));
+		}
+	}
+
+
+};
+
+}
+
+
+#endif // FENNEC_CONTAINERS_PRIORITY_QUEUE_H

include/fennec/containers/rdtree.h

@@ -1,6 +1,6 @@
 // =====================================================================================================================
 //  fennec, a free and open source game engine
-//  Copyright © 2025  Medusa Slockbower
+//  Copyright © 2025 - 2026  Medusa Slockbower
 //
 //  This program is free software: you can redistribute it and/or modify
 //  it under the terms of the GNU General Public License as published by
@@ -17,14 +17,14 @@
 // =====================================================================================================================
 
 ///
-/// \file rdtree.h
+/// \file fennec/containers/rdtree.h
 /// \brief A header containing the definition for a tree with a root and directed edges
 ///
 ///
 /// \details
 /// \author Medusa Slockbower
 ///
-/// \copyright Copyright © 2025 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
+/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
 ///
 ///
 
@@ -34,6 +34,8 @@
 #include <fennec/containers/list.h>
 #include <fennec/containers/optional.h>
 #include <fennec/containers/traversal.h>
+#include <fennec/containers/pair.h>
+
 #include <fennec/memory/allocator.h>
 
 namespace fennec
@@ -41,29 +43,58 @@ namespace fennec
 
 ///
 /// \brief Rooted-Directed Tree
+/// \details
+/// | Property    | Value      |
+/// |:-----------:|:----------:|
+/// | stable      |     ⛔     |
+/// | dynamic     |     ✅     |
+/// | homogeneous |     ✅     |
+/// | distinct    |     ⛔     |
+/// | ordered     |     ⛔     |
+/// | space       | \f$O(N)\f$ |
+/// | linear      |     ⛔     |
+/// | access      | \f$O(1)\f$ |
+/// | find        | \f$O(N)\f$ |
+/// | insertion   | \f$O(1)\f$ |
+/// | deletion    | \f$O(1)\f$ |
+/// | space       | \f$O(N)\f$ |
+///
 /// \tparam TypeT Data type
 /// \tparam AllocT Allocator Type
 template<typename TypeT, typename AllocT = allocator<TypeT>>
 struct rdtree {
 
 // Definitions =========================================================================================================
-protected:
+private:
 	struct node;
 
 public:
-	using value_t = TypeT;
-	using alloc_t = typename allocator_traits<AllocT>::template rebind<node>;
-	static constexpr size_t root = 0;
-	static constexpr size_t npos = -1;
 
-protected:
+	/// \name Definitions
+	/// @{
+
+	using value_t = TypeT;                                                    //!< the held value type
+	using alloc_t = typename allocator_traits<AllocT>::template rebind<node>; //!< the underlying allocator type
+
+	/// @}
+
+
+	/// \name Constants
+	/// @{
+
+	static constexpr size_t root = 0;  //!< the id of the root node
+	static constexpr size_t npos = -1; //!< the id of a null node
+
+	/// @}
+
+private:
 	struct node {
-		optional<TypeT> value;
+		value_t value;
-		size_t parent, child, prev, next;
+		size_t  parent, child, prev, next;
-		size_t depth, num_children;
+		size_t  depth, num_children;
 
 		constexpr node()
-			: value(nullopt)
+			: value()
 			, parent(npos), child(npos)
 			, prev(npos), next(npos)
 			, depth(0), num_children(0) {
@@ -86,6 +117,9 @@ protected:
 		}
 	};
 
+	using table_t = allocation<node, alloc_t>;
+	using freed_t = list<size_t>;
+
 public:
 
 // Constructors ========================================================================================================
@@ -97,23 +131,36 @@ public:
 	/// \brief Root Constructor, constructs the root node of the tree
 	/// \tparam ArgsT The argument types
 	/// \param args The arguments to construct the root with
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	template<typename...ArgsT>
 	explicit constexpr rdtree(ArgsT&&...args)
 		: _table(), _freed(), _size(1) {
-		_table.creallocate(8);
+		_table.reallocate(8);
 		fennec::construct(&_table[0], npos, npos, npos, npos, 0, fennec::forward<ArgsT>(args)...);
 	}
 
 	///
-	/// \brief Copy Constructor, copies the contents of `tree`
+	/// \brief Copy Constructor, copies the contents of \f$tree\f$
 	/// \param tree the rdtree to copy
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
+	///
 	constexpr rdtree(const rdtree& tree)
 		: _table(tree._table), _freed(tree._freed), _size(tree._size) {
+		// TODO: properly invoke copy constructor for all elements
 	}
 
 	///
-	/// \brief Move Constructor, takes ownership over the contents of `tree`
+	/// \brief Move Constructor, takes ownership over the contents of \f$tree\f$
 	/// \param tree the rdtree to move
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr rdtree(rdtree&& tree) noexcept
 		: _table(fennec::move(tree._table)), _freed(fennec::move(tree._freed)), _size(tree._size) {
 	}
@@ -123,14 +170,19 @@ public:
 
 // Assignment ==========================================================================================================
 
-	/// \name Assignment
+	/// \name Assignment Operators
 	/// @{
 
 	///
 	/// \brief Copy Assignment Operator
 	/// \param rhs the rdtree to copy
-	/// \returns `this` after copying the contents of `rhs`
+	/// \returns \f$this\f$ after copying the contents of \f$rhs\f$
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
+	///
 	constexpr rdtree& operator=(const rdtree& rhs) {
+		// TODO: properly invoke copy constructor for all elements
 		for (value_t* it : this->_table) {
 			fennec::destruct(it);
 		}
@@ -143,7 +195,11 @@ public:
 	///
 	/// \brief Move Assignment Operator
 	/// \param rhs the rdtree to move
-	/// \returns `this` after taking ownership over the contents of `rhs`
+	/// \returns \f$this\f$ after taking ownership over the contents of \f$rhs\f$
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr rdtree& operator=(rdtree&& rhs) noexcept {
 		for (value_t* it : _table) {
 			fennec::destruct(it);
@@ -163,28 +219,49 @@ public:
 
 	///
 	/// \returns The number of nodes in the tree
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr size_t size() const {
 		return _size;
 	}
 
 	///
 	/// \returns The capacity of the underlying allocation
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr size_t capacity() const {
 		return _table.capacity();
 	}
 
 	///
-	/// \returns `true` when there are no nodes in the tree, `false` otherwise
+	/// \returns \f$true\f$ when there are no nodes in the tree, \f$false\f$ otherwise
-	constexpr bool empty() const {
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	constexpr bool is_empty() const {
 		return _size == 0;
 	}
 
+	/// @}
+
 
 // Access ==============================================================================================================
 
+	/// \name Access
+	/// @{
+
 	///
 	/// \param i The id of the node to check
 	/// \returns The id of the parent node
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr size_t parent(size_t i) const {
 		if (i >= _table.capacity()) return npos;
 		return i == npos ? npos : _table[i].parent;
@@ -192,9 +269,14 @@ public:
 
 	///
 	/// \param i The id of the node to check
+	/// \param n The index of the child relative to the parent
 	/// \returns The id of the child node
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr size_t child(size_t i, size_t n = 0) const {
-		if (i >= _table.capacity()) return npos;
+		if (i >= _table.capacity() && n != npos) return npos;
 		size_t c = i == npos ? npos : _table[i].child;
 		if (n != 0)
 			return next(c, n == npos ? npos : n - 1);
@@ -203,9 +285,14 @@ public:
 
 	///
 	/// \param i The id of the node to check
+	/// \param n The index of the child relative to the parent
 	/// \returns The id of the next node
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr size_t next(size_t i, size_t n = 0) const {
-		if (i >= _table.capacity()) return npos;
+		if (i >= _table.capacity() && n != npos) return npos;
 		if (i == npos) {
 			return npos;
 		}
@@ -227,7 +314,12 @@ public:
 
 	///
 	/// \param i The id of the node to check
+	/// \param n The index of the child relative to the parent
 	/// \returns The id of the previous node
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr size_t prev(size_t i, size_t n = 0) const {
 		if (i >= _table.capacity()) return npos;
 		if (i == npos) {
@@ -251,7 +343,11 @@ public:
 
 	///
 	/// \param i the node to start at
-	/// \returns the left-most child of node `i`
+	/// \returns the left-most child of node \f$i\f$
+	///
+	/// \par Complexity
+	/// \f$O(\log N)\f$
+	///
 	constexpr size_t left_most(size_t i) const {
 		if (i >= _table.capacity()) return npos;
 		size_t n = i;
@@ -268,7 +364,11 @@ public:
 
 	///
 	/// \param i the node to start at
-	/// \returns the right-most child of node `i`
+	/// \returns the right-most child of node \f$i\f$
+	///
+	/// \par Complexity
+	/// \f$O(\log N)\f$
+	///
 	constexpr size_t right_most(size_t i) const {
 		if (i >= _table.capacity()) return npos;
 		if ((i = child(i)) == npos) {
@@ -289,6 +389,10 @@ public:
 	///
 	/// \param i The id of the node to check
 	/// \returns The depth of the node
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr size_t depth(size_t i) const {
 		if (i >= _table.capacity()) return npos;
 		return i == npos ? npos : _table[i].depth;
@@ -297,16 +401,24 @@ public:
 	///
 	/// \param i The id of the node to check
 	/// \returns The number of children the node has
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr size_t num_children(size_t i) const {
 		if (i >= _table.capacity()) return 0;
 		return i == npos ? 0 : _table[i].num_children;
 	}
 
 	///
-	/// \returns The next node id were `insert` or `emplace` to be called
+	/// \returns The next node id were \f$insert\f$ or \f$emplace\f$ to be called
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr size_t next_id() const {
 		size_t i = _size;
-		if (not _freed.empty()) {
+		if (not _freed.is_empty()) {
 			i = _freed.front();
 		}
 		return i;
@@ -315,56 +427,104 @@ public:
 	///
 	/// \param i The id of the node to access
 	/// \returns A reference to the value of the node wrapped in an optional
-	constexpr value_t* operator[](size_t i) {
+	///
-		auto& it = _table[i].value;
+	/// \par Complexity
-		if (it) {
+	/// \f$O(1)\f$
-			return &*_table[i].value;
+	///
-		} else {
+	constexpr value_t& operator[](size_t i) {
-			return nullptr;
+		return _table[i].value;
-		}
 	}
 
 	///
 	/// \param i The id of the node to access
 	/// \returns A const-qualified reference to the value of the node wrapped in an optional
-	constexpr const value_t* operator[](size_t i) const {
+	///
-		const auto& it = _table[i].value;
+	/// \par Complexity
-		if (it) {
+	/// \f$O(1)\f$
-			return &*_table[i].value;
+	///
-		} else {
+	constexpr const value_t& operator[](size_t i) const {
-			return nullptr;
+		return _table[i].value;
-		}
 	}
 
+	/// @}
 
-// Insertion & Deletion ================================================================================================
+
+// Modifiers ===========================================================================================================
+
+	/// \name Modifiers
+	/// @{
 
 	///
-	/// \brief Insertion, creates a node in the tree with parent `parent`
+	/// \brief Insertion, creates a node in the tree with parent \f$parent\f$
-	/// \param parent the parent node, if `npos` sets the value of the root node
+	/// \param parent the parent node, if \f$npos\f$ sets the value of the root node
-	/// \param next the next node, as an index relative to the parent
+	/// \param next the next node, as an index relative to the parent, i.e. parent[0] == parent.child, parent[1] == parent.child.next
 	/// \param val the value to insert
 	/// \returns the index of the created node
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr size_t insert(size_t parent, size_t next, const value_t& val) {
 		return this->_insert(parent, next, val);
 	}
 
 	///
-	/// \brief Insertion, creates a node in the tree with parent `parent`
+	/// \brief Insertion, creates a node in the tree with parent \f$parent\f$
-	/// \param parent the parent node, if `npos` sets the value of the root node
+	/// \param parent the parent node, if \f$npos\f$ sets the value of the root node
 	/// \param next the next node, as an index relative to the parent
 	/// \param val the value to insert
 	/// \returns the index of the created node
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr size_t insert(size_t parent, size_t next, value_t&& val) {
 		return this->_insert(parent, next, fennec::forward<value_t>(val));
 	}
 
 	///
-	/// \brief Insertion, creates a node in the tree with parent `parent`
+	/// \brief tree insertion, copies the contents of tree into self with the root at the specified node location
-	/// \param parent the parent node, if `npos` sets the value of the root node
+	/// \param parent the parent node, if \f$npos\f$ sets the value of the root node
 	/// \param next the next node, as an index relative to the parent
+	/// \param tree the tree to insert
+	/// \returns the index of the inserted root
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	constexpr size_t insert(size_t parent, size_t next, const rdtree& tree) {
+		list<pair<size_t, size_t>> visit;
+		visit.push_front({ root, parent });
+		size_t res = npos;
+
+		while (not visit.is_empty()) {
+			auto node = visit.front();
+			visit.pop_front();
+
+			size_t p = this->_insert(node.second, node.second == parent ? next : npos, tree[node.first]);
+
+			res = (res == npos) ? p : res;
+
+			size_t c = tree.child(node.first, npos);
+			while (c != npos) {
+				visit.push_front({ c, p });
+				c = tree._table[c].prev;
+			}
+		}
+
+		return res;
+	}
+
+	///
+	/// \brief Insertion, creates a node in the tree with parent \f$parent\f$
+	/// \param parent the parent node, if \f$npos\f$ sets the value of the root node
+	/// \param next the next node, as an index relative to the parent, i.e. parent[0] == parent.child, parent[1] == parent.child.next
 	/// \param args the args to construct the value to insert
 	/// \returns the index of the created node
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	template<typename...ArgsT>
 	constexpr size_t emplace(size_t parent, size_t next, ArgsT&&...args) {
 		return this->_insert(parent, next, fennec::forward<ArgsT>(args)...);
@@ -374,6 +534,10 @@ public:
 	/// \brief Swap two nodes
 	/// \param i0 The id of the first node
 	/// \param i1 The id of the second node
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr void swap(size_t i0, size_t i1) {
 		assertf(i0 != root and i1 != root, "Cannot Swap With Root");
 
@@ -399,28 +563,37 @@ public:
 		_erase(i);
 	}
 
+	/// @}
+
 
 // Traversal ===========================================================================================================
 
+	/// \name Traversal
+	/// @{
+
 	///
 	/// \brief Traverse the tree using a specified order and visiting functor
 	///
 	/// \details
-	/// The visitor should accept a reference to a value of type `TypeT` and a `size_t` which contains the node's id.
+	/// The visitor should accept a reference to a value of type \f$TypeT\f$ and a \f$size_t\f$ which contains the node's id.
 	/// The visitor should return one of the following values in the `fennec::traversal_control_` enum
 	///
 	/// \tparam OrderT The order with which to traverse the tree.
-	/// \tparam VisitorT The visitor, should fulfill the signature `uint8_t visit(TypeT&, size_t)`
+	/// \tparam VisitorT The visitor, should fulfill the signature \f$uint8_t visit(TypeT&, size_t)\f$
 	/// \param visit The visiting object
 	/// \param i The node to start at
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
+	///
 	template<typename OrderT, typename VisitorT>
-	void traverse(VisitorT&& visit, size_t i = root) {
+	constexpr void traverse(VisitorT&& visit, size_t i = root) {
 		OrderT order;
 		i = order(*this, i);
 		while (i != npos) {
 			uint8_t mode = traversal_control_continue;
 			if (_table[i].value) {
-				mode = visit(*_table[i].value, i);
+				mode = visit(_table[i].value, i);
 			}
 			if (mode == traversal_control_break) {
 				break;
@@ -429,16 +602,107 @@ public:
 		}
 	}
 
-	struct pre_order {
+	///
-		list<size_t> visit;
+	/// \brief Traverse the tree using a specified order and visiting functor
-		size_t       head;
+	///
+	/// \details
+	/// The visitor should accept a reference to a value of type \f$TypeT\f$ and a \f$size_t\f$ which contains the node's id.
+	/// The visitor should return one of the following values in the `fennec::traversal_control_` enum
+	///
+	/// \tparam OrderT The order with which to traverse the tree.
+	/// \tparam VisitorT The visitor, should fulfill the signature \f$uint8_t visit(TypeT&, size_t)\f$
+	/// \param visit The visiting object
+	/// \param i The node to start at
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
+	///
+	template<typename OrderT, typename VisitorT>
+	constexpr void traverse(VisitorT&& visit, size_t i = root) const {
+		OrderT order;
+		i = order(*this, i);
+		while (i != npos) {
+			uint8_t mode = traversal_control_continue;
+			if (_table[i].value) {
+				mode = visit(_table[i].value, i);
+			}
+			if (mode == traversal_control_break) {
+				break;
+			}
+			i = order[*this, i, mode];
+		}
+	}
 
-		size_t operator()(const rdtree&, size_t start) {
+	///
+	/// \brief Traverser pattern for breadth-first traversal
+	struct breadth_first {
+
+		///
+		/// \brief Traversal Init
+		/// \param start The node in the tree to start at
+		/// \returns The first index of the specified order
+		constexpr size_t operator()(const rdtree&, size_t start) {
 			head = start;
 			return start;
 		}
 
-		size_t operator[](const rdtree& tree, size_t node, uint8_t mode) {
+		///
+		/// \brief Traverser Step
+		/// \param tree The tree we are operating on
+		/// \param node The current node
+		/// \param mode The mode specifying branch conditions
+		/// \returns The next index according to the traversal order
+		constexpr size_t operator[](const rdtree& tree, size_t node, uint8_t mode) {
+			if (node == npos) {
+				return npos;
+			}
+
+			size_t nxt = tree.next(node);
+			size_t chd = tree.next(node);
+
+			if (nxt != npos && node != head) {
+				visit.push_front(nxt);
+			}
+
+			if (chd != npos && mode != traversal_control_jump_over) {
+				visit.push_back(chd);
+			}
+
+			if (not visit.is_empty()) {
+				node = visit.front();
+				visit.pop_front();
+			} else {
+				node = npos;
+			}
+
+			return node;
+		}
+
+	private:
+		list<size_t> visit;
+		size_t head;
+	};
+
+	///
+	/// \brief Traverser pattern for pre-order traversal
+	struct pre_order {
+
+		///
+		/// \brief Traversal Init
+		/// \param start The node in the tree to start at
+		/// \returns The first index of the specified order
+		constexpr size_t operator()(const rdtree&, size_t start) {
+			head = start;
+			return start;
+		}
+
+		///
+		/// \brief Traverser Step
+		/// \param tree The tree we are operating on
+		/// \param node The current node
+		/// \param mode The mode specifying branch conditions
+		/// \returns The next index according to the traversal order
+		constexpr size_t operator[](const rdtree& tree, size_t node, uint8_t mode) {
 			if (node == npos) {
 				return npos;
 			}
@@ -454,7 +718,7 @@ public:
 				visit.push_front(chd);
 			}
 
-			if (not visit.empty()) {
+			if (not visit.is_empty()) {
 				node = visit.front();
 				visit.pop_front();
 			} else {
@@ -463,18 +727,32 @@ public:
 
 			return node;
 		}
-	};
 
-	struct in_order {
+	private:
 		list<size_t> visit;
 		size_t       head;
+	};
 
-		size_t operator()(const rdtree& tree, size_t start) {
+	///
+	/// \brief Traverser pattern for in-order traversal
+	struct in_order {
+
+		///
+		/// \brief Traversal Init
+		/// \param tree The tree we are operating on
+		/// \param start The node in the tree to start at
+		/// \returns The first index of the specified order
+		constexpr size_t operator()(const rdtree& tree, size_t start) {
 			head = start;
 			return tree.left_most(start);
 		}
 
-		size_t operator[](const rdtree& tree, size_t node, uint8_t) {
+		///
+		/// \brief Traverser Step
+		/// \param tree The tree we are operating on
+		/// \param node The current node
+		/// \returns The next index according to the traversal order
+		constexpr size_t operator[](const rdtree& tree, size_t node, uint8_t) {
 			if (node == npos) {
 				return npos;
 			}
@@ -492,7 +770,7 @@ public:
 				}
 			}
 
-			if (not visit.empty()) {
+			if (not visit.is_empty()) {
 				node = visit.front();
 				visit.pop_front();
 			} else {
@@ -501,18 +779,32 @@ public:
 
 			return node;
 		}
-	};
 
-	struct post_order {
+	private:
 		list<size_t> visit;
 		size_t       head;
+	};
 
-		size_t operator()(const rdtree& tree, size_t start) {
+	///
+	/// \brief Traverser pattern for post-order traversal
+	struct post_order {
+
+		///
+		/// \brief Traversal Init
+		/// \param tree The tree we are operating on
+		/// \param start The node in the tree to start at
+		/// \returns The first index of the specified order
+		constexpr size_t operator()(const rdtree& tree, size_t start) {
 			head = start;
 			return tree.left_most(start);
 		}
 
-		size_t operator[](const rdtree& tree, size_t node, uint8_t) {
+		///
+		/// \brief Traverser Step
+		/// \param tree The tree we are operating on
+		/// \param node The current node
+		/// \returns The next index according to the traversal order
+		constexpr size_t operator[](const rdtree& tree, size_t node, uint8_t) {
 			if (node == npos) {
 				return npos;
 			}
@@ -528,7 +820,7 @@ public:
 				}
 			}
 
-			if (not visit.empty()) {
+			if (not visit.is_empty()) {
 				node = visit.front();
 				visit.pop_front();
 			} else {
@@ -537,21 +829,32 @@ public:
 
 			return node;
 		}
+
+	private:
+		list<size_t> visit;
+		size_t       head;
 	};
 
+	/// @}
 
-protected:
+
-	allocation<node, alloc_t> _table;
+// Private Member Variables ============================================================================================
-	list<size_t>              _freed;
+private:
-	size_t                    _size;
+	table_t _table;
+	freed_t _freed;
+	size_t  _size;
+
+
+// Private Helpers =====================================================================================================
+private:
 
 	void _expand() {
-		_table.creallocate(_table.capacity() * 2);
+		_table.reallocate(_table.capacity() * 2);
 	}
 
 	size_t _next_free() {
 		size_t next = _size;
-		if (not _freed.empty()) {
+		if (not _freed.is_empty()) {
 			next = _freed.front();
 			_freed.pop_front();
 		}
@@ -605,7 +908,7 @@ protected:
 	constexpr void _erase(size_t i) {
 		list<size_t> queue;
 		queue.push_back(child(i));
-		while (not queue.empty()) {
+		while (not queue.is_empty()) {
 			size_t n = queue.front(); queue.pop_front();
 			if (n == npos) continue;
 			queue.push_back(next(n));

include/fennec/containers/sequence.h

@@ -0,0 +1,927 @@
+// =====================================================================================================================
+//  fennec, a free and open source game engine
+//  Copyright © 2025 - 2026  Medusa Slockbower
+//
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+// =====================================================================================================================
+
+///
+/// \file fennec/containers/sequence.h
+/// \brief
+///
+///
+/// \details
+/// \author Medusa Slockbower
+///
+/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
+///
+///
+
+#ifndef FENNEC_CONTAINERS_SEQUENCE_H
+#define FENNEC_CONTAINERS_SEQUENCE_H
+
+#include <fennec/containers/pair.h>
+#include <fennec/containers/sequence.h>
+#include <fennec/lang/compare.h>
+#include <fennec/memory/allocator.h>
+
+// https://en.wikipedia.org/wiki/Red%E2%80%93black_tree
+// https://www.geeksforgeeks.org/dsa/insertion-in-red-black-tree/
+// https://github.com/anandarao/Red-Black-Tree/blob/master/RBTree.cpp
+
+// After rewriting the _fix_insert and _fix_erase functions the performance decreased significantly in the lower end
+// but now in the higher end it remains consistent. Something I was doing was disturbing both the rb-tree and bst tree
+// properties, now that is fixed. I'll see about optimizing more in the future.
+
+// I realized that the way bintree is setup makes some insert calls O(n + log n) = O(n), so I switched to a pointer based model.
+// This increased performance overall maintaining O(log n).
+
+namespace fennec
+{
+
+///
+///
+/// \brief wrapper for ordered sets of elements, called sequences in mathematics
+/// \details
+/// This data-structure behaves like an ordered-set, but does not use pointers, instead storing the table in-array
+///
+/// | Property    | Value           |
+/// |:-----------:|:---------------:|
+/// | stable      |        ✅       |
+/// | dynamic     |        ✅       |
+/// | homogeneous |        ✅       |
+/// | distinct    |        ✅       |
+/// | ordered     |        ✅       |
+/// | space       |   \f$O(N)\f$    |
+/// | linear      |        ✅       |
+/// | access      | \f$O(\log N)\f$ |
+/// | find        | \f$O(\log N)\f$ |
+/// | insertion   | \f$O(\log N)\f$ |
+/// | deletion    | \f$O(\log N)\f$ |
+/// | space       |   \f$O(N)\f$    |
+///
+/// \tparam TypeT The type to contain
+/// \tparam CompareT Function for comparing two values
+/// \tparam AllocT An allocator class
+template<typename TypeT, typename CompareT = less<TypeT>, class AllocT = allocator<pair<TypeT, bool>>>
+struct sequence {
+
+// Definitions =========================================================================================================
+private:
+	struct _node;
+
+	enum color_ : bool {
+		black = false,
+		red   = true,
+	};
+
+	enum dir_ : bool {
+		dir_left  = false,
+		dir_right = true,
+	};
+
+public:
+
+	/// \name Definitions
+	/// @{
+
+	using value_t   = TypeT;                                            //!< the value type
+	using node_t    = pair<TypeT, bool>;                                //!< the node type
+	using alloc_t   = allocator_traits<AllocT>::template rebind<_node>; //!< underlying alloc type
+	using compare_t = CompareT;                                         //!< comparison type
+
+	/// @}
+
+	class iterator;
+	class const_iterator;
+
+private:
+	using node = _node*;
+
+	struct _node {
+		node    parent;
+		node    child[2];
+		value_t key;
+		bool    color;
+
+		template<typename...ArgsT>
+		constexpr _node(ArgsT&&...args)
+			: parent(nullptr)
+			, child { nullptr, nullptr }
+			, key(fennec::forward<ArgsT>(args)...)
+			, color(red) {
+		}
+
+		template<typename...ArgsT>
+		constexpr _node(node p, node l, node r, ArgsT&&...args)
+			: parent(p)
+			, child { l, r }
+			, key(fennec::forward<ArgsT>(args)...)
+			, color(red) {
+		}
+
+		constexpr ~_node() {
+			parent   = nullptr;
+			child[0] = nullptr;
+			child[1] = nullptr;
+		}
+	};
+
+
+// Member Access Helpers
+
+	constexpr value_t& _key(node n) {
+		return n->key;
+	}
+
+	constexpr bool& _color(node n) {
+		return n->color;
+	}
+
+	constexpr node& _parent(node n) {
+		return n->parent;
+	}
+
+	constexpr node& _child(node n, bool dir) {
+		return n->child[dir];
+	}
+
+	constexpr node& _left(node n) {
+		return n->child[dir_left];
+	}
+
+	constexpr node& _right(node n) {
+		return n->child[dir_right];
+	}
+
+
+// Safe Member Access Helpers
+
+
+	constexpr const value_t& key(node n) const {
+		return n->key;
+	}
+
+	constexpr bool color(node n) {
+		return n ? n->color : (bool)black;
+	}
+
+	constexpr node parent(node n) {
+		return n ? n->parent : nullptr;
+	}
+
+	constexpr node child(node n, bool dir) {
+		return n ? n->child[dir] : nullptr;
+	}
+
+	constexpr node left(node n) {
+		return n ? n->child[dir_left] : nullptr;
+	}
+
+	constexpr node right(node n) {
+		return n ? n->child[dir_right] : nullptr;
+	}
+
+	constexpr node leftmost(node n) {
+		if (n == nullptr) {
+			return nullptr;
+		}
+
+		while (this->_left(n)) {
+			n = this->_left(n);
+		}
+		return n;
+	}
+
+	constexpr node rightmost(node n) {
+		if (n == nullptr) {
+			return nullptr;
+		}
+
+		while (this->_right(n)) {
+			n = this->_right(n);
+		}
+		return n;
+	}
+
+// Constructors & Destructors ==========================================================================================
+public:
+	/// \name Constructors & Destructor
+	/// @{
+
+	///
+	/// \brief Default Constructor, initializes an empty sequence
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	constexpr sequence()
+		: _root(nullptr), _size(0) {
+	}
+
+	///
+	/// \brief Move Constructor, takes ownership of a sequence
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	constexpr sequence(sequence&&) noexcept = default;
+
+	///
+	/// \brief Copy Constructor, copies a sequence
+	constexpr sequence(const sequence&) = default;
+	// TODO: properly implement
+
+	///
+	/// \brief Default Destructor, destructs elements *in-order*
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
+	///
+	constexpr ~sequence() {
+		this->clear();
+	}
+
+	/// @}
+
+// Search ==============================================================================================================
+public:
+	/// \name Search
+	/// @{
+
+	///
+	/// \brief Value Find Function, finds the iterator position for \f$val\f$, otherwise returns \f$end()\f$
+	/// \param val The value to find
+	/// \returns An iterator at the value
+	///
+	/// \par Complexity
+	/// \f$O(\log N)\f$
+	///
+	constexpr iterator find(const value_t& val) {
+		node node = _root;
+		while (node) {
+			if (_compare(val, _key(node))) {
+				node = _left(node);
+			} else if (_compare(_key(node), val)) {
+				node = _right(node);
+			} else {
+				return sequence::iterator(this, _root, node);
+			}
+		}
+		return sequence::iterator(this, _root, node);
+	}
+
+	///
+	/// \brief Value Contains Function, checks if the sequence contains a value
+	/// \param val The value to find
+	/// \returns \f$true\f$ if \f$val\f$ is in the sequence, \f$false\f$ otherwise
+	bool contains(const value_t& val) {
+		return find(val) != end();
+	}
+
+	/// @}
+
+
+// Properties ==========================================================================================================
+public:
+	/// \name Properties
+	/// @{
+
+	///
+	/// \returns The number of elements in the sequence
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	constexpr size_t size() const {
+		return _size;
+	}
+
+	///
+	/// \returns \f$true\f$ when there are no elements in the sequence, \f$false\f$ otherwise.
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	constexpr bool is_empty() const {
+		return _size == 0;
+	}
+
+	/// @}
+
+// Modifiers ===========================================================================================================
+public:
+	/// \name Modifiers
+	/// @{
+
+	///
+	/// \brief Move Insertion, moves \f$val\f$ into the sequence
+	/// \param val The value to insert
+	///
+	/// \par Complexity
+	/// \f$O(\log N)\f$
+	///
+	constexpr void insert(value_t&& val) {
+		node i = _insert_bst(fennec::forward<value_t>(val));
+		_fix_insert(i);
+	}
+
+	///
+	/// \brief Copy Insertion, inserts a copy of \f$val\f$ into the sequence
+	/// \param val The value to insert
+	///
+	/// \par Complexity
+	/// \f$O(\log N)\f$
+	///
+	constexpr void insert(const value_t& val) {
+		node i = _insert_bst(val);
+		_fix_insert(i);
+	}
+
+	///
+	/// \brief Emplacement, constructs and adds a value into the sequence
+	/// \tparam ArgsT The argument types
+	/// \param args The arguments to construct with
+	///
+	/// \par Complexity
+	/// \f$O(\log N)\f$
+	///
+	template<typename...ArgsT>
+	constexpr void emplace(ArgsT&&...args) {
+		node i = _insert_bst(fennec::forward<ArgsT>(args)...);
+		_fix_insert(i);
+	}
+
+	///
+	/// \brief Erase the specified value from the sequence
+	/// \param val the value to erase
+	///
+	/// \par Complexity
+	/// \f$O(\log N)\f$
+	///
+	constexpr void erase(const value_t& val) {
+		_erase(find(val)._node);
+	}
+
+	///
+	/// \brief Destructs all elements, *in-order*, contained in the sequence
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
+	///
+	constexpr void clear() {
+		list<node> visit;
+		for (iterator it = begin(); it != end(); ++it) {
+			visit.push_back(it._node);
+		}
+		for (node n : visit) {
+			this->_free_node(n);
+		}
+		_root = nullptr;
+		_size = 0;
+	}
+
+	/// @}
+
+// Iterator ============================================================================================================
+
+	///
+	/// \returns An iterator at the smallest element in the sequence
+	///
+	/// \par Complexity
+	/// \f$O(\log N)\f$
+	///
+	constexpr iterator begin() {
+		return sequence::iterator(this, _root);
+	}
+
+	///
+	/// \brief C++ Iterator Specification \f$begin()\f$
+	/// \returns An iterator at the smallest element in the sequence
+	///
+	/// \par Complexity
+	/// \f$O(\log N)\f$
+	///
+	constexpr const_iterator begin() const {
+		return sequence::const_iterator(this, _root);
+	}
+
+	///
+	/// \returns An iterator after the largest element in the sequence
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	constexpr iterator end() {
+		return sequence::iterator(this, _root, nullptr);
+	}
+
+	///
+	/// \brief Const C++ Iterator Specification \f$end()\f$
+	/// \returns An iterator after the largest element in the sequence
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	constexpr const_iterator end() const {
+		return sequence::const_iterator(this, _root, nullptr);
+	}
+
+	///
+	/// \brief C++ Iterator Specification \f$iterator\f$
+	class iterator {
+	public:
+
+		///
+		/// \brief prefix increment operator
+		/// \param it the iterator to increment
+		/// \returns \f$it\f$ after having moved to the next element in the list
+		friend iterator& operator++(iterator& it) {
+			if (it._node == nullptr) {
+				return it;
+			}
+
+			node parent = it._seq->_parent(it._node);
+			node pright = it._seq->right(parent);
+			node next   = it._seq->leftmost(it._seq->right(it._node));
+
+			if (it._node != pright && parent != nullptr) {
+				it._visit.push_front(parent);
+			}
+
+			if (next != nullptr) {
+				it._visit.push_front(next);
+			}
+
+			if (not it._visit.is_empty()) {
+				it._node = it._visit.front();
+				it._visit.pop_front();
+			} else {
+				it._node = nullptr;
+			}
+
+			return it;
+		}
+
+		///
+		/// \brief postfix increment operator
+		/// \param it the iterator to increment
+		/// \returns \f$it\f$ before having moved to the next element in the list
+		friend iterator operator++(iterator& it, int) {
+			iterator prev = it;
+			++it;
+			return prev;
+		}
+
+		///
+		/// \brief dereference operator
+		/// \returns a reference to the value pointed by the iterator
+		const value_t& operator*() const {
+			return _node->key;
+		}
+
+		///
+		/// \brief pointer access operator
+		/// \returns a pointer to the value pointed by the iterator
+		const value_t* operator->() const {
+			return &_node->key;
+		}
+
+		///
+		/// \brief iterator equality operator
+		/// \param lhs the iterator
+		/// \param rhs the iterator to compare with
+		/// \returns \f$true\f$ if the iterators are identical, \f$false\f$ otherwise
+		constexpr friend bool operator==(const iterator& lhs, const iterator& rhs) {
+			return lhs._seq == rhs._seq and lhs._node == rhs._node;
+		}
+
+		///
+		/// \brief iterator inequality operator
+		/// \param lhs the iterator
+		/// \param rhs the iterator to compare with
+		/// \returns \f$true\f$ if the iterators are different, \f$false\f$ otherwise
+		constexpr friend bool operator!=(const iterator& lhs, const iterator& rhs) {
+			return lhs._seq != rhs._seq or lhs._node != rhs._node;
+		}
+
+	private:
+		sequence*  _seq;
+		node       _head;
+		node       _node;
+		list<node> _visit;
+
+		constexpr iterator(sequence* seq, node start)
+			: _seq(seq)
+			, _head(start)
+			, _node(seq->leftmost(start)) {
+		}
+
+		constexpr iterator(sequence* seq, node root, node start)
+			: _seq(seq)
+			, _head(root)
+			, _node(start) {
+		}
+
+		friend struct sequence;
+	};
+
+	///
+	/// \brief C++ Iterator Specification \f$iterator\f$
+	class const_iterator {
+	public:
+
+		///
+		/// \brief prefix increment operator
+		/// \param it the iterator to increment
+		/// \returns \f$it\f$ after having moved to the next element in the list
+		friend const_iterator& operator++(const_iterator& it) {
+			if (it._node == nullptr) {
+				return it;
+			}
+
+			node parent = it._seq->_parent(it._node);
+			node pright = it._seq->right(parent);
+			node next   = it._seq->leftmost(it._seq->right(it._node));
+
+			if (it._node != pright && parent != nullptr) {
+				it._visit.push_front(parent);
+			}
+
+			if (next != nullptr) {
+				it._visit.push_front(next);
+			}
+
+			if (not it._visit.is_empty()) {
+				it._node = it._visit.front();
+				it._visit.pop_front();
+			} else {
+				it._node = nullptr;
+			}
+
+			return it;
+		}
+
+		///
+		/// \brief postfix increment operator
+		/// \param it the iterator to increment
+		/// \returns \f$it\f$ before having moved to the next element in the list
+		friend const_iterator operator++(const_iterator& it, int) {
+			const_iterator prev = it;
+			++it;
+			return prev;
+		}
+
+		///
+		/// \brief dereference operator
+		/// \returns a reference to the value pointed by the iterator
+		const value_t& operator*() const {
+			return _node->key;
+		}
+
+		///
+		/// \brief pointer access operator
+		/// \returns a pointer to the value pointed by the iterator
+		const value_t* operator->() const {
+			return &_node->key;
+		}
+
+		///
+		/// \brief iterator equality operator
+		/// \param lhs the iterator
+		/// \param rhs the iterator to compare with
+		/// \returns \f$true\f$ if the iterators are identical, \f$false\f$ otherwise
+		constexpr friend bool operator==(const const_iterator& lhs, const const_iterator& rhs) {
+			return lhs._seq == rhs._seq and lhs._node == rhs._node;
+		}
+
+		///
+		/// \brief iterator inequality operator
+		/// \param lhs the iterator
+		/// \param rhs the iterator to compare with
+		/// \returns \f$true\f$ if the iterators are different, \f$false\f$ otherwise
+		constexpr friend bool operator!=(const const_iterator& lhs, const const_iterator& rhs) {
+			return lhs._seq != rhs._seq or lhs._node != rhs._node;
+		}
+
+	private:
+		const sequence*  _seq;
+		node             _head;
+		node             _node;
+		list<node>       _visit;
+
+		constexpr const_iterator(const sequence* seq, node start)
+			: _seq(seq)
+			, _head(start)
+			, _node(seq->leftmost(start)) {
+		}
+
+		constexpr const_iterator(const sequence* seq, node root, node start)
+			: _seq(seq)
+			, _head(root)
+			, _node(start) {
+		}
+
+		friend struct sequence;
+	};
+
+
+// Private Member Variables ============================================================================================
+private:
+	alloc_t   _alloc;
+	node      _root;
+	compare_t _compare;
+	size_t    _size;
+
+
+// Private Helpers =====================================================================================================
+private:
+
+	template<typename...ArgsT>
+	constexpr node _make_node(ArgsT&&...args) {
+		node res = _alloc.allocate(1);
+		fennec::construct(res, fennec::forward<ArgsT>(args)...);
+		return res;
+	}
+
+	constexpr void _free_node(node n) {
+		fennec::destruct(n);
+		_alloc.deallocate(n);
+	}
+
+	constexpr node _rotate(node sub, bool dir) {
+		if (sub == nullptr) {
+			return nullptr;
+		}
+		node sub_parent = _parent(sub);
+		node new_root   = _child(sub, not dir);
+		node new_child  = _child(new_root, dir);
+
+		_child(sub, not dir) = new_child;
+		if (new_child != nullptr) {
+			_parent(new_child) = sub;
+		}
+		_child(new_root, dir) = sub;
+
+		_parent(new_root) = sub_parent;
+		_parent(sub) = new_root;
+		if (sub_parent != nullptr) {
+			_child(sub_parent, sub == _right(sub_parent)) = new_root;
+		} else {
+			_root = new_root;
+		}
+		return new_root;
+	}
+
+	constexpr void _recolor(node n) {
+		bool c = color(n) == black;
+		if (n == _root) { // Only recolor if not the root node
+			_color(n) = c;
+		}
+		_color(_left(n))  = !_color(_left(n)) ;
+		_color(_right(n)) = !_color(_right(n));
+	}
+
+	// run-of-the-mill bst insert
+	template<typename...ArgsT>
+	constexpr node _insert_bst(ArgsT&&...args) {
+		node res = _make_node(fennec::forward<ArgsT>(args)...);
+
+		if (_root == nullptr) {
+			++_size;
+			_color(res) = black;
+			return _root = res;
+		}
+
+		node i = _root;
+		node p = nullptr;
+		bool d = dir_left;
+		while (i != nullptr) {
+			p = i;
+
+			if (_compare(_key(res), _key(i))) {
+				i = _left(i);
+				d = dir_left;
+			} else if (_compare(_key(i), _key(res))) {
+				i = _right(i);
+				d = dir_right;
+			} else {
+				_free_node(res);
+				return nullptr;
+			}
+		}
+
+		++_size;
+		_child(p, d) = res;
+		_parent(res) = p;
+		return res;
+	}
+
+	// This makes some cheats given that the structure is modified only by internal functions
+	// If such is the case, ONLY LL, LR, RL, and RR will show up
+	// Then we just need to handle splitting a 4-node
+	constexpr void _fix_insert(node n) {
+		if (n == nullptr) {
+			return;
+		}
+
+		node p = _parent(n);
+		while (n != _root && color(n) == red && color(p) == red) {
+			node g = _parent(p);
+			bool d = n == _right(p);
+			bool r = p == _right(g);
+			node u = _child(g, !r);
+
+			if (color(u) == red) {
+				_recolor(g);
+				n = g;
+				p = _parent(n);
+				continue;
+			}
+
+			if (d != r) {
+				_rotate(p, r);
+				n = p;
+				p = _parent(n);
+			}
+
+			_rotate(g, not r);
+			fennec::swap(_color(p), _color(g));
+			n = p;
+			p = _parent(n);
+		}
+		_color(_root) = black;
+	}
+
+	constexpr void _swap_val(node a, node b) {
+		fennec::swap(_key(a), _key(b));
+	}
+
+	constexpr node _red_child(node x) {
+		node l = _left(x);
+		node r = _right(x);
+
+		if (color(l) == red) {
+			return l;
+		}
+
+		if (color(r) == red) {
+			return r;
+		}
+
+		return nullptr;
+	}
+
+	constexpr void _fix_erase(node n) {
+		if (n == nullptr) {
+			return;
+		}
+
+		if (n == _root) {
+			_root = nullptr;
+			return;
+		}
+
+		node o = n;
+		node p = _parent(n);
+		if (p == nullptr) {
+			_root = nullptr;
+			return;
+		}
+
+		bool d = n == _right(p);
+		node c = _red_child(n);
+		node s = nullptr;
+		if (_color(n) == red || c != nullptr) {
+			_child(p, d) = c;
+			if (c != nullptr) {
+				_parent(c) = p;
+			}
+			_color(c) = black;
+			return;
+		}
+
+		while (n != _root) {
+			p = _parent(n);
+			d = n == _right(p);
+			s = _child(p, !d);
+
+			if (s == nullptr) {
+				break;
+			}
+
+			if (_color(s) == red) {
+				_color(s) = black;
+				_color(p) = red;
+				_rotate(p, d);
+				continue;
+			}
+
+			node nc = _child(s, d);
+			node nf = _child(s, !d);
+
+			if (color(nc) == black && color(nf) == black) {
+				_color(s) = red;
+				if (_color(p) == red) {
+					_color(p) = black;
+					break;
+				}
+				n = p;
+				continue;
+			}
+
+			if (color(nf) == black) {
+				_color(nc) = black;
+				_color(s) = red;
+				_rotate(s, !d);
+				s  = nc;
+				nf = s;
+			}
+			_color(s) = _color(p);
+			_color(p) = black;
+			_color(nf) = black;
+			_rotate(p, d);
+			break;
+		}
+
+		p = parent(o);
+		if (p != nullptr) {
+			if (o == _left(p)) {
+				_left(p) = nullptr;
+			} else {
+				_right(p) = nullptr;
+			}
+			_color(_root) = black;
+		} else {
+			_root = nullptr;
+		}
+	}
+
+	constexpr void _erase(node n) {
+		if (n == nullptr) {
+			return;
+		}
+
+		node l = _left(n);
+		node r = _right(n);
+
+		// 2 children
+		if (l != nullptr && r != nullptr) {
+			node s = leftmost(r);
+			_swap_val(n, s);
+			n = s;
+			l = _left(n);
+			r = _right(n);
+		}
+
+		node p = _parent(n);
+		bool d = n == right(p);
+		node c = l != nullptr ? l : r;
+
+		// Single child
+		if (c != nullptr) {
+			_parent(c) = p;
+		}
+
+		// Handles root cases
+		if (p == nullptr) {
+			_root = c;
+			if (c == nullptr) {
+				_free_node(n);
+				--_size;
+				return;
+			} else {
+				_color(c) = black;
+			}
+		}
+
+		// Single Child, Red, and Root cases
+		if (p == nullptr || c != nullptr || _color(n) == red) {
+			if (p != nullptr) {
+				_child(p, d) = c;
+			}
+			_free_node(n);
+			--_size;
+			return;
+		}
+
+		_fix_erase(n);
+		_free_node(n);
+		--_size;
+	}
+};
+
+}
+
+#endif // FENNEC_CONTAINERS_SEQUENCE_H

include/fennec/containers/set.h

@@ -1,6 +1,6 @@
 // =====================================================================================================================
 //  fennec, a free and open source game engine
-//  Copyright © 2025  Medusa Slockbower
+//  Copyright © 2025 - 2026  Medusa Slockbower
 //
 //  This program is free software: you can redistribute it and/or modify
 //  it under the terms of the GNU General Public License as published by
@@ -17,14 +17,14 @@
 // =====================================================================================================================
 
 ///
-/// \file set.h
+/// \file fennec/containers/set.h
 /// \brief A header containing the definition for a set of unique values
 ///
 ///
 /// \details
 /// \author Medusa Slockbower
 ///
-/// \copyright Copyright © 2025 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
+/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
 ///
 ///
 
@@ -49,43 +49,58 @@ namespace fennec
 /// \details
 /// This data-structure behaves like a set, but does not use pointers, instead storing the table in-array
 ///
-/// | Property   | Value      |
+/// | Property    | Value      |
-/// |:----------:|:----------:|
+/// |:-----------:|:----------:|
-/// | stable     |      ⛔     |
+/// | stable      |     ⛔     |
-/// | dynamic    |      ✅     |
+/// | dynamic     |     ✅     |
-/// | homogenous |      ✅     |
+/// | homogeneous |     ✅     |
-/// | distinct   |      ✅     |
+/// | distinct    |     ✅     |
-/// | ordered    |      ⛔     |
+/// | ordered     |     ⛔     |
-/// | space      | \f$O(N)\f$ |
+/// | space       | \f$O(N)\f$ |
-/// | linear     |      ✅     |
+/// | linear      |     ✅     |
-/// | access     | \f$O(1)\f$ |
+/// | access      | \f$O(1)\f$ |
-/// | find       | \f$O(1)\f$ |
+/// | find        | \f$O(1)\f$ |
-/// | insertion  | \f$O(1)\f$ |
+/// | insertion   | \f$O(1)\f$ |
-/// | deletion   | \f$O(1)\f$ |
+/// | deletion    | \f$O(1)\f$ |
+/// | space       | \f$O(N)\f$ |
 ///
 /// \tparam TypeT The type to contain
 template<typename TypeT, class Hash = hash<TypeT>, class Equals = equality<TypeT>, class Alloc = allocator<TypeT>>
 struct set {
 
 // Definitions =========================================================================================================
+private:
+	struct node;
+
 public:
-	using alloc_t = typename allocator_traits<Alloc>::template rebind<TypeT>;
+
-	using hash_t = Hash;
+	/// \name Definitions
-	using equal_t = Equals;
+	/// @{
-	using elem_t = TypeT;
+
+	using alloc_t = typename allocator_traits<Alloc>::template rebind<node>; //!< the allocator type
+
+	using hash_t = Hash;    //!< the hash type
+	using equal_t = Equals; //!< the equality type
+	using elem_t = TypeT;   //!< the element type
+
+	/// @}
+
+
+	/// \name Constants
+	/// @{
+
+	static constexpr double default_load = 0.8; //!< the default load factor for reallocation
+
+	/// @}
+
 
 	class iterator;
-	static constexpr size_t npos = -1;
-	static constexpr double default_load = 0.8;
 
 private:
-	struct node {
+	static constexpr size_t npos = -1;
-		optional<elem_t> value;
+
-		int psl;
+	using table_t = dynarray<node, alloc_t>;
 
-		constexpr node() = default;
-		constexpr ~node() = default;
-	};
 
 // Constructors ========================================================================================================
 public:
@@ -95,8 +110,12 @@ public:
 
 	///
 	/// \brief Default Constructor, initializes empty set
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr set()
-		: _alloc()
+		: _table()
 		, _hash()
 		, _size(0)
 		, _sumpsl(0)
@@ -106,8 +125,12 @@ public:
 	///
 	/// \brief Hash Copy Constructor, initializes empty set with a hash
 	/// \param hash the hash object
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr set(const hash_t& hash)
-		: _alloc()
+		: _table()
 		, _hash(hash)
 		, _size(0)
 		, _sumpsl(0)
@@ -117,8 +140,12 @@ public:
 	///
 	/// \brief Alloc Copy Constructor, initializes empty set with an allocator
 	/// \param alloc the allocator object
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
+	///
 	constexpr set(const alloc_t& alloc)
-		: _alloc(alloc)
+		: _table(alloc)
 		, _hash()
 		, _size(0)
 		, _sumpsl(0)
@@ -129,8 +156,12 @@ public:
 	/// \brief Hash Alloc Copy Constructor, initializes empty set with a hash and allocator
 	/// \param hash the hash object
 	/// \param alloc the allocator object
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr set(const hash_t& hash, const alloc_t& alloc)
-		: _alloc(alloc)
+		: _table(alloc)
 		, _hash(hash)
 		, _size(0)
 		, _sumpsl(0)
@@ -140,8 +171,12 @@ public:
 	///
 	/// \brief Set Copy Constructor
 	/// \param set Set to copy
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr set(const set& set)
-		: _alloc(set._alloc)
+		: _table(set._table)
 		, _hash(set._hash)
 		, _size(set._size)
 		, _sumpsl(set._sumpsl)
@@ -151,8 +186,12 @@ public:
 	///
 	/// \brief Set Move Constructor
 	/// \param set Set to move
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr set(set&& set) noexcept
-		: _alloc(fennec::move(set._alloc))
+		: _table(fennec::move(set._table))
 		, _hash(fennec::move(set._hash))
 		, _size(fennec::move(set._size))
 		, _sumpsl(set._sumpsl)
@@ -161,9 +200,13 @@ public:
 
 	///
 	/// \brief Destructor, destructs all elements and releases the allocation
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
+	///
 	constexpr ~set() {
 		for (size_t i = 0; i < capacity(); ++i) {
-			_alloc[i].value = nullopt;
+			_table[i].value = nullopt;
 		}
 	}
 
@@ -177,20 +220,32 @@ public:
 
 	///
 	/// \returns Size of the set in elements
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr size_t size() const {
 		return _size;
 	}
 
 	///
-	/// \returns `true` when the set is empty, `false` otherwise
+	/// \returns \f$true\f$ when the set is empty, \f$false\f$ otherwise
-	constexpr bool empty() const {
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	constexpr bool is_empty() const {
 		return _size == 0;
 	}
 
 	///
 	/// \returns Capacity of the set in elements
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr size_t capacity() const {
-		return _alloc.size();
+		return _table.size();
 	}
 
 	/// @}
@@ -205,6 +260,10 @@ public:
 	/// \brief Find an Element
 	/// \param val Value to find
 	/// \returns An iterator at the location of the value
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr iterator find(const elem_t& val) const {
 		if (capacity() == 0) {
 			return end();
@@ -215,8 +274,8 @@ public:
 		size_t n = 0;
 
 		// Check the first element;
-		if (_alloc[i].psl >= psl && _alloc[i].value) {
+		if (_table[i].psl >= psl && _table[i].value) {
-			if (_equal(*_alloc[i].value, val)) {
+			if (_equal(*_table[i].value, val)) {
 				return iterator(this, i);
 			}
 		}
@@ -227,16 +286,16 @@ public:
 			size_t i0 = (i + capacity() - n) % capacity(); // Prevent index underflow
 			size_t i1 = (i + n) % capacity();
 			int    p0 = psl - n, p1 = psl + n;
-			bool   c0  = p0 >= 0 && _alloc[i0].psl >= p0, c1 = _alloc[i1].psl >= p1; // Check that we are in range
+			bool   c0  = p0 >= 0 && _table[i0].psl >= p0, c1 = _table[i1].psl >= p1; // Check that we are in range
 
-			if (c0 && _alloc[i0].value) {
+			if (c0 && _table[i0].value) {
-				if (_equal(*_alloc[i0].value, val)) {
+				if (_equal(*_table[i0].value, val)) {
 					return iterator(this, i0);
 				}
 			}
 
-			if (c1 && _alloc[i1].value) {
+			if (c1 && _table[i1].value) {
-				if (_equal(*_alloc[i1].value, val)) {
+				if (_equal(*_table[i1].value, val)) {
 					return iterator(this, i1);
 				}
 			}
@@ -252,7 +311,11 @@ public:
 	///
 	/// \brief Check if a set contains a value
 	/// \param val Value to check
-	/// \returns `true` if `val` can be found, `false` otherwise
+	/// \returns \f$true\f$ if \f$val\f$ can be found, \f$false\f$ otherwise
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr bool contains(const elem_t& val) const {
 		return this->find(val) != end();
 	}
@@ -260,25 +323,33 @@ public:
 	///
 	/// \brief Iterator Access
 	/// \param it Location to access
-	/// \returns A pointer to the element, `nullptr` if not found.
+	/// \returns A pointer to the element, \f$nullptr\f$ if not found.
 	///          The value should not be changed in a manner that will change the hash of the element.
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr elem_t* at(const iterator& it) {
 		if (it == end()) {
 			return nullptr;
 		}
-		if (not _alloc[it._i].value) {
+		if (not _table[it._i].value) {
 			return nullptr;
 		}
-		return &*_alloc[it._i].value;
+		return &*_table[it._i].value;
 	}
 
 	///
 	/// \brief Iterator Const Access
 	/// \param it Location to access
-	/// \returns A const-qualified pointer to the element, `nullptr` if not found.
+	/// \returns A const-qualified pointer to the element, \f$nullptr\f$ if not found.
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr const elem_t* at(const iterator& it) const {
-		if (not _alloc[it._i].value) return nullptr;
+		if (not _table[it._i].value) return nullptr;
-		return &*_alloc[it._i].value;
+		return &*_table[it._i].value;
 	}
 
 	/// @}
@@ -291,6 +362,11 @@ public:
 	///
 	/// \brief Move Insertion
 	/// \param val Value to insert
+	/// \returns An iterator at the held value
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr iterator insert(elem_t&& val) {
 		return this->_insert(fennec::forward<elem_t>(val));
 	}
@@ -298,6 +374,11 @@ public:
 	///
 	/// \brief Copy Insertion
 	/// \param val Value to insert
+	/// \returns An iterator at the held value
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr iterator insert(const elem_t& val) {
 		return this->_insert(val);
 	}
@@ -306,6 +387,11 @@ public:
 	/// \brief Emplace Insertion
 	/// \tparam ArgsT Argument types
 	/// \param args Arguments to construct with
+	/// \returns An iterator at the held value
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	template<typename...ArgsT>
 	constexpr iterator emplace(ArgsT&&...args) {
 		return this->_insert(fennec::forward<ArgsT>(args)...);
@@ -314,24 +400,28 @@ public:
 	///
 	/// \brief Element Erase
 	/// \param it Location to erase
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr void erase(iterator it) {
 		size_t i = it._i;
 		if (i >= capacity()) {
 			return;
 		} // These are separated due to compilers being inconsistent
-		if (not _alloc[i].value) {
+		if (not _table[i].value) {
 			return;
 		}
 
-		_alloc[i].value = nullopt;
+		_table[i].value = nullopt;
-		_sumpsl -= _alloc[i].psl;
+		_sumpsl -= _table[i].psl;
 		--_size;
 		size_t p = i;
-		while (_alloc[i = (i + 1) % capacity()].value) {
+		while (_table[i = (i + 1) % capacity()].value) {
-			if (_alloc[i].psl == 0) break;
+			if (_table[i].psl == 0) break;
 
-			fennec::swap(_alloc[i - 1].value, _alloc[i].value);
+			fennec::swap(_table[p].value, _table[i].value);
-			--_alloc[p].psl, --_sumpsl;
+			--_table[p].psl, --_sumpsl;
 			p = i;
 		}
 	}
@@ -339,16 +429,22 @@ public:
 	///
 	/// \brief Element Erase
 	/// \param val Value to erase
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr void erase(const elem_t& val) {
 		this->erase(this->find(val));
 	}
 
 	///
-	/// \brief
+	/// \brief Clear all elements from the set, destructing them
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
+	///
 	constexpr void clear() {
-		for (size_t i = 0; i < _alloc.capacity(); ++i) {
+		_table.clear();
-
-		}
 	}
 
 	/// @}
@@ -360,17 +456,27 @@ public:
 	/// @{
 
 	///
+	/// \brief C++ Iterator Specification \f$begin()\f$
 	/// \returns An iterator for all elements of the set in no particular order
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr iterator begin() const {
 		iterator it(this, 0);
-		if (not _alloc[it._i].value) {
+		while (not _table[it._i].value) {
 			++it;
 		}
 		return it;
 	}
 
 	///
+	/// \brief C++ Iterator Specification \f$end()\f$
 	/// \returns An iterator representing the end of the set
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	constexpr iterator end() const {
 		return iterator(this, npos);
 	}
@@ -378,79 +484,114 @@ public:
 	/// @}
 
 	///
-	/// \brief Class for Iterating the Set
+	/// \brief C++ Iterator Specification \f$iterator\f$
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
 	class iterator {
 	public:
+		///
+		/// \brief destructor
+		constexpr ~iterator() {
+			_set = nullptr;
+		}
+
+		///
+		/// \brief prefix increment operator
+		/// \param it the iterator to increment
+		/// \returns \f$it\f$ after having moved to the next element in the list
+		constexpr friend iterator& operator++(iterator& it) {
+			while (++it._i < it._set->capacity()) {
+				if (it._set->_table[it._i].value) {
+					return it;
+				}
+			}
+			it._i = npos;
+			return it;
+		}
+
+		///
+		/// \brief postfix increment operator
+		/// \param it the iterator to increment
+		/// \returns \f$it\f$ before having moved to the next element in the list
+		constexpr friend iterator operator++(iterator& it, int) {
+			iterator prev = it;
+			++it;
+			return prev;
+		}
+
+		///
+		/// \brief dereference operator
+		/// \returns a reference to the value pointed by the iterator
+		constexpr const elem_t& operator*() const {
+			return *_set->_table[_i].value;
+		}
+
+		///
+		/// \brief pointer access operator
+		/// \returns a pointer to the value pointed by the iterator
+		constexpr const elem_t* operator->() const {
+			if (not _set->_table[_i].value) return nullptr;
+			return &*_set->_table[_i].value;
+		}
+
+		///
+		/// \brief iterator equality operator
+		/// \param it the iterator to compare with
+		/// \returns \f$true\f$ if the iterators are identical, \f$false\f$ otherwise
+		constexpr bool operator==(const iterator& it) const {
+			return _set == it._set and _i == it._i;
+		}
+
+		///
+		/// \brief iterator inequality operator
+		/// \param it the iterator to compare with
+		/// \returns \f$true\f$ if the iterators are different, \f$false\f$ otherwise
+		constexpr bool operator!=(const iterator& it) const {
+			return _set != it._set or _i != it._i;
+		}
+
+	private:
+		const set* _set;
+		size_t _i;
+
 		constexpr iterator(const set* set, size_t i)
 			: _set(set)
 			, _i(i) {
 		}
 
-		constexpr ~iterator() {
-			_set = nullptr;
-		}
-
-		// prefix operator
-		constexpr friend iterator& operator++(iterator& rhs) {
-			while (++rhs._i < rhs._set->capacity()) {
-				if (rhs._set->_alloc[rhs._i].value) {
-					return rhs;
-				}
-			}
-			rhs._i = npos;
-			return rhs;
-		}
-
-		constexpr friend iterator operator++(iterator& lhs, int) {
-			iterator prev = lhs;
-			++lhs;
-			return prev;
-		}
-
-		constexpr const elem_t& operator*() const {
-			return *_set->_alloc[_i].value;
-		}
-
-		constexpr const elem_t* operator->() const {
-			if (not _set->_alloc[_i].value) return nullptr;
-			return &*_set->_alloc[_i].value;
-		}
-
-		constexpr bool operator==(const iterator& it) const {
-			return _set == it._set and _i == it._i;
-		}
-
-		constexpr bool operator!=(const iterator& it) const {
-			return _set != it._set or _i != it._i;
-		}
-
-		constexpr size_t index() const { return _i; }
-
-	private:
-		const set* _set;
-		size_t _i;
 		friend set;
 	};
 
 
-// PRIVATE =============================================================================================================
+// Private Member Variables ============================================================================================
+private:
+	table_t _table;
+	hash_t  _hash;
+	equal_t _equal;
+	size_t  _size;
+	size_t  _sumpsl;
+	float   _load;
 
+
+// Private Helpers =====================================================================================================
 private:
 	constexpr void _expand() {
 		set cpy; // Create a new set
-		cpy._alloc.resize(
+		cpy._table.resize(
-			fennec::next_prime2(_alloc.capacity())
+			fennec::next_prime2(_table.capacity())
 		);
 
 		// rehash
 		for (size_t i = 0; i < capacity(); ++i) {
-			if (_alloc[i].value) {
+			if (_table[i].value) {
-				cpy.insert(fennec::move(*_alloc[i].value));
+				cpy.insert(fennec::move(*_table[i].value));
 			}
 		}
 
 		// Swap buffers
-		fennec::swap(_alloc, cpy._alloc);
+		fennec::swap(_table, cpy._table);
 	}
 
 	template<typename...ArgsT>
@@ -462,29 +603,33 @@ private:
 		elem_t value(fennec::forward<ArgsT>(args)...);
 		size_t i = _hash(value) % capacity(); // Initial search index
 		int psl = 0;
-		while (_alloc[i].value) { // Search for empty cell
+		while (_table[i].value) { // Search for empty cell
-			if (_equal(*_alloc[i].value, value)) { // Check to see if this element is already inserted
+			if (_equal(*_table[i].value, value)) { // Check to see if this element is already inserted
 				return iterator(this, i);
 			}
-			if (psl > _alloc[i].psl) { // When psl is higher, swap
+			if (psl > _table[i].psl) { // When psl is higher, swap
-				_sumpsl += psl - _alloc[i].psl;
+				_sumpsl += psl - _table[i].psl;
-				fennec::swap(_alloc[i].psl, psl);
+				fennec::swap(_table[i].psl, psl);
-				fennec::swap(*_alloc[i].value, value);
+				fennec::swap(*_table[i].value, value);
 			}
 			i = (i + 1) % capacity(); ++psl;
 		}
-		_alloc[i].value = fennec::move(value);
+		_table[i].value = fennec::move(value);
-		_sumpsl += (_alloc[i].psl = psl);
+		_sumpsl += (_table[i].psl = psl);
 		++_size;
 		return iterator(this, npos);
 	}
 
-	dynarray<node, alloc_t> _alloc;
+
-	hash_t  _hash;
+// Private Definitions =================================================================================================
-	equal_t _equal;
+private:
-	size_t  _size;
+	struct node {
-	size_t  _sumpsl;
+		optional<elem_t> value;
-	float   _load;
+		int psl;
+
+		constexpr node() = default;
+		constexpr ~node() = default;
+	};
 };
 
 }

include/fennec/containers/traversal.h

@@ -1,6 +1,6 @@
 // =====================================================================================================================
 //  fennec, a free and open source game engine
-//  Copyright © 2025  Medusa Slockbower
+//  Copyright © 2025 - 2026  Medusa Slockbower
 //
 //  This program is free software: you can redistribute it and/or modify
 //  it under the terms of the GNU General Public License as published by
@@ -17,14 +17,14 @@
 // =====================================================================================================================
 
 ///
-/// \file traversal.h
+/// \file fennec/containers/traversal.h
 /// \brief a header containing constants and utilities related to traversal
 ///
 ///
 /// \details
 /// \author Medusa Slockbower
 ///
-/// \copyright Copyright © 2025 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
+/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
 ///
 ///
 
@@ -37,9 +37,9 @@ namespace fennec
 ///
 /// \brief A set of constants used in the traverser-visitor pattern
 enum traversal_control_ {
-	traversal_control_continue  = 0,
+	traversal_control_continue  = 0, //!< Continue to the next element
-	traversal_control_break     = 1,
+	traversal_control_break     = 1, //!< Break the traversal loop
-	traversal_control_jump_over = 2,
+	traversal_control_jump_over = 2, //!< Jump over the next element
 };
 
 }

include/fennec/containers/tuple.h

@@ -1,6 +1,6 @@
 // =====================================================================================================================
 //  fennec, a free and open source game engine
-//  Copyright © 2025  Medusa Slockbower
+//  Copyright © 2025 - 2026  Medusa Slockbower
 //
 //  This program is free software: you can redistribute it and/or modify
 //  it under the terms of the GNU General Public License as published by
@@ -17,14 +17,14 @@
 // =====================================================================================================================
 
 ///
-/// \file tuple.h
+/// \file fennec/containers/tuple.h
 /// \brief A header containing the definition for a container with multiple values of differing types
 ///
 ///
 /// \details
 /// \author Medusa Slockbower
 ///
-/// \copyright Copyright © 2025 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
+/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
 ///
 ///
 
@@ -42,24 +42,30 @@ namespace fennec
 ///
 /// \brief Tuple, holds a collection of values of different types
 /// \details
-/// | Property   | Value      |
+/// | Property    | Value      |
-/// |:----------:|:----------:|
+/// |:-----------:|:----------:|
-/// | stable     |      ⛔     |
+/// | stable      |     ⛔     |
-/// | dynamic    |      ✅     |
+/// | dynamic     |     ✅     |
-/// | homogenous |      ⛔     |
+/// | homogeneous |     ⛔     |
-/// | distinct   |      ⛔     |
+/// | distinct    |     ⛔     |
-/// | ordered    |      ⛔     |
+/// | ordered     |     ⛔     |
-/// | space      | \f$O(N)\f$ |
+/// | space       | \f$O(N)\f$ |
-/// | linear     |      ✅     |
+/// | linear      |     ✅     |
-/// | access     | \f$O(1)\f$ |
+/// | access      | \f$O(1)\f$ |
-/// | find       | \f$O(1)\f$ |
+/// | find        | \f$O(1)\f$ |
-/// | insertion  |      ⛔     |
+/// | insertion   |     ⛔     |
-/// | deletion   |      ⛔     |
+/// | deletion    |     ⛔     |
+/// | space       | \f$O(N)\f$ |
 ///
 /// \tparam TypesT The types to store
 template<typename...TypesT> struct tuple;
 
-
+///
+/// \brief tuple get
+/// \tparam i the index
+/// \tparam TypesT the types held in the tuple
+/// \param x the tuple
+/// \returns the \f$i\f$th element of the tuple
 template<size_t i, typename...TypesT>
 constexpr typename tuple<TypesT...>::template elem_t<i>& get(tuple<TypesT...>& x) {
 	using elem_t = typename tuple<TypesT...>::template elem_t<i>;
@@ -67,6 +73,11 @@ constexpr typename tuple<TypesT...>::template elem_t<i>& get(tuple<TypesT...>& x
 	return it.value;
 }
 
+///
+/// \tparam i the index
+/// \tparam TypesT the types held in the tuple
+/// \param x the tuple
+/// \returns the \f$i\f$th element of the tuple
 template<size_t i, typename...TypesT>
 constexpr const typename tuple<TypesT...>::template elem_t<i>& get(const tuple<TypesT...>& x) {
 	using elem_t = typename tuple<TypesT...>::template elem_t<i>;
@@ -76,28 +87,67 @@ constexpr const typename tuple<TypesT...>::template elem_t<i>& get(const tuple<T
 
 
 template<typename ...TypesT>
-struct tuple : public detail::_tuple<make_index_sequence_t<sizeof...(TypesT)>, TypesT...>
+struct tuple : public detail::_tuple<make_index_metasequence_t<sizeof...(TypesT)>, TypesT...> {
-{
+
-	using base_t = detail::_tuple<make_index_sequence_t<sizeof...(TypesT)>, TypesT...>;
+// Definitions =========================================================================================================
+public:
+
+	/// \name Definitions
+	/// @{
+
+	using base_t = detail::_tuple<make_index_metasequence_t<sizeof...(TypesT)>, TypesT...>; //!< the base type
 
 	template<size_t i>
-	using elem_t = typename nth_element<i, TypesT...>::type;
+	using elem_t = typename nth_element<i, TypesT...>::type; //!< helper for getting the \f$i\f$th element
 
+	static constexpr size_t size = sizeof...(TypesT); //!< the number of elements held by the tuple
+
+	/// @}
+
+
+// Constructors & Destructor ===========================================================================================
+public:
+
+	///
+	/// \brief tuple constructor
+	/// \tparam ArgsT The element types
+	/// \param args The arguments to initialize the tuple with
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
+	///
 	template<typename...ArgsT>
     tuple(ArgsT&&...args)
 		: base_t(fennec::forward<ArgsT>(args)...) {
     }
 
+	///
+	/// \brief copy constructor
+	/// \param cpy the tuple to copy
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
+	///
 	tuple(const tuple& cpy)
 		: base_t(cpy) {
 	}
 
-	tuple(tuple&& cpy)
+	///
-		: base_t(cpy) {
+	/// \brief move constructor
+	/// \param mov the tuple to move
+	///
+	/// \par Complexity
+	/// \f$O(N)\f$
+	///
+	tuple(tuple&& mov)
+		: base_t(fennec::forward<tuple>(mov)) {
 	}
 };
 
-// This is needed for
+///
+/// \brief Helper for deducing the tuple constructor
+/// \tparam TypesT the types of the tuple
+/// \returns A new tuple containing the passed values
 template<typename...TypesT>
 tuple(TypesT...) -> tuple<TypesT...>;
 

include/fennec/containers/variant.h

@@ -1,6 +1,6 @@
 // =====================================================================================================================
 //  fennec, a free and open source game engine
-//  Copyright © 2025  Medusa Slockbower
+//  Copyright © 2025 - 2026  Medusa Slockbower
 //
 //  This program is free software: you can redistribute it and/or modify
 //  it under the terms of the GNU General Public License as published by
@@ -17,18 +17,369 @@
 // =====================================================================================================================
 
 ///
-/// \file variant.h
+/// \file fennec/containers/variant.h
 /// \brief Contains the definition for a structure that holds a single value from multiple types
 ///
 ///
 /// \details
 /// \author Medusa Slockbower
 ///
-/// \copyright Copyright © 2025 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
+/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
 ///
 ///
 
 #ifndef FENNEC_CONTAINERS_VARIANT_H
 #define FENNEC_CONTAINERS_VARIANT_H
 
+#include <fennec/containers/optional.h>
+#include <fennec/lang/type_sequences.h>
+#include <fennec/math/ext/common.h>
+#include <fennec/rtti/type.h>
+
+namespace fennec
+{
+
+///
+/// \brief A structure that represents a union between \f$TypesT\ldots\f$
+/// \details
+/// | Property    | Value      |
+/// |:-----------:|:----------:|
+/// | stable      |     ✅     |
+/// | dynamic     |     ⛔     |
+/// | homogeneous |     ⛔     |
+/// | distinct    |     ⛔     |
+/// | ordered     |     ⛔     |
+/// | space       | \f$O(N)\f$ |
+/// | linear      |     ⛔     |
+/// | access      | \f$O(1)\f$ |
+/// | find        |     ⛔     |
+/// | insertion   | \f$O(1)\f$ |
+/// | deletion    | \f$O(1)\f$ |
+/// | space       | \f$O(1)\f$ |
+///
+/// \tparam TypesT The types to hold in the variant
+template<typename...TypesT>
+struct variant {
+// Assertions ==========================================================================================================
+public:
+
+	static_assert(
+		     is_unique_v<TypesT...>         and // No two types in TypesT... may be equivalent
+		not (is_reference_v<TypesT> or ...) and // No type in TypesT... may be a reference
+		not (is_array_v<TypesT> or ...)     and // No type in TypesT... may be an array
+		not (is_void_v<TypesT> or ...)          // No type in TypesT... may be void
+	);
+
+
+// Definitions & Constants =============================================================================================
+public:
+
+	/// \name Constants
+	/// @{
+
+	static constexpr size_t size = max_element_size_v<TypesT...>; //!< size of the variant in bytes
+	static constexpr size_t nulltype = sizeof...(TypesT);         //!< id for a null type
+
+	/// @}
+
+
+// Constructors ========================================================================================================
+public:
+
+	/// \name Constructors & Destructor
+	/// @{
+
+	///
+	/// \brief Default Constructor, constructs the first type in \f$TypesT\ldots\f$ that is default constructible
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	variant()
+		: _bytes {}
+		, _handle(&_bytes)
+		, _type(nulltype) {
+		using construct_t = search_element_t<is_default_constructible, TypesT...>;
+		this->_construct<construct_t>();
+	}
+
+	///
+	/// \brief Conversion Constructor, constructs the type in \f$TypesT\ldots\f$ that is identical to \f$T\f$
+	///        or the first that is constructible with \f$T\f$
+	/// \tparam T The type of the value
+	/// \param t The value to forward
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	template<typename T>
+	variant(T&& t)
+		: _bytes {}
+		, _handle(&_bytes)
+		, _type() {
+		using same_t = search_element_args<is_same, type_sequence<T>, TypesT...>::type;
+		using convert_t = search_element_args<is_constructible, type_sequence<T>, TypesT...>::type;
+		using construct_t = conditional_t<is_void_v<same_t>, convert_t, same_t>;
+		this->_construct<construct_t>(fennec::forward<T>(t));
+	}
+
+	///
+	/// \brief Emplace Constructor, constructs a type \f$T\f$ that is in \f$TypesT\ldots\f$ that is constructible with \f$ArgsT\ldots\f$
+	/// \tparam ArgsT The arguments of the constructor
+	/// \param args The argument values
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	template<typename T, typename...ArgsT>
+	variant(type_identity<T>, ArgsT&&...args)
+		: _bytes{}
+		, _handle(&_bytes)
+		, _type(nulltype) {
+		static_assert(contains_element_v<T, TypesT...>, "T must be in TypesT...");
+		this->_construct<T>(fennec::forward<ArgsT>(args)...);
+		_type = find_element_v<T>;
+	}
+
+	///
+	/// \brief Copy Constructor
+	/// \param v The variant to copy
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	variant(const variant& v)
+		: _bytes {}
+		, _handle(&_bytes)
+		, _type(nulltype) {
+
+		if (v._type == nulltype) {
+			return;
+		}
+
+		((v._type == find_element_v<TypesT, TypesT...> ?
+			this->_construct<TypesT>(v.get<TypesT>()) :
+			((void)0)
+		), ...);
+		_type = v._type;
+	}
+
+	///
+	/// \brief Move Constructor
+	/// \param v The variant to move
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	variant(variant&& v) noexcept
+		: _bytes {}
+		, _handle(&_bytes)
+		, _type() {
+
+		if (v._type == nulltype) {
+			return;
+		}
+
+		((v._type == find_element_v<TypesT, TypesT...> ?
+			this->_construct<TypesT>(fennec::move(v.get<TypesT>())) :
+			((void)0)
+		), ...);
+		_type = v._type;
+	}
+
+	///
+	/// \brief Destructor, if a type is held, destruct it.
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	~variant() {
+		_clear();
+	}
+
+	/// @}
+
+
+// Assignment ==========================================================================================================
+public:
+
+	/// \name Assignment
+	/// @{
+
+
+	///
+	/// \brief value assignment operator
+	/// \tparam T The type to assign
+	/// \param t the value to assign
+	/// \returns a reference to \f$self\f$ after assigning \f$t\f$
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	template<typename T>
+	variant& operator=(T&& t) {
+
+		// First, check if T is in TypesT...
+		if constexpr((contains_element_v<T, TypesT> or ...)) {
+			using type_t = remove_reference_t<T>;
+			if (_type == find_element_v<type_t, TypesT...>) {
+				*_get<type_t>() = fennec::forward<T>(t);
+			} else {
+				_clear();
+				this->_construct<type_t>(fennec::forward<T>(t));
+				_type = find_element_v<type_t, TypesT...>;
+			}
+			return *this;
+		}
+
+		// Next, try to assign using the currently held type
+		bool assigned = false;
+		if (_type != nulltype) {
+			((_type == find_element_v<TypesT, TypesT...> ?
+				(*_get<TypesT>() = fennec::forward<T>(t), assigned = true) :
+				((void)0)
+			), ...);
+		}
+
+		if (assigned) {
+			return *this;
+		}
+
+		// Otherwise, destruct, then construct
+		_clear();
+		using construct_t = search_element_args<is_constructible, type_sequence<T>, TypesT...>;
+		this->_construct<construct_t>(fennec::forward<T>(t));
+		return *this;
+	}
+
+	///
+	/// \brief emplace function
+	/// \tparam T The type to construct
+	/// \tparam ArgsT the argument types
+	/// \param args the argument values
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	template<typename T, typename...ArgsT> requires(contains_element_v<T, TypesT...>)
+	void emplace(ArgsT&&...args) {
+		_clear();
+		this->_construct<T>(fennec::forward<ArgsT>(args)...);
+	}
+
+	///
+	/// \brief deduced emplace function
+	/// \tparam ArgsT the argument types
+	/// \param args the argument values
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	template<size_t I, typename...ArgsT>
+	void emplace(ArgsT&&...args) {
+		using type_t = nth_element_t<I, TypesT...>;
+		_clear();
+		this->_construct<type_t>(fennec::forward<ArgsT>(args)...);
+	}
+
+	/// @}
+
+
+// Access ==============================================================================================================
+
+	/// \name Access
+	/// @{
+
+	///
+	/// \brief get the value of the variant interpreted as \f$T\f$
+	/// \tparam T the type to interpret as
+	/// \returns The value interpreted as \f$T\f$
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	template<typename T> requires(contains_element_v<T, TypesT...>)
+	T& get() {
+		return *_get<T>();
+	}
+
+	///
+	/// \tparam T the type to interpret as
+	/// \returns The value interpreted as \f$T\f$
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	template<typename T> requires(contains_element_v<T, TypesT...>)
+	const T& get() const {
+		return *_get<T>();
+	}
+
+	///
+	/// \tparam T the type to interpret as
+	/// \returns The value interpreted as \f$T\f$
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	template<size_t I, typename T = nth_element_t<I, TypesT...>> requires(contains_element_v<T, TypesT...>)
+	T& get() {
+		return *_get<T>();
+	}
+
+	///
+	/// \tparam T the type to interpret as
+	/// \returns The value interpreted as \f$T\f$
+	///
+	/// \par Complexity
+	/// \f$O(1)\f$
+	///
+	template<size_t I, typename T = nth_element_t<I, TypesT...>> requires(contains_element_v<T, TypesT...>)
+	const T& get() const {
+		return *_get<T>();
+	}
+
+	/// @}
+
+
+// Private Member Variables ============================================================================================
+private:
+	byte_t _bytes[size];
+	void*  _handle;
+	size_t _type;
+
+
+// Private Helpers =====================================================================================================
+private:
+
+	template<typename T>
+	T* _get() const {
+		return static_cast<T*>(_handle);
+	}
+
+	void _clear() {
+		if (_type == nulltype) {
+			return;
+		}
+
+		((_type == find_element_v<TypesT, TypesT...> ?
+			this->_destruct<TypesT>() :
+			((void)0)
+		), ...);
+		_type = nulltype;
+	}
+
+	template<typename ConstructT, typename...ArgsT>
+	void _construct(ArgsT&&...args) {
+		fennec::construct<ConstructT>(_get<ConstructT>(), fennec::forward<ArgsT>(args)...);
+	}
+
+	template<typename DestructT>
+	void _destruct() {
+		fennec::destruct(_get<DestructT>());
+	}
+};
+
+}
+
 #endif // FENNEC_CONTAINERS_VARIANT_H

include/fennec/core/engine.h

@@ -1,6 +1,6 @@
 // =====================================================================================================================
 //  fennec, a free and open source game engine
-//  Copyright © 2025  Medusa Slockbower
+//  Copyright © 2025 - 2026  Medusa Slockbower
 //
 //  This program is free software: you can redistribute it and/or modify
 //  it under the terms of the GNU General Public License as published by
@@ -17,14 +17,14 @@
 // =====================================================================================================================
 
 ///
-/// \file engine.h
+/// \file fennec/core/engine.h
 /// \brief fennec::engine definition
 ///
 ///
 /// \details
 /// \author Medusa Slockbower
 ///
-/// \copyright Copyright © 2025 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
+/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
 ///
 ///
 
@@ -49,7 +49,7 @@
 ///   2. \ref fennec_memory "Memory Management Library"
 ///   2. \ref fennec_containers "Containers Library"
 ///
-/// \copyright Copyright © 2025 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
+/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
 ///
 
 ///
@@ -63,10 +63,21 @@
 ///  | \subpage fennec_containers | Implementation of common data structures, those that are specified in the C++ STD Library, and custom data structures that fennec uses.                                                                                               |
 ///
 ///
-/// \copyright Copyright © 2025 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
+/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
 ///
 
 #ifndef FENNEC_CORE_ENGINE_H
 #define FENNEC_CORE_ENGINE_H
 
+namespace fennec
+{
+
+class engine {
+public:
+
+private:
+};
+
+}
+
 #endif // FENNEC_CORE_ENGINE_H

include/fennec/core/event.h

@@ -1,6 +1,6 @@
 // =====================================================================================================================
 //  fennec, a free and open source game engine
-//  Copyright © 2025  Medusa Slockbower
+//  Copyright © 2025 - 2026  Medusa Slockbower
 //
 //  This program is free software: you can redistribute it and/or modify
 //  it under the terms of the GNU General Public License as published by
@@ -20,40 +20,148 @@
 #define FENNEC_CORE_EVENT_H
 
 #include <fennec/lang/types.h>
-#include <fennec/lang/typeuuid.h>
+#include <fennec/rtti/enable.h>
+
+#include <fennec/rtti/typeid.h>
 
 namespace fennec
 {
 
 struct event;
 
+///
+/// \brief Class outlining the interface for an object that listens for events
 class event_listener {
+// Constructors & Destructor ===========================================================================================
 public:
-	virtual ~event_listener() = default;
+
+	/// \name Constructors & Destructor
+	/// @{
+
+	///
+	/// \brief Virtual Destructor
+	virtual ~event_listener();
+
+	/// @}
+
+
+// Event Handling ======================================================================================================
+public:
+
+	/// \name Event Handling
+	/// @{
+
+	///
+	/// \brief event handler callback
+	/// \param event the event to handle
 	virtual void handle_event(event* event) = 0;
+
+	/// @}
+
+
+// Private Member Variables ============================================================================================
+private:
+	FENNEC_RTTI_CLASS_ENABLE() {
+	}
 };
 
+///
+/// \brief Main event interface, includes static methods for registering listeners and dispatching events
 struct event {
-	const uint64_t type;
 
-	event() = delete;
+// Constructor & Destructor ============================================================================================
+public:
 
-	template<typename EventT>
+	/// \name Constructors & Destructor
-	event() : type(typeuuid<EventT>()) { }
+	/// @{
 
+	///
+	/// \brief Default Constructor
+	event() = default;
+
+	///
+	/// \brief Copy Constructor
+	event(const event&) = default;
+
+	///
+	/// \brief Move Constructor
+	event(event&&) noexcept = default;
+
+	///
+	/// \brief Virtual Destructor
+	virtual ~event() = default;
+
+	/// @}
+
+
+// Static Event System Interface =======================================================================================
+public:
+
+	/// \name Event System Interface
+	/// @{
+
+	///
+	/// \brief Handles the event loop to distribute events.
+	///
+	/// \details Blocking
+	static void handle_events();
+
+	///
+	/// \brief Registers a listener for the event type
+	///
+	/// \details Blocking
+	/// \tparam EventT the event type
+	/// \param listener the listener to register
 	template<typename EventT>
 	static void add_listener(event_listener* listener) {
-		event::add_listener(listener, typeuuid<EventT, event>());
+		event::_add_listener(listener, type::get<EventT>().id());
 	}
 
-	template<typename EventT>
+	///
-	static void dispatch(EventT* event) {
+	/// \brief Removes a listener from the event system
-		dispatch(event);
+	///
-	}
+	/// \details Blocking
-
+	/// \param listener the listener to remove
-	static void add_listener(event_listener* listener, uint64_t type);
 	static void remove_listener(event_listener* listener);
-	static void dispatch(event* event);
+
+	///
+	/// \brief Dispatch an event at the beginning of the next tick.
+	///
+	/// \details Non-Blocking, Lock-Free, Wait-Free
+	/// \tparam EventT The event type
+	/// \tparam ArgsT The argument types
+	/// \param args The arguments to construct the event with
+	template<typename EventT, typename...ArgsT>
+	static void dispatch(ArgsT&&...args) {
+		event::_dispatch(fennec::make_unique<EventT>(fennec::forward<ArgsT>(args)...));
+	}
+
+	///
+	/// \brief Dispatch an event immediately, on the current thread.
+	///
+	/// \details Blocking
+	/// \tparam EventT The event type
+	/// \tparam ArgsT The argument types
+	/// \param args The arguments to construct the event with
+	template<typename EventT, typename...ArgsT>
+	static void dispatch_immediate(ArgsT&&...args) {
+		event::_dispatch_immediate(fennec::make_unique<EventT>(fennec::forward<ArgsT>(args)...));
+	}
+
+	/// @}
+
+
+// Private Helpers =====================================================================================================
+private:
+	static void _add_listener(event_listener* listener, uint64_t type);
+	static void _handle_event(unique_ptr<event>& event);
+	static void _dispatch(unique_ptr<event>&& event);
+	static void _dispatch_immediate(unique_ptr<event>&& event);
+
+#ifndef FENNEC_DOXYGEN
+	FENNEC_RTTI_CLASS_ENABLE() {
+	}
+#endif
 };
 
 }

include/fennec/core/logger.h

@@ -0,0 +1,115 @@
+// =====================================================================================================================
+//  fennec, a free and open source game engine
+//  Copyright © 2025 - 2026  Medusa Slockbower
+//
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+// =====================================================================================================================
+
+///
+/// \file fennec/core/logger.h
+/// \brief
+///
+///
+/// \details
+/// \author Medusa Slockbower
+///
+/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
+///
+///
+
+
+#ifndef FENNEC_CORE_LOGGER_H
+#define FENNEC_CORE_LOGGER_H
+
+#include <fennec/filesystem/file.h>
+#include <fennec/rtti/singleton.h>
+#include <fennec/containers/tuple.h>
+
+namespace fennec
+{
+
+///
+/// \brief logger class
+class logger : public singleton<logger> {
+
+// Logger System Interface =============================================================================================
+public:
+
+	/// \name System Interface
+	/// @{
+
+	///
+	/// \brief Log a string to the log file and cout
+	/// \param str the string to log
+	/// \param _line the line of the log call
+	/// \param _file the file log was called in
+	static void log(const cstring& str,
+	                uint32_t _line = FENNEC_BUILTIN_LINE(),
+	                const char* _file = FENNEC_BUILTIN_FILE()
+	) {
+		logger& inst = instance();
+
+		if (inst._logfile.is_open()) {
+			inst._logfile.print(cstring(_file, strlen(_file)));
+			inst._logfile.printf("({}): ", _line);
+			inst._logfile.println(str);
+		}
+
+		inst._cout->print(cstring(_file, strlen(_file)));
+		inst._cout->printf("({}): ", _line);
+		inst._cout->println(str);
+	}
+
+	///
+	/// \brief Log a string to the log file and cout
+	/// \param str the string to log
+	/// \param _line the line of the log call
+	/// \param _file the file log was called in
+	static void log(const string& str,
+		uint32_t _line = FENNEC_BUILTIN_LINE(),
+		const char* _file = FENNEC_BUILTIN_FILE()
+	) {
+		logger& inst = instance();
+
+		if (inst._logfile.is_open()) {
+			inst._logfile.print(cstring(_file, strlen(_file)));
+			inst._logfile.printf("({}): ", _line);
+			inst._logfile.println(str);
+		}
+
+		inst._cout->print(cstring(_file, strlen(_file)));
+		inst._cout->printf("({}): ", _line);
+		inst._cout->println(str);
+	}
+
+	/// @}
+
+
+// Private Member Variables ============================================================================================
+private:
+	file  _logfile;
+	file* _cout;
+
+
+// Private Constructors & Destructor ===================================================================================
+private:
+	logger();
+	~logger();
+
+	friend struct singleton;
+};
+
+}
+
+#endif // FENNEC_CORE_LOGGER_H

include/fennec/core/system.h

@@ -1,6 +1,6 @@
 // =====================================================================================================================
 //  fennec, a free and open source game engine
-//  Copyright © 2025  Medusa Slockbower
+//  Copyright © 2025 - 2026  Medusa Slockbower
 //
 //  This program is free software: you can redistribute it and/or modify
 //  it under the terms of the GNU General Public License as published by
@@ -18,7 +18,7 @@
 
 #ifndef FENNEC_CORE_SYSTEM_H
 #define FENNEC_CORE_SYSTEM_H
-#include <fennec/langproc/strings/string.h>
+#include <fennec/string/string.h>
 
 namespace fennec
 {

include/fennec/core/version.h

@@ -0,0 +1,123 @@
+// =====================================================================================================================
+//  fennec, a free and open source game engine
+//  Copyright © 2025 - 2026  Medusa Slockbower
+//
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+// =====================================================================================================================
+
+///
+/// \file fennec/core/version.h
+/// \brief
+///
+///
+/// \details
+/// \author Medusa Slockbower
+///
+/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
+///
+///
+
+
+#ifndef FENNEC_CORE_VERSION_H
+#define FENNEC_CORE_VERSION_H
+
+#if FENNEC_COMPILER_GCC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wpedantic"
+#endif
+
+#if FENNEC_COMPILER_MSVC
+#pragma warning(push)
+#pragma warning(disable:4201)
+#endif
+
+#include <fennec/lang/types.h>
+#include <fennec/string/string.h>
+
+namespace fennec
+{
+
+///
+/// \brief simple version struct for drivers and systems
+struct version {
+
+// Public Member Variables =============================================================================================
+public:
+
+	/// \name Member Variables
+	/// @{
+
+	union {
+		uint64_t num; //!< long version number
+		struct {
+			uint16_t major = { 1 }; //!< the major version
+			uint16_t minor = { 0 }; //!< the minor version
+			uint16_t patch = { 0 }; //!< the patch version
+			uint16_t meta  = { 0 }; //!< the meta  version, e.g. "rc.1"
+		};
+	};
+
+	/// @}
+
+// Comparison Operators ================================================================================================
+public:
+
+	/// \name Comparison Operators
+	/// @{
+
+	///
+	/// \brief Equality Operator
+	/// \param lhs The e
+	friend bool operator==(const version& lhs, const version& rhs) {
+		return lhs.num == rhs.num;
+	}
+
+	friend bool operator!=(const version& lhs, const version& rhs) {
+		return lhs.num != rhs.num;
+	}
+
+	///
+	/// \brief
+	/// \param lhs
+	/// \param rhs
+	/// \return
+	friend bool operator<(const version& lhs, const version& rhs) {
+		return lhs.num < rhs.num;
+
+		// This generates branching instructions, even in -O4
+		//return lhs.major < rhs.major or(
+		//	(lhs.major == rhs.major and lhs.minor < rhs.minor) or (
+		//		lhs.minor == rhs.minor and lhs.patch < rhs.patch
+		//	)
+		//);
+	}
+
+	friend bool operator>(const version& lhs, const version& rhs) {
+		return lhs.num > rhs.num;
+	}
+
+	/// @}
+};
+
+#ifdef FENNEC_COMPILER_GCC
+#pragma GCC diagnostic pop
+#endif
+
+#if FENNEC_COMPILER_MSVC
+#pragma warning(pop)
+#endif
+
+}
+
+#endif // FENNEC_CORE_VERSION_H

include/fennec/filesystem/detail/_stdio.h

@@ -1,6 +1,6 @@
 // =====================================================================================================================
 //  fennec, a free and open source game engine
-//  Copyright © 2025  Medusa Slockbower
+//  Copyright © 2025 - 2026  Medusa Slockbower
 //
 //  This program is free software: you can redistribute it and/or modify
 //  it under the terms of the GNU General Public License as published by
@@ -16,9 +16,9 @@
 //  along with this program.  If not, see <https://www.gnu.org/licenses/>.
 // =====================================================================================================================
 
-#ifndef FENNEC_LANGPROC_STRINGS_DETAIL_CTYPE_H
+#ifndef FENNEC_FILESYSTEM_DETAIL_CTYPE_H
-#define FENNEC_LANGPROC_STRINGS_DETAIL_CTYPE_H
+#define FENNEC_FILESYSTEM_DETAIL_CTYPE_H
 
 #include <stdio.h>
 
-#endif // FENNEC_LANGPROC_STRINGS_DETAIL_CTYPE_H
+#endif // FENNEC_FILESYSTEM_DETAIL_CTYPE_H

include/fennec/filesystem/file.h

@@ -0,0 +1,589 @@
+// =====================================================================================================================
+//  fennec, a free and open source game engine
+//  Copyright © 2025 - 2026  Medusa Slockbower
+//
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+// =====================================================================================================================
+
+#ifndef FENNEC_FILESYSTEM_FILE_H
+#define FENNEC_FILESYSTEM_FILE_H
+
+#include <fennec/filesystem/path.h>
+#include <fennec/format/format.h>
+
+#include <fennec/string/cstring.h>
+#include <fennec/string/string.h>
+#include <fennec/string/wstring.h>
+
+namespace fennec
+{
+
+///
+/// \brief Mode flags for opening a file
+///
+/// fmode_binary and fmode_wide are independent of the other modes
+///
+/// \details Valid Flag Combinations
+/// <table width="100%" class="fieldtable" id="table_fennec_LANGPROC_io_fmode">
+/// <tr><th style="vertical-align: top">Flags
+///     <th style="vertical-align: top">Description
+///
+/// <tr><td style="vertical-align: top">\f$read\f$
+///     <td style="vertical-align: top">Opens file as read-only, reading from start
+///
+/// <tr><td style="vertical-align: top">\f$write\f$
+///     <td style="vertical-align: top">Opens file as write-only, writing to end
+///
+/// <tr><td style="vertical-align: top">\f$read | write\f$
+///     <td style="vertical-align: top">Opens file as read-write, reading from start
+///
+/// <tr><td style="vertical-align: top">\f$write | trunc\f$
+///     <td style="vertical-align: top">Opens file as write-only, destroying contents
+///
+/// <tr><td style="vertical-align: top">\f$read | write | trunc\f$
+///     <td style="vertical-align: top">Opens file as read-write, destroying contents
+/// </table>
+enum fmode_ : uint8_t
+{
+	fmode_read      = 0b00000001 //!< Opens file for reading
+,	fmode_write     = 0b00000010 //!< Opens file for writing
+,	fmode_trunc     = 0b00000100 //!< Contents of the file will be destroyed, only compatible with write enabled modes
+,	fmode_exclusive = 0b00001000 //!< Generates an error if the opened file is not empty
+,   fmode_binary    = 0b00010000 //!< Open in binary mode
+,	fmode_wide      = 0b00100000 //!< Opens a file in wide mode
+};
+
+///
+/// \brief Structure for handling streams of data
+///
+/// \details operations, when errored, will return a corresponding error.
+///          Use file::get_error() to check if an error is present and return a corresponding string.
+///          Use file::clear_error() to clear the errored state.
+///          Some operations, specifically file::rename() and file::copy().
+///          <br>
+///          This file paradigm is to subvert time-of-check time-of-use (TOCTOU) attacks. This involves a threat actor
+///          reading that our application checks if a file exists, and replacing the file with another malicious file
+///          or symlink between our call to open the file.
+class file
+{
+// Constants ===========================================================================================================
+public:
+
+	/// \name Constants
+	/// @{
+
+	/// \brief value of an invalid position
+	static constexpr size_t npos = -1;
+
+	/// @}
+
+
+// Validation Functions ================================================================================================
+public:
+
+	/// \name Validation Functions
+	/// @{
+
+	///
+	/// \brief Check if the provided mode bitflags are a valid combination
+	/// \param mode the bitfield
+	/// \returns true if the combination of flags is valid, false otherwise
+	static constexpr bool is_valid(uint8_t mode) {
+		const bool t = mode & fmode_trunc;
+		const bool x = mode & fmode_exclusive;
+		const bool w = mode & fmode_write;
+
+		// when x is true, t must be true
+		// when t is true, w must be true
+		return (t && x && w)
+		||     (t && w)
+		||    !(t || x);
+	}
+
+	/// @}
+
+
+// STD Text Streams ====================================================================================================
+public:
+
+	/// \name STD Text Streams
+	/// @{
+
+	///
+	/// \returns the c stdout stream
+	static file& cout();
+
+	///
+	/// \returns the c stdin stream
+	static file& cin();
+
+	///
+	/// \returns the c stderr stream
+	static file& cerr();
+
+	/// @}
+
+
+// Constructors & Destructor ===========================================================================================
+public:
+
+	/// \name Constructors & Destructor
+	/// @{
+
+	///
+	/// \brief Default constructor
+	/// \details Initializes an empty stream
+	file();
+
+	///
+	/// \details Initializes a stream pointing to \f$path\f$ opened with \f$mode\f$
+	/// \param path the path of the file
+	/// \param mode the mode to open with
+	file(const cstring& path, uint8_t mode)
+		: file() {
+		open(path, mode);
+	}
+
+	///
+	/// \details Initializes a stream pointing to \f$path\f$ opened with \f$mode\f$
+	/// \param path the path of the file
+	/// \param mode the mode to open with
+	file(const string& path, uint8_t mode)
+		: file() {
+		open(path, mode);
+	}
+
+	///
+	/// \brief Path constructor
+	/// \details Initializes a stream pointing to \f$path\f$ opened with \f$mode\f$
+	/// \param path the path of the file
+	/// \param mode the mode to open with
+	file(const path& path, uint8_t mode)
+		: file() {
+		open(path, mode);
+	}
+
+	///
+	/// \brief Move constructor
+	/// \param file the stream to take ownership of
+	file(file&& file) noexcept;
+
+	///
+	/// \brief Destructor
+	/// \details Flushes and closes an open stream
+	~file();
+
+	///
+	/// \brief Move assignment
+	/// \param file the stream to take ownership of
+	file& operator=(file&& file) noexcept;
+
+	///@}
+
+private:
+	// don't allow copying streams
+	file(const file&) = delete;
+	file& operator=(const file&) = delete;
+
+
+// Properties ==========================================================================================================
+public:
+
+	/// \name Properties
+	/// @{
+
+	///
+	/// \returns The path the stream
+	const path& get_path() const {
+		return _path;
+	}
+
+	///
+	/// \returns The mode of the stream
+	uint8_t mode() const {
+		return _mode;
+	}
+
+	///
+	/// \returns \f$true\f$ if there is a valid, open stream.
+	bool is_open() const {
+		return _handle != nullptr;
+	}
+
+	/// @}
+
+
+// File Access =========================================================================================================
+public:
+
+	/// \name File Access
+	/// @{
+
+	///
+	/// \param path the path to the file
+	/// \param mode the mode flags to open the file with
+	/// \returns \f$false\f$ on success, \f$true\f$ on error
+	bool open(const cstring& path, uint8_t mode);
+
+	///
+	/// \param path the path to the file
+	/// \param mode the mode flags to open the file with
+	/// \returns \f$false\f$ on success, \f$true\f$ on error
+	bool open(const string& path, uint8_t mode);
+
+	///
+	/// \brief Open a file
+	/// \param path the path to the file
+	/// \param mode the mode flags to open the file with
+	/// \returns \f$false\f$ on success, \f$true\f$ on error
+	bool open(const path& path, uint8_t mode);
+
+	///
+	/// \brief Close a stream
+	/// \returns \f$false\f$ on success, \f$true\f$ on error
+	bool close();
+
+	///
+	/// \brief Commit the streams buffer to the file
+	/// \returns \f$false\f$ on success, \f$true\f$ on error
+	bool commit();
+
+	/// @}
+
+
+// File Operations =====================================================================================================
+public:
+
+	/// \name File Operations
+	/// @{
+
+	///
+	/// \brief closes the stream and erases the file
+	/// \returns \f$false\f$ on success, \f$true\f$ on error
+	bool erase();
+
+	///
+	/// \param path the new path
+	/// \returns \f$false\f$ on success, \f$true\f$ on error
+	///
+	/// \details
+	/// Copies contents to the new path, and erases the old file.
+	/// * Attempts to open a write-only stream at path
+	/// * Attempts to reopen this file as read-only
+	/// * Copies the contents of this file to the new stream
+	/// * Reopen the new stream with the flags of this file and binds to it
+	/// * Closes the old file
+	bool rename(const cstring& path);
+
+	///
+	/// \param path the new path
+	/// \returns \f$false\f$ on success, \f$true\f$ on error
+	///
+	/// \details
+	/// Copies contents to the new path, and erases the old file.
+	/// * Attempts to open a write-only stream at path
+	/// * Attempts to reopen this file as read-only
+	/// * Copies the contents of this file to the new stream
+	/// * Reopen the new stream with the flags of this file and binds to it
+	/// * Closes the old file
+	bool rename(const string& path);
+
+	///
+	/// \brief Rebind the stream.
+	/// \param path the new path
+	/// \returns \f$false\f$ on success, \f$true\f$ on error
+	///
+	/// \details
+	/// Copies contents to the new path, and erases the old file.
+	/// * Attempts to open a write-only stream at path
+	/// * Attempts to reopen this file as read-only
+	/// * Copies the contents of this file to the new stream
+	/// * Reopen the new stream with the flags of this file and binds to it
+	/// * Closes the old file
+	bool rename(const path& path);
+
+	///
+	/// \param path the path to copy to
+	/// \returns a file at the new path with the copied contents
+	///
+	/// \details
+	/// Copies the contents to a new stream at the provided path.
+	/// * Attempts to open a write-only stream at path, <br>
+	/// * Attempts to reopen this file as read-only, <br>
+	/// * Copies the contents of this file to the new stream, <br>
+	/// * Reopen the new stream with the flags of this file.
+	file copy(const cstring& path);
+
+	///
+	/// \param path the path to copy to
+	/// \returns a file at the new path with the copied contents
+	///
+	/// \details
+	/// Copies the contents to a new stream at the provided path.
+	/// * Attempts to open a write-only stream at path, <br>
+	/// * Attempts to reopen this file as read-only, <br>
+	/// * Copies the contents of this file to the new stream, <br>
+	/// * Reopen the new stream with the flags of this file.
+	file copy(const string& path);
+
+	///
+	/// \brief Copy contents to a new file.
+	/// \details Copies the contents of the current stream into a new stream bound to the file at the provided path.
+	/// \param path the path to copy to
+	/// \returns a file at the new path with the copied contents
+	///
+	/// \details
+	/// Copies the contents to a new stream at the provided path.
+	/// * Attempts to open a write-only stream at path, <br>
+	/// * Attempts to reopen this file as read-only, <br>
+	/// * Copies the contents of this file to the new stream, <br>
+	/// * Reopen the new stream with the flags of this file.
+	file copy(const path& path);
+
+	/// @}
+
+
+// File Positioning ====================================================================================================
+public:
+
+	/// \name File Positioning
+	/// @{
+
+	///
+	/// \returns the position index in the stream
+	size_t get_pos() const;
+
+	///
+	/// \param i the new index to move to
+	/// \returns \f$false\f$ on success, \f$true\f$ otherwise
+	bool set_pos(size_t i);
+
+	///
+	/// \brief return to the start of the stream
+	/// \returns \f$false\f$ on success, \f$true\f$ otherwise
+	bool rewind();
+
+	///
+	/// \returns \f$true\f$ if the stream has reached the end of the file, \f$false\f$ otherwise
+	bool eof() const;
+
+	/// @}
+
+
+// Binary Read Operations ==============================================================================================
+public:
+
+	/// \name Binary Read Operations
+	/// @{
+
+	///
+	/// \brief binary read
+	/// \param data the buffer to write to
+	/// \param size the size of each object in bytes
+	/// \param n the number of objects to read
+	/// \returns the number of objects successfully read
+	size_t read(void* data, size_t size, size_t n);
+
+	///
+	/// \brief type read
+	/// \tparam T the type to read
+	/// \param data the buffer to write to
+	/// \param n the number of objects to read
+	/// \returns the number of objects successfully read
+	template<typename T>
+	size_t read(T* data, size_t n) {
+		return read(static_cast<void*>(data), sizeof(T), n);
+	}
+
+	///
+	/// \brief type read
+	/// \tparam T the type to read
+	/// \tparam n the number of objects to read
+	/// \param data the buffer to write to
+	/// \returns the number of objects successfully read
+	template<typename T, size_t n>
+	size_t read(T (&data)[n]) {
+		return read(static_cast<void*>(data), sizeof(T), n);
+	}
+
+	/// @}
+
+
+// Binary Write Operations =============================================================================================
+public:
+
+	/// \name Binary Write Operations
+	/// @{
+
+	///
+	/// \brief put a character at the current position in the stream
+	/// \param c the character to put
+	/// \returns \f$false\f$ on success, \f$true\f$ otherwise
+	bool putc(char c);
+
+	///
+	/// \brief put a wide character at the current position in the stream
+	/// \param c the character to put
+	/// \returns \f$false\f$ on success, \f$true\f$ otherwise
+	bool putwc(wchar_t c);
+
+	///
+	/// \brief write a buffer to at the current position in the stream
+	/// \param data the buffer to read from
+	/// \param size the size of each object in bytes
+	/// \param n the number of objects to write
+	/// \returns the number of objects successfully written
+	size_t write(const void* data, size_t size, size_t n);
+
+	///
+	/// \brief write a character buffer to at the current position in the stream
+	/// \tparam n the number of characters to write
+	/// \param data the buffer to read from
+	/// \returns the number of objects successfully written
+	template<size_t n>
+	size_t write(const char (&data)[n]) {
+		return write(data, sizeof(char), n - 1);
+	}
+
+	///
+	/// \brief write a wide character buffer to at the current position in the stream
+	/// \tparam n the number of characters to write
+	/// \param data the buffer to read from
+	/// \returns the number of objects successfully written
+	template<size_t n>
+	size_t write(const wchar_t (&data)[n]) {
+		return write(data, sizeof(wchar_t), n - 1);
+	}
+
+	///
+	/// \brief write a buffer to at the current position in the stream
+	/// \tparam T the object type to write
+	/// \param data the buffer to read from
+	/// \param n the number of objects to write
+	/// \returns the number of objects successfully written
+	template<typename T>
+	size_t write(const T* data, size_t n) {
+		return write(static_cast<const void*>(data), sizeof(T), n);
+	}
+
+	///
+	/// \brief write a buffer to at the current position in the stream
+	/// \tparam T the object type to write
+	/// \tparam n the number of objects to write
+	/// \param data the buffer to read from
+	/// \returns the number of objects successfully written
+	template<typename T, size_t n>
+	size_t write(const T (&data)[n]) {
+		return write(static_cast<const void*>(data), sizeof(T), n);
+	}
+
+	/// @}
+
+
+// Read Operations =====================================================================================================
+public:
+
+	/// \name Read Operations
+	/// @{
+
+	///
+	/// \returns the character read at the current position in the stream
+	/// \details Advances the position by one character
+	char getc();
+
+	///
+	/// \returns the wide character read at the current position in the stream
+	/// \details Advances the position by one wide character
+	wchar_t getwc();
+
+	///
+	/// \returns A string containing the characters from the current position to the next newline character
+	/// \details Advances the position to the character following the next newline character
+	string getline();
+
+	///
+	/// \returns A wide string containing the characters from the current position to the next newline character
+	/// \details Advances the position to the character following the next newline character
+	wstring getwline();
+
+	/// @}
+
+
+// Printing Operations =================================================================================================
+public:
+
+	/// \name Print Operations
+	/// @{
+
+	///
+	/// \param str the string to print
+	void print(const cstring& str);
+
+	///
+	/// \brief print a string to the stream
+	/// \param str the string to print
+	void print(const string&  str);
+
+	///
+	/// \param str the string to print
+	void println(const cstring& str);
+
+	///
+	/// \brief print a string to the stream followed by a newline character
+	/// \param str the string to print
+	void println(const string&  str);
+
+	///
+	/// \brief print a formatted string to the stream
+	/// \tparam ArgsT the argument types
+	/// \param str the format string
+	/// \param args the argument values
+	template<typename...ArgsT>
+	void printf(const cstring& str, ArgsT&&...args) {
+		string fmt = fennec::format(str, fennec::forward<ArgsT>(args)...);
+		this->print(cstring(fmt.cstr(), fmt.length()));
+	}
+
+	/// @}
+
+
+
+
+// Error Handling ======================================================================================================
+public:
+
+	/// \name Error Handling
+	/// @{
+
+	///
+	/// \brief Returns the current error state.
+	/// \returns A string containing the current error.
+	cstring get_error() const { return { _error, ::strlen(_error) }; }
+
+	///
+	/// \brief clears the errored state
+	void clear_error() { _error = nullptr; }
+
+	/// @}
+
+private:
+	FILE* _handle;
+	path    _path;
+	uint8_t _mode;
+	char*  _error;
+};
+
+}
+
+#endif // FENNEC_FILESYSTEM_FILE_H

include/fennec/filesystem/path.h

@@ -0,0 +1,438 @@
+// =====================================================================================================================
+//  fennec, a free and open source game engine
+//  Copyright © 2025 - 2026  Medusa Slockbower
+//
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+// =====================================================================================================================
+
+#ifndef FENNEC_FILESYSTEM_PATH_H
+#define FENNEC_FILESYSTEM_PATH_H
+
+#include <fennec/filesystem/path.h>
+#include <fennec/string/string.h>
+
+namespace fennec
+{
+
+///
+/// \brief struct for handling file paths
+///
+/// \details This structure makes no guarantees about the validity of a path.
+///          Operations do not examine the system's file structure.
+struct path {
+
+// Definitions =========================================================================================================
+public:
+
+	class iterator;
+	friend class iterator;
+
+
+// Current Working Director ============================================================================================
+public:
+
+	/// \name Current Working Directory
+	/// @{
+
+	/// \brief Get the current working directory
+	/// \returns a path containing the absolute path to the working directory
+	static path get_current();
+
+	/// \brief Set the current working directory
+	/// \param path the path to the new working directory
+	/// \returns a path containing the absolute path to the working directory
+	static path set_current(const path& path);
+
+	/// @}
+
+
+// Constructors & Destructor ===========================================================================================
+public:
+
+	/// \name Constructors & Destructor
+	/// @{
+
+	///
+	/// \brief Default Constructor, returns the root of the current working directory
+	path() : _str("/") { }
+
+	///
+	/// \brief C-String Conversion Constructor
+	/// \param str the cstring to convert
+	path(const cstring& str)
+		: _str(str) {
+		if (str.size() > 2 && str[str.size() - 1] == '/') {
+			_str = _str.substring(0, str.size() - 1);
+		}
+	}
+
+	///
+	/// \brief String Conversion Constructor
+	/// \param str the string to convert
+	path(const string& str)
+	: _str(str) {
+		if (str.size() > 2 && str[str.size() - 1] == '/') {
+			_str = _str.substring(0, str.size() - 1);
+		}
+	}
+
+	///
+	/// \brief Path Copy Constructor
+	/// \param p the path to copy
+	path(const path& p)
+		: _str(p._str) {
+	}
+
+	///
+	/// \brief Path Move Constructor
+	/// \param p the path to take ownership of
+	path(path&& p) noexcept : _str(move(p._str)) { }
+
+	///
+	/// \brief Destructor
+	~path() = default;
+
+	/// @}
+
+
+// Assignment Operators ================================================================================================
+public:
+
+	/// \name Assignment
+	/// @{
+
+	///
+	/// \brief C-String Assignment Operator
+	/// \param str the cstring to assign
+	/// \returns a reference to \f$this\f$ after assigning \f$p\f$
+	template<size_t n>
+	path& operator=(const char (&str)[n]) {
+		_str = str;
+		return *this;
+	}
+
+	///
+	/// \brief C-String Assignment Operator
+	/// \param p the cstring to assign
+	/// \returns a reference to \f$this\f$ after assigning \f$p\f$
+	path& operator=(const cstring& p) {
+		_str = p;
+		return *this;
+	}
+
+	///
+	/// \brief String Assignment Operator
+	/// \param p the cstring to assign
+	/// \returns a reference to \f$this\f$ after assigning \f$p\f$
+	path& operator=(const string& p) {
+		_str = p;
+		return *this;
+	}
+
+	///
+	/// \brief Path Copy Assignment Operator
+	/// \param p the path to copy
+	/// \returns a reference to \f$this\f$ after copying \f$p\f$
+	path& operator=(const path& p) {
+		_str = p._str;
+		return *this;
+	}
+
+	///
+	/// \brief Path Move Assignment Operator
+	/// \param p the path to take ownership of
+	/// \returns a reference to \f$this\f$ after taking ownership of \f$p\f$
+	path& operator=(path&& p) noexcept {
+		_str = move(p._str);
+		return *this;
+	}
+
+	/// @}
+
+
+// Comparison ==========================================================================================================
+public:
+
+	/// \name Comparison
+	/// @{
+
+	///
+	/// \brief path equality operator
+	/// \param p the path to compare against
+	/// \returns \f$true\f$ if the paths are identical, \f$false\f$ otherwise. relative paths are not resolved
+	bool operator==(const path& p) const {
+		return _str == p._str;
+	}
+
+	/// @}
+
+
+// Modifiers ===========================================================================================================
+public:
+
+	/// \name Modifiers
+	/// @{
+
+	///
+	/// \brief path append operator
+	/// \param str the filename to append
+	/// \returns a path containing the current path followed by \f$str\f$
+	path operator/(const cstring& str) const {
+		return path(_str + '/' + str);
+	}
+
+	///
+	/// \brief path append operator
+	/// \param str the filename to append
+	/// \returns a path containing the current path followed by \f$str\f$
+	path operator/(const string& str) const {
+		return path(_str + '/' + str);
+	}
+
+	///
+	/// \brief path append operator
+	/// \param p the path to append
+	/// \returns a path containing the current path followed by \f$p\f$
+	path operator/(const path& p) const {
+		return path(_str + '/' + p._str);
+	}
+
+	/// @}
+
+	///
+	/// \brief the filename of the current path
+	/// \returns a string containing a copy of the filename
+	string filename() const {
+		size_t i = _str.rfind('/');
+		return _str.substring(i + 1);
+	}
+
+	///
+	/// \returns the underlying string representation
+	const string& str() const { return _str; }
+
+	///
+	/// \returns the underlying C-Style string representation
+	const char* cstr() const { return _str.cstr(); }
+
+	///
+	/// \returns \f$true\f$ if the path is empty or points to root
+	bool is_empty() {
+		size_t size = _str.size();
+		if (size == 0) return true;
+#if FENNEC_PLATFORM_WINDOWS
+		return (_str[1] == ':' && size == 3);
+#else
+		return (_str[0] == '/' && size == 1);
+#endif
+	}
+
+	///
+	/// \returns a copy of the path with the filename removed
+	path parent() const {
+#ifdef FENNEC_PLATFORM_WINDOWS
+		size_t start = _str.size() - 1;
+		start = _str[start] == '/' || _str[start] == '\\' ? start - 1 : start;
+
+		size_t r = _str.rfind('/', start);
+		size_t l = _str.rfind('\\', start);
+		if (r == _str.size()) {
+			start = l;
+		}
+		else if (l == _str.size()) {
+			start = r;
+		}
+		else {
+			start = max(r, l);
+		}
+		return _str.substring(0, start);
+#else
+		size_t start = _str.size();
+		start = _str[start] == '/' ? start - 1 : start;
+		return path(_str.substring(0, _str.rfind('/', start)));
+#endif
+	}
+
+	///
+	/// \brief absolute path
+	/// \returns a copy of the path with relative paths resolved
+	path absolute() const {
+		path parse = *this;
+		path working; working._str.resize(0);
+
+// Check if this is a rooted path;
+#ifdef FENNEC_PLATFORM_WINDOWS
+		if (_str[1] != ':') {
+#else
+		if (_str[0] != '/') {
+#endif
+			working = get_current();
+		}
+
+		while (not parse.is_empty()) {
+			// Handle dots
+			while (not parse.is_empty() && parse._str[0] == '.') {
+				// Check for ".."
+				if (parse._str[1] == '.') {
+					// ".."
+					if (parse._str.size() == 2) {
+						parse = path();
+						working = working.parent();
+					}
+					// "../"
+					else if (parse._str[2] == '/') {
+						working = working.parent();
+						parse._str = parse._str.substring(3);
+					}
+				}
+				// "./"
+				else if (parse._str[1] == '/') {
+					parse._str = parse._str.substring(2);
+				}
+			}
+
+			if (parse.is_empty()) break;
+
+			// Push the path
+			const size_t loc = parse._str.find('/');
+			working._str += '/';
+			working._str += parse._str.substring(0, loc);
+			parse._str = parse._str.substring(loc + 1);
+		}
+
+		return working;
+	}
+
+
+// Iteration ===========================================================================================================
+public:
+
+	/// \name Iteration
+	/// @{
+
+	///
+	/// \brief C++ Iterator Specification \f$begin()\f$
+	/// \returns an iterator at the first filename in the path
+	iterator begin() const {
+		return iterator(this, 0);
+	}
+
+	///
+	/// \brief C++ Iterator Specification \f$end()\f$
+	/// \returns an iterator to the end of the path
+	iterator end() const {
+		return iterator(this, _str.size());
+	}
+
+	///
+	/// \brief C++ Iterator Specification \f$iterator\f$
+	class iterator {
+	public:
+		///
+		/// \brief copy constructor
+		/// \param it the iterator to copy
+		constexpr iterator(const iterator& it) = default;
+
+		///
+		/// \brief move constructor
+		/// \param it the iterator to move
+		constexpr iterator(iterator&& it) noexcept = default;
+
+		///
+		/// \brief dereference operator
+		/// \returns copy of the current file in the path
+		constexpr string operator*() const {
+			if ((*_str)[_pos] == '/') {
+				return string("");
+			}
+
+			size_t e = _str->find('/', _pos);
+			return _str->substring(_pos, e - _pos);
+		}
+
+		///
+		/// \brief prefix increment operator
+		/// \returns \f$self\f$ after having moved to the next element in the list
+		constexpr iterator& operator++() {
+			_pos = min(_str->find('/', _pos) + 1, _str->size());
+			return *this;
+		}
+
+		///
+		/// \brief postfix increment operator
+		/// \returns \f$self\f$ before having moved to the next element in the list
+		constexpr iterator operator++(int) {
+			iterator it = *this;
+			this->operator++();
+			return it;
+		}
+
+		///
+		/// \brief iterator equality operator
+		/// \param rhs the iterator to compare with
+		/// \returns \f$true\f$ if the iterators are identical, \f$false\f$ otherwise
+		constexpr bool operator==(const iterator& rhs) const {
+			return _str == rhs._str and _pos == rhs._pos;
+		}
+
+		///
+		/// \brief iterator inequality operator
+		/// \param rhs the iterator to compare with
+		/// \returns \f$true\f$ if the iterators are different, \f$false\f$ otherwise
+		constexpr bool operator!=(const iterator& rhs) const {
+			return _str != rhs._str or _pos != rhs._pos;
+		}
+
+	private:
+		const string* _str;
+		size_t _pos;
+
+		constexpr iterator(const path* path, size_t p)
+			: _str(&path->_str)
+			, _pos(p) {
+
+			// Handle end()
+			if (p == _str->size()) {
+				return;
+			}
+
+			// Handle rooted paths
+#ifdef FENNEC_PLATFORM_WINDOWS
+			if ((*_str)[1] == ':') {
+				_pos = max(_pos, size_t(3));
+			}
+#else
+			if ((*_str)[0] == '/') {
+				_pos = max(_pos, size_t(1));
+			}
+#endif
+
+			// Ensure we are at the start of a directory/file name
+			if (_pos != 0 && (*_str)[_pos - 1] != '/') {
+				_pos = _str->find('/', _pos) + 1;
+			}
+		}
+
+		friend struct path;
+	};
+
+	/// @}
+
+private:
+	string _str;
+};
+
+}
+
+#endif // FENNEC_FILESYSTEM_PATH_H

include/fennec/format/charconv.h

@@ -0,0 +1,201 @@
+// =====================================================================================================================
+//  fennec, a free and open source game engine
+//  Copyright © 2025 - 2026  Medusa Slockbower
+//
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+// =====================================================================================================================
+
+///
+/// \file fennec/format/charconv.h
+/// \brief
+///
+///
+/// \details
+/// \author Medusa Slockbower
+///
+/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
+///
+///
+
+#ifndef FENNEC_FORMAT_CHARCONV_H
+#define FENNEC_FORMAT_CHARCONV_H
+
+namespace fennec
+{
+
+///
+/// \param first the start of the buffer
+/// \param last the end of the buffer
+/// \param x the value to write
+/// \param base the base to interpret the integer as
+/// \returns a pointer to one past the last written character
+char* to_chars(char* first, char* last,          char x, int base);
+
+///
+/// \param first the start of the buffer
+/// \param last the end of the buffer
+/// \param x the value to write
+/// \param base the base to interpret the integer as
+/// \returns a pointer to one past the last written character
+char* to_chars(char* first, char* last,   signed char x, int base);
+
+///
+/// \param first the start of the buffer
+/// \param last the end of the buffer
+/// \param x the value to write
+/// \param base the base to interpret the integer as
+/// \returns a pointer to one past the last written character
+char* to_chars(char* first, char* last, unsigned char x, int base);
+
+///
+/// \param first the start of the buffer
+/// \param last the end of the buffer
+/// \param x the value to write
+/// \param base the base to interpret the integer as
+/// \returns a pointer to one past the last written character
+char* to_chars(char* first, char* last,   signed short x, int base);
+
+///
+/// \param first the start of the buffer
+/// \param last the end of the buffer
+/// \param x the value to write
+/// \param base the base to interpret the integer as
+/// \returns a pointer to one past the last written character
+char* to_chars(char* first, char* last, unsigned short x, int base);
+
+
+///
+/// \param first the start of the buffer
+/// \param last the end of the buffer
+/// \param x the value to write
+/// \param base the base to interpret the integer as
+/// \returns a pointer to one past the last written character
+char* to_chars(char* first, char* last,   signed int x, int base);
+
+///
+/// \param first the start of the buffer
+/// \param last the end of the buffer
+/// \param x the value to write
+/// \param base the base to interpret the integer as
+/// \returns a pointer to one past the last written character
+char* to_chars(char* first, char* last, unsigned int x, int base);
+
+
+///
+/// \param first the start of the buffer
+/// \param last the end of the buffer
+/// \param x the value to write
+/// \param base the base to interpret the integer as
+/// \returns a pointer to one past the last written character
+char* to_chars(char* first, char* last,   signed long x, int base);
+
+///
+/// \param first the start of the buffer
+/// \param last the end of the buffer
+/// \param x the value to write
+/// \param base the base to interpret the integer as
+/// \returns a pointer to one past the last written character
+char* to_chars(char* first, char* last, unsigned long x, int base);
+
+
+///
+/// \param first the start of the buffer
+/// \param last the end of the buffer
+/// \param x the value to write
+/// \param base the base to interpret the integer as
+/// \returns a pointer to one past the last written character
+char* to_chars(char* first, char* last,   signed long long x, int base);
+
+///
+/// \param first the start of the buffer
+/// \param last the end of the buffer
+/// \param x the value to write
+/// \param base the base to interpret the integer as
+/// \returns a pointer to one past the last written character
+char* to_chars(char* first, char* last, unsigned long long x, int base);
+
+
+///
+/// \param first the start of the buffer
+/// \param last the end of the buffer
+/// \param x the value to write
+/// \param base the base to interpret the integer as
+/// \returns a pointer to one past the last written character
+char* to_chars(char* first, char* last,   signed long long x, int base);
+
+///
+/// \brief integer to ascii
+/// \param first the start of the buffer
+/// \param last the end of the buffer
+/// \param x the value to write
+/// \param base the base to interpret the integer as
+/// \returns a pointer to one past the last written character
+char* to_chars(char* first, char* last, unsigned long long x, int base);
+
+
+///
+/// \param first the start of the buffer
+/// \param last the end of the buffer
+/// \param x the value to write
+/// \returns a pointer to one past the last written character
+char* to_chars(char* first, char* last, float x);
+
+///
+/// \param first the start of the buffer
+/// \param last the end of the buffer
+/// \param x the value to write
+/// \param fmt the float string format to use
+/// \returns a pointer to one past the last written character
+char* to_chars(char* first, char* last, float x, char fmt);
+
+///
+/// \brief float to ascii
+/// \param first the start of the buffer
+/// \param last the end of the buffer
+/// \param x the value to write
+/// \param fmt the float string format to use
+/// \param precision the number of decimal places to write
+/// \returns a pointer to one past the last written character
+char* to_chars(char* first, char* last, float x, char fmt, int precision);
+
+
+///
+/// \param first the start of the buffer
+/// \param last the end of the buffer
+/// \param x the value to write
+/// \returns a pointer to one past the last written character
+char* to_chars(char* first, char* last, double x);
+
+///
+/// \param first the start of the buffer
+/// \param last the end of the buffer
+/// \param x the value to write
+/// \param fmt the float string format to use
+/// \returns a pointer to one past the last written character
+char* to_chars(char* first, char* last, double x, char fmt);
+
+///
+/// \brief float to ascii
+/// \param first the start of the buffer
+/// \param last the end of the buffer
+/// \param x the value to write
+/// \param fmt the float string format to use
+/// \param precision the number of decimal places to write
+/// \returns a pointer to one past the last written character
+char* to_chars(char* first, char* last, double x, char fmt, int precision);
+
+
+}
+
+#endif // FENNEC_FORMAT_CHARCONV_H

include/fennec/format/detail/_format.h

@@ -0,0 +1,152 @@
+// =====================================================================================================================
+//  fennec, a free and open source game engine
+//  Copyright © 2025 - 2026  Medusa Slockbower
+//
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+// =====================================================================================================================
+
+#ifndef FENNEC_FORMAT_DETAIL_FORMAT_H
+#define FENNEC_FORMAT_DETAIL_FORMAT_H
+
+#include <fennec/memory/pointers.h>
+#include <fennec/format/formatter.h>
+#include <fennec/format/format_arg.h>
+
+namespace fennec::detail
+{
+
+// Impl interface for templated polymorphism fuckery
+struct _format_argimpl {
+	_format_argimpl() {};
+	virtual ~_format_argimpl() {};
+	virtual string format(const format_arg& fmt) = 0;
+	virtual bool   is_integer() = 0;
+	virtual int64_t int_value() = 0;
+};
+
+// Polymorphic template specialization
+template<typename T>
+struct _format_arg : _format_argimpl {
+	formatter<T> fmtr;
+	const T& val;
+	_format_arg(const T& arg) : val(arg) {
+	}
+	virtual ~_format_arg() = default;
+	string format(const format_arg& fmt) override {
+		return fennec::forward<string>(fmtr(fmt, val));
+	}
+
+	bool is_integer() override {
+		return is_integral_v<T> or is_convertible_v<T, int64_t>;
+	}
+	virtual int64_t int_value() override {
+		if constexpr(is_integral_v<T>) {
+			return val;
+		} else if constexpr(is_convertible_v<T, int64_t>) {
+			return val;
+		} else {
+			return -1;
+		}
+	}
+};
+
+// Polymorphic template specialization for x/r/xr value references
+template<typename T>
+struct _format_arg<T&> : _format_arg<T> {
+	_format_arg(const T& arg) : _format_arg<T>(arg) {
+	}
+};
+
+// Polymorphic template specialization for x/r/xr value references
+template<typename T>
+struct _format_arg<const T> : _format_arg<T> {
+	_format_arg(const T& arg) : _format_arg<T>(arg) {
+	}
+};
+
+// Polymorphic template specialization for x/r/xr value references
+template<typename T>
+struct _format_arg<const T&> : _format_arg<T> {
+	_format_arg(const T& arg) : _format_arg<T>(arg) {
+	}
+};
+
+// Containing array for format args
+template<size_t N>
+struct _format_argarray {
+	array<unique_ptr<_format_argimpl>, N> args;
+	template<typename...ArgsT>
+	_format_argarray(ArgsT&&...args)
+		: args { unique_ptr<_format_argimpl>(new _format_arg<ArgsT>(fennec::forward<ArgsT>(args)))... } {
+	}
+
+	string format(size_t i, const format_arg& fmt) {
+		return args[i]->format(fmt);
+	}
+
+	bool is_integer(size_t i) {
+		return args[i]->is_integer();
+	}
+
+	int64_t int_value(size_t i) {
+		return args[i]->int_value();
+	}
+};
+
+// checks if character is a valid format type
+constexpr bool _isfmt_t(char c) {
+	switch (c) {
+		default: return false;
+		case 's': case '?': // strings
+		case 'c':           // char
+		case 'd':           // decimal
+		case 'b': case 'B': // binary
+		case 'o':           // octal
+		case 'x': case 'X': // hex
+		case 'a': case 'A': // float hex
+		case 'e': case 'E': // scientific notation
+		case 'f': case 'F': // fixed precision
+		case 'g': case 'G': // general precision
+			return true;
+	}
+}
+
+// checks if character is a valid format int type
+constexpr bool _isfmt_i(char c) {
+	switch (c) {
+		default: return false;
+		case 'd':           // decimal
+		case 'b': case 'B': // binary
+		case 'o':           // octal
+		case 'x': case 'X': // hex
+			return true;
+	}
+}
+
+// checks if character is a valid format float type
+constexpr bool _isfmt_f(char c) {
+	switch (c) {
+		default: return false;
+		case 'a': case 'A': // float hex
+		case 'e': case 'E': // scientific notation
+		case 'f': case 'F': // fixed precision
+		case 'g': case 'G': // general precision
+			return true;
+	}
+
+}
+
+}
+
+#endif // FENNEC_FORMAT_DETAIL_FORMAT_H

include/fennec/format/format.h

@@ -0,0 +1,384 @@
+// =====================================================================================================================
+//  fennec, a free and open source game engine
+//  Copyright © 2025 - 2026  Medusa Slockbower
+//
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+// =====================================================================================================================
+
+///
+/// \file fennec/format/format.h
+/// \brief
+///
+///
+/// \details
+/// \author Medusa Slockbower
+///
+/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
+///
+///
+
+#ifndef FENNEC_FORMAT_FORMAT_H
+#define FENNEC_FORMAT_FORMAT_H
+
+#include <fennec/string/string.h>
+
+#include <fennec/format/detail/_format.h>
+#include <fennec/format/formatter.h>
+
+namespace fennec
+{
+
+///
+/// \brief C++ 20 format specification
+/// \tparam ArgsT The argument types
+/// \param str The format string
+/// \param args The argument values
+/// \returns A formatted string using the C++20 format specification
+template<typename...ArgsT>
+string format(const cstring& str, ArgsT&&...args) {
+	static constexpr size_t argc = sizeof...(ArgsT);
+	static constexpr format_arg default_fmt = {
+		.fill  = ' ',
+		.align = '\0',  // default to locale
+		.sign  = '\0',  // default to sign only for negative numbers, gets handled later in code
+		.alt   = false, // default no prefix
+		.upper = false,
+		.width = 0,
+		.precision = 6, // default to 6 sigfigs
+		.base = 10,
+		.type  = '\0',
+	};
+
+	// empty case
+	if constexpr(argc == 0) {
+		return str;
+	}
+
+	detail::_format_argarray<argc> argarray = { fennec::forward<ArgsT>(args)... };
+	string res;
+	size_t i = 0;
+	size_t arg_c = -1;
+
+	while (i <= str.length()) {
+		size_t brace = str.find('{', i);
+		size_t end = str.find('}', i);
+		format_arg fmt = default_fmt;
+
+		// check for '}}'
+		if (end < brace) {
+			if (str[end + 1] == '}') {
+				res += string(str.data() + i, end - i);
+				i = end + 2;
+				continue;
+			}
+			assertf(false, "fennec::format syntax error, encountered unexpected '{'")
+		}
+
+		// append string
+		if (brace >= str.length()) { // handle end case
+			res += string(str.data() + i, str.length() - i);
+			break;
+		}
+		res += string(str.data() + i, brace - i);
+
+		// next brace, validate escape
+		size_t next_brace = str.find('{', brace + 1);
+		if (brace + 1 == next_brace) {
+			res += '{';
+			i = next_brace + 1;
+			continue;
+		}
+
+		// find contained colon
+		size_t colon = str.find(':', brace);
+
+		// validate colon and brace location
+		assertf(colon < next_brace or end < next_brace, "fennec::format syntax error, mismatched '{}'");
+
+		// parse index if present
+		size_t id = min(colon, end) - 1;
+		if (id > brace) {
+			arg_c = 0;
+		} else {
+			++arg_c;
+		}
+		for (size_t j = id, k = 1; j > brace; --j, k *= 10) {
+			size_t u = (str[j] - '0');
+			assertf(u < 10, "fennec::format syntax error, invalid argument index");
+			arg_c += k * u;
+		}
+
+		// store argument to allow nested replacement fields
+		size_t arg = arg_c;
+
+		// validate index
+		assertf(arg < argc, "fennec::format syntax error, invalid argument index");
+
+		// early return case for no colon
+		if (colon > end) {
+			fmt.sign = fmt.sign == '\0' ? '-' : fmt.sign;
+			res += argarray.format(arg, fmt);
+			i = end + 1;
+			continue;
+		}
+
+		// parse format specifiers
+
+		// we're going to parse right-to-left since the valid combinations
+		// of specifiers change based on the type of the argument
+
+		// to compensate for this, the nested replacement fields need to be computed in this loop
+		// (nested replacement deduced)
+		size_t nrfd = 0;
+		size_t nnrf = 0;
+
+		// first find the matching '}' brace, e is not necessarily the matching brace
+		// since some specifiers allow nested replacement fields
+		size_t parse = colon;
+		while (str[parse + 1] != '}') {
+			if (next_brace < end) { // if the next brace is before the next closing brace
+				++nnrf;
+				nrfd += str[end - 1] == '{';
+				parse = end + 1;
+				end = str.find('}', parse);
+				next_brace = str.find('{', parse);
+			} else {
+				parse = end - 1;
+				break;
+			}
+		}
+
+		assertf(nrfd <= 2 and parse < str.length() - 1 and str[parse + 1] == '}',
+			    "fennec::format syntax error, mismatched '{}'");
+
+		// check type
+		switch (str[parse]) {
+			default: break;
+
+			case 's': case '?': // strings
+			case 'c':           // char
+				fmt.type = str[parse--];
+				break;
+
+
+			case 'd':           // decimal
+				fmt.base = 10;
+				fmt.type = str[parse--];
+				break;
+
+			case 'B':           // binary
+				fmt.upper = true; [[fallthrough]];
+			case 'b':
+				fmt.base = 2;
+				fmt.type = str[parse--];
+				break;
+
+			case 'o':           // octal
+				fmt.base = 8;
+				fmt.type = str[parse--];
+				break;
+
+			case 'X':           // hex
+				fmt.upper = true; [[fallthrough]];
+			case 'x':
+				fmt.base = 16;
+				fmt.type = str[parse--];
+				break;
+
+
+			case 'A':
+				fmt.upper = true; [[fallthrough]];
+			case 'a':           // float hex
+				fmt.base = 16;
+				fmt.type = str[parse--];
+				break;
+
+			case 'E':           // scientific notation
+				fmt.upper = true; [[fallthrough]];
+			case 'e':
+				fmt.base = 16;
+				fmt.type = str[parse--];
+				break;
+
+			case 'F':           // fixed precision
+				fmt.upper = true; [[fallthrough]];
+			case 'f':
+				fmt.base = 10;
+				fmt.type = str[parse--];
+				break;
+
+			case 'G':           // general precision
+				fmt.upper = true; [[fallthrough]];
+			case 'g':
+				fmt.base = 10;
+				fmt.type = str[parse--];
+				break;
+		}
+
+		// early return
+		if (parse == colon) {
+			fmt.sign = fmt.sign == '\0' ? '-' : fmt.sign;
+			res += argarray.format(arg, fmt);
+			i = end + 1;
+			continue;
+		}
+
+		// search for width and precision
+		size_t x = 0, j = 1;
+		bool   found_decimal = false;
+		size_t num_decimals = 0;
+		bool   is_float_t   = detail::_isfmt_f(fmt.type);
+		bool   is_str_t     = fmt.type == 's';
+		bool   is_integer_t = detail::_isfmt_i(fmt.type);
+		bool   ded_width_f  = false;
+		bool   ded_width    = false;
+		size_t ded_temp_i   = 0;
+
+		// default "precision" for strings should be 0 for no limit
+		if (is_str_t) {
+			fmt.precision = 0;
+		}
+
+		// parse width and precision
+		while (isdigit(str[parse]) or (found_decimal = (str[parse] == '.')) or str[parse] == '{' or str[parse] == '}') {
+			// handle decimal point for precision
+			if (found_decimal) {
+				assertf(is_float_t or is_str_t, "fennec::format syntax error, encountered precision argument on non-floating point format");
+				assertf(num_decimals == 0, "fennec::format syntax error, multiple decimals detected in floating point format");
+				++num_decimals;
+				found_decimal = false;
+
+				fmt.precision = x;
+				x = 0, j = 1;
+				--parse;
+				continue;
+			}
+
+			// check for nested replacement field
+			if (str[parse] == '{') {
+				assertf(str[parse - 1] == '0' or str[parse - 1] == '.' or not isdigit(str[parse - 1]),
+						"fennec::format syntax error, unexpected digit preceding nested replacement field");
+
+				bool prec = str[parse - 1] == '.';
+				bool ded  = str[parse + 1] == '}';
+
+				size_t sub;
+				if (nrfd == 2) { // if both are deduced, parse normally. Hack with prefix and postfix.
+					sub = prec ? ++arg_c + 1 : arg_c++;
+				} else if (nrfd == 1 and nnrf == 2 and prec and ded) { // if only precision is nrf, deduce width first
+					ded_width_f = true;
+					ded_temp_i  = parse;
+					continue;
+				} else { // otherwise deduce normally
+					sub = ded ? ++arg_c : x;
+				}
+
+				assertf(sub < argc, "fennec::format syntax error, argument index out of range in nested replacement field");
+				assertf(argarray.is_integer(sub), "fennec::format argument error, nested replacement field argument is not convertible to integral type");
+
+				(prec ? fmt.precision : fmt.width) = argarray.int_value(sub);
+				x = 0;
+
+				if (ded_width_f) {
+					ded_width_f = false;
+					ded_width   = true;
+					swap(ded_temp_i, parse);
+					arg_c = sub;
+					continue;
+				}
+
+				if (ded_width) {
+					parse     = ded_temp_i;
+					ded_width = false;
+				}
+
+				parse -= 1 + prec;
+				continue;
+			}
+
+			// ignore closing brace for nested replacement fields
+			if (str[parse] == '}') {
+				--parse;
+				continue;
+			}
+
+			// crude way to only handle 0 case if 0 is the last digit
+			fmt.fill = str[parse] == '0' ? '0' : ' ';
+
+			// parse the number
+			x += j * (str[parse] - '0');
+			j *= 10;
+			--parse;
+		}
+		if (x != 0) {
+			fmt.width = x;
+		}
+
+		// early return
+		if (parse == colon) {
+			fmt.sign = fmt.sign == '\0' ? '-' : fmt.sign;
+			res += argarray.format(arg, fmt);
+			i = end + 1;
+			continue;
+		}
+
+		// check for alt form
+		if (str[parse] == '#') {
+			assertf(is_float_t or is_integer_t, "fennec::format syntax error, encountered alt spec ('#') with non-decimal type");
+			fmt.alt = true;
+			--parse;
+		}
+
+		// check for sign
+		if (str[parse] == '-' or str[parse] == '+' or str[parse] == ' ') {
+			fmt.sign = str[parse];
+			if (str[parse] == ' ') { // handle fill if only space, gets overwritten if encounters fill character
+				fmt.fill = ' ';
+			}
+			--parse;
+		}
+
+		// check for alignment
+		if (str[parse] == '<' or str[parse] == '>' or str[parse] == '^') {
+			fmt.align = str[parse];
+			--parse;
+		}
+
+		// fill character
+		if (str[parse] != ':') {
+			fmt.fill = str[parse];
+			if (str[parse] == ' ') {
+				fmt.sign = fmt.sign == '\0' ? ' ' : fmt.sign;
+			}
+			--parse;
+		}
+
+		// default sign
+		fmt.sign = fmt.sign == '\0' ? '-' : fmt.sign;
+
+		// validate that we handled the entire format arg
+		assertf(parse == colon, "fennec::format syntax error, malformed format string detected, possible double colon");
+
+
+		// add formatted argument
+		res += argarray.format(arg, fmt);
+		i = end + 1;
+	}
+
+	return res;
+}
+
+}
+
+#endif // FENNEC_FORMAT_FORMAT_H

include/fennec/format/format_arg.h

@@ -0,0 +1,55 @@
+// =====================================================================================================================
+//  fennec, a free and open source game engine
+//  Copyright © 2025 - 2026  Medusa Slockbower
+//
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+// =====================================================================================================================
+
+///
+/// \file fennec/format/format_arg.h
+/// \brief
+///
+///
+/// \details
+/// \author Medusa Slockbower
+///
+/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
+///
+///
+
+#ifndef FENNEC_FORMAT_FORMAT_ARG_H
+#define FENNEC_FORMAT_FORMAT_ARG_H
+
+#include <fennec/lang/types.h>
+
+namespace fennec
+{
+
+///
+/// \brief helper struct for `fennec::format`
+struct format_arg {
+	char fill;        //!< the fill character of the argument
+	char align;       //!< the alignment of the argument
+	char sign;        //!< the sign to use
+	bool alt;         //!< alternate form
+	bool upper;       //!< print as uppercase
+	size_t width;     //!< the width of the fill
+	size_t precision; //!< the number of decimal points
+	size_t base;      //!< the base to use
+	char   type;      //!< the argument type
+};
+
+}
+
+#endif // FENNEC_FORMAT_FORMAT_ARG_H

include/fennec/format/formatter.h

@@ -0,0 +1,301 @@
+// =====================================================================================================================
+//  fennec, a free and open source game engine
+//  Copyright © 2025 - 2026  Medusa Slockbower
+//
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+// =====================================================================================================================
+
+///
+/// \file fennec/format/formatter.h
+/// \brief
+///
+///
+/// \details
+/// \author Medusa Slockbower
+///
+/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
+///
+///
+
+#ifndef FENNEC_FORMAT_FORMATTER_H
+#define FENNEC_FORMAT_FORMATTER_H
+
+#include <fennec/format/charconv.h>
+#include <fennec/string/string.h>
+#include <fennec/format/format_arg.h>
+
+namespace fennec
+{
+
+// base template =======================================================================================================
+
+///
+/// \brief Formatter struct, used to turn values into formatted strings
+/// \tparam T The type to format
+template<typename T>
+struct formatter {
+	///
+	/// \brief default format function
+	///
+	/// \details throws a static assertion
+	/// \returns empty string
+	string operator()(const format_arg&, const T&) {
+		static_assert(false, "Formatter not implemented for the provided type.");
+		return string("");
+	}
+};
+
+
+// strings =============================================================================================================
+
+///
+/// \brief formatter of a character array
+/// \tparam N the number of characters
+template<size_t N>
+struct formatter<char[N]> {
+	///
+	/// \brief format function
+	/// \param str the string argument
+	/// \returns the formatted version of \f$str\f$
+	string operator()(const format_arg&, const char (&str)[N]) {
+		return string(str);
+	}
+};
+
+///
+/// \brief formatter of a character array
+/// \tparam N the number of characters
+template<size_t N>
+struct formatter<const char[N]> {
+	///
+	/// \brief format function
+	/// \param str the string argument
+	/// \returns the formatted version of \f$str\f$
+	string operator()(const format_arg&, const char (&str)[N]) {
+		return string(str);
+	}
+};
+
+///
+/// \brief formatter of a C-Style string
+template<>
+struct formatter<cstring> {
+	///
+	/// \brief format function
+	/// \param str the string argument
+	/// \returns the formatted version of \f$str\f$
+	string operator()(const format_arg&, const cstring& str) {
+		return str;
+	}
+};
+
+///
+/// \brief formatter of a string
+template<>
+struct formatter<string> {
+	///
+	/// \brief format function
+	/// \param str the string argument
+	/// \returns the formatted version of \f$str\f$
+	string operator()(const format_arg&, const string& str) {
+		return str;
+	}
+};
+
+
+// decimal types =======================================================================================================
+
+///
+/// \brief formatter of integral types
+template<typename IntT> requires(is_integral_v<IntT> and not is_bool_v<IntT>)
+struct formatter<IntT> {
+	///
+	/// \brief format function
+	/// \param fmt the format specification
+	/// \param x the integral argument
+	/// \returns the formatted version of \f$x\f$
+	string operator()(const format_arg& fmt, IntT x) {
+		char digits[128] = {};
+		auto chk = fennec::to_chars(digits, digits + sizeof(digits), fennec::abs(x), fmt.base);
+		assertf(chk != nullptr, "fennec::format error, to_chars error");
+		size_t len = chk - digits;
+
+		// handle uppercase
+		if (fmt.upper) {
+			for (auto& digit : digits) {
+				if (digit == 0) {
+					break;
+				}
+				digit = toupper(digit);
+			}
+		}
+
+		const bool   has_sign = (x < 0 or fmt.sign != '-');
+		const bool   zero     = fmt.fill == '0';
+		const size_t prefix = fmt.alt ? (fmt.type == 'd' ? 0 : 2 - (fmt.type == 'o')) : 0;
+		const size_t sgnlen = len + (zero ? has_sign + prefix : 0);
+		const size_t explen = fennec::max(sgnlen, fmt.width) + (zero ? 0 : has_sign + prefix);
+		const size_t fill   = fmt.width > sgnlen ? fmt.width - sgnlen : 0;
+		size_t sign = 0;
+
+		string res = string(explen);
+
+		if (fill > 0) {
+			switch (fmt.align) {
+				case '<':
+					memcpy(res.data() + has_sign + prefix, digits, len);
+					memset(res.data() + has_sign + prefix + len, fmt.fill == '0' ? ' ' : fmt.fill, fill);
+					break;
+				case '>': case '\0':
+					memcpy(res.data() + explen - len, digits, len);
+					sign = fmt.fill == '0' ? 0 : explen - len - 1 - prefix;
+					memset(res.data(), fmt.fill, explen - len);
+					break;
+				case '^':
+					size_t bef = fill / 2 + has_sign + prefix;
+					size_t aft = explen - bef;
+					memcpy(res.data() + bef, digits, len);
+					sign = fmt.fill == '0' ? 0 : bef - 1 - prefix;
+					memset(res.data(), fmt.fill, bef);
+					memset(res.data() + bef + len, fmt.fill == '0' ? ' ' : fmt.fill, aft);
+					break;
+
+
+			}
+		} else {
+			memcpy(res.data() + has_sign + prefix, digits, len);
+		}
+
+		if (has_sign) {
+			res[sign] = (x < 0) ? '-' : fmt.sign;
+		}
+
+		if (prefix) {
+			res[sign + has_sign] = '0';
+			if (fmt.type != 'o') {
+				res[sign + has_sign + 1] = fmt.type;
+			}
+		}
+
+		return res;
+	}
+};
+
+///
+/// \brief formatter of boolean types
+template<typename BoolT> requires(is_bool_v<BoolT>)
+struct formatter<BoolT> {
+	///
+	/// \brief format function
+	/// \param fmt the format specification
+	/// \param x the boolean argument
+	/// \returns the formatted version of \f$x\f$
+	string operator()(const format_arg& fmt, BoolT x) {
+		if (fmt.type == 's' or fmt.type == '\0') {
+			return x ? string("true") : string("false");
+		}
+
+		return formatter<uint8_t>{}(fmt, static_cast<uint8_t>(x));
+	}
+};
+
+///
+/// \brief formatter of floating point types
+template<typename FloatT> requires(is_floating_point_v<FloatT>)
+struct formatter<FloatT> {
+	///
+	/// \brief format function
+	/// \param fmt the format specification
+	/// \param x the float argument
+	/// \returns the formatted version of \f$x\f$
+	string operator()(const format_arg& fmt, FloatT x) {
+
+		// nan & inf cases
+		if (fennec::isnan(x)) {
+			return string("nan");
+		}
+		if (fennec::isinf(x)) {
+			return string("inf");
+		}
+
+
+		char digits[128] = {};
+		auto chk = fennec::to_chars(digits, digits + sizeof(digits), fennec::abs(x), fmt.type, fmt.precision);
+		assertf(chk != nullptr, "fennec::format error, to_chars error");
+		size_t len = chk - digits;
+
+		// handle uppercase
+		if (fmt.upper) {
+			for (auto& digit : digits) {
+				if (digit == 0) {
+					break;
+				}
+				digit = toupper(digit);
+			}
+		}
+
+		const bool   has_sign = (x < 0 or fmt.sign != '-');
+		const bool   zero     = fmt.fill == '0';
+		const size_t prefix = fmt.alt ? 2 : 0;
+		const size_t sgnlen = len + (zero ? has_sign + prefix : 0);
+		const size_t explen = fennec::max(sgnlen, fmt.width) + (zero ? 0 : has_sign + prefix);
+		const size_t fill   = fmt.width > sgnlen ? fmt.width - sgnlen : 0;
+		size_t sign = 0;
+
+		string res = string(explen);
+
+		if (fill > 0) {
+			switch (fmt.align) {
+				case '<':
+					memcpy(res.data() + has_sign + prefix, digits, len);
+					memset(res.data() + has_sign + prefix + len, fmt.fill == '0' ? ' ' : fmt.fill, fill);
+					break;
+				case '>': case '\0':
+					memcpy(res.data() + explen - len, digits, len);
+					sign = fmt.fill == '0' ? 0 : explen - len - 1 - prefix;
+					memset(res.data(), fmt.fill, explen - len);
+					break;
+				case '^':
+					size_t bef = fill / 2 + has_sign + prefix;
+					size_t aft = explen - bef;
+					memcpy(res.data() + bef, digits, len);
+					sign = fmt.fill == '0' ? 0 : bef - 1 - prefix;
+					memset(res.data(), fmt.fill, bef);
+					memset(res.data() + bef + len, fmt.fill == '0' ? ' ' : fmt.fill, aft);
+					break;
+
+
+			}
+		} else {
+			memcpy(res.data() + has_sign + prefix, digits, len);
+		}
+
+		if (has_sign) {
+			res[sign] = (x < 0) ? '-' : fmt.sign;
+		}
+
+		if (prefix) {
+			res[sign + has_sign] = '0';
+			res[sign + has_sign + 1] = fmt.type + ('x' - 'a');
+		}
+
+		return res;
+	}
+
+
+};
+
+}
+
+#endif // FENNEC_FORMAT_FORMATTER_H

include/fennec/interpret/tokenizer.h

@@ -0,0 +1,113 @@
+// =====================================================================================================================
+//  fennec, a free and open source game engine
+//  Copyright © 2025 - 2026  Medusa Slockbower
+//
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+// =====================================================================================================================
+
+///
+/// \file fennec/interpret/tokenizer.h
+/// \brief
+///
+///
+/// \details
+/// \author Medusa Slockbower
+///
+/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
+///
+///
+
+#ifndef FENNEC_INTERPRET_TOKENIZER_H
+#define FENNEC_INTERPRET_TOKENIZER_H
+
+#include <fennec/containers/list.h>
+#include <fennec/containers/map.h>
+#include <fennec/containers/priority_queue.h>
+#include <fennec/string/string.h>
+
+//
+// escape sequences are tricky, sometimes they must be separated by white space,
+// other times they don't. Requiring a list of all possible escape sequences is unrealistic.
+// We need to allow the user of this struct to specify rules for escape sequences. Here are some basic rules:
+//
+// An escape sequence is marked by an escape character, e.g. %, \, {{
+// Multiple escape characters may be used in a single tokenizer and will have different rules
+// Escape characters may also be operators, brackets, or quotes
+// Escape sequences may contain operators, brackets, or quotes
+//
+// Here are a few examples of escape sequences from various formats and languages
+// C: \\, \n, \0, \u200b
+// PrintF: %s, %2.2f
+// Python FMT: {{, }}
+// SPSS: ''
+//
+
+namespace fennec
+{
+///
+/// \brief Escape Sequence Specification
+struct escape_sequence {
+	virtual size_t operator[](const string& str, size_t i) = 0;
+};
+
+struct tokenizer {
+	using escseq = escape_sequence*;
+	using escmap = map<char, escape_sequence*>;
+
+	string delimiter; //!< markers that separate tokens
+	string operators; //!< operators are treated as individual tokens
+	string brackets;  //!< characters that mark brackets
+	string quotes;    //!< characters that mark a string sequence, entire string sequence is treated as one token
+	escmap escapes;   //!< characters that mark the start of an escape sequence and validate them
+	bool   numbers;   //!< Anything that resembles a number
+
+	enum token_ : uint8_t {
+		token_text     = 0,
+		token_integer,
+		token_string,
+		token_newline,
+		token_escaped,
+		token_operator,
+		token_bracket,
+		token_quoted,
+
+		num_token_types
+	};
+
+	using token = pair<string, uint8_t>;
+
+private:
+	static constexpr uint8_t token_delimiter = num_token_types;
+
+	constexpr list<token> operator()(const string& line) {
+		list<token> res;
+		priority_queue<pair<size_t, uint8_t>> idx;
+
+		for (char c : delimiter) {
+			size_t i = 0;
+			while (i != line.size()) {
+				size_t n = line.find(c, i);
+				// TODO
+			}
+		}
+
+		return res;
+	}
+
+private:
+};
+
+}
+
+#endif // FENNEC_INTERPRET_TOKENIZER_H

include/fennec/lang/assert.h

@@ -1,6 +1,6 @@
 // =====================================================================================================================
 //  fennec, a free and open source game engine
-//  Copyright © 2025  Medusa Slockbower
+//  Copyright © 2025 - 2026  Medusa Slockbower
 //
 //  This program is free software: you can redistribute it and/or modify
 //  it under the terms of the GNU General Public License as published by
@@ -17,20 +17,22 @@
 // =====================================================================================================================
 
 ///
-/// \file assert.h
+/// \file fennec/lang/assert.h
 /// \brief \ref fennec_lang_assert
 ///
 ///
 /// \details
 /// \author Medusa Slockbower
 ///
-/// \copyright Copyright © 2025 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
+/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
 ///
 ///
 
 #ifndef FENNEC_LANG_ASSERT_H
 #define FENNEC_LANG_ASSERT_H
 
+#include <fennec/lang/types.h>
+
 ///
 /// \page fennec_lang_assert Assertions
 ///
@@ -46,18 +48,18 @@
 /// <tr><td width="50%" style="vertical-align: top"> <br>
 ///         assert(expr, desc)
 ///     <td width="50%" style="vertical-align: top">
-///         Make an assertion with expression `expr` and provide a description `desc`. Only halts in debug mode.
+///         Make an assertion with expression \f$expr\f$ and provide a description \f$desc\f$. Only halts in debug mode.
 ///
 /// <tr><td width="50%" style="vertical-align: top"> <br>
 ///         assertf(expr, desc)
 ///     <td width="50%" style="vertical-align: top">
-///         Make an assertion with expression `expr` and provide a description `desc`. Always halts.
+///         Make an assertion with expression \f$expr\f$ and provide a description \f$desc\f$. Always halts.
 ///
 /// <tr><td width="50%" style="vertical-align: top"> <br>
 ///         assertd(expr, desc)
 ///     <td width="50%" style="vertical-align: top">
-///         Make an assertion, ***only in debug mode***, with expression `expr` and provide a description `desc`.
+///         Make an assertion, ***only in debug mode***, with expression \f$expr\f$ and provide a description \f$desc\f$.
-///         This should be used when the branching caused by `assert` would hinder performance in release mode.
+///         This should be used when the branching caused by \f$assert\f$ would hinder performance in release mode.
 ///
 /// </table>
 ///
@@ -68,21 +70,44 @@
 #define __PRETTY_FUNCTION__ __FUNCSIG__
 #endif
 
-using assert_handler = void (*)(const char *, const char *, int , const char *);
+#ifndef FENNEC_DOXYGEN
+void _assert_impl(const char* expr, size_t expr_l,
+	              const char* file, size_t file_l, int line,
+	              const char* func, size_t func_l,
+	              const char* desc, bool halt);
 
-void _assert_impl(const char* expression, const char* file, int line, const char* function, const char* desc, bool halt);
+template<size_t ExprL, size_t FileL, size_t FuncL>
+void _assert(const char (&expr)[ExprL],
+	         const char (&file)[FileL], int line,
+	         const char (&func)[FuncL],
+	         const char* desc,
+	         bool halt) {
+	::_assert_impl(expr, ExprL, file, FileL, line, func, FuncL, desc, halt);
+}
+#endif
 
-// flagged unlikely to optimize branch prediction
+///
+/// \brief base assert function, halts only in debug mode
+/// \param expression the expression to validate
+/// \param description the description of the assertion
 #define assert(expression, description) \
 	if(not(expression)) [[unlikely]] { \
-		_assert_impl(#expression, __FILE__, __LINE__, __PRETTY_FUNCTION__, description, not FENNEC_RELEASE); \
+		_assert(#expression, __FILE__, __LINE__, __PRETTY_FUNCTION__, description, not FENNEC_RELEASE); \
 	}
 
+///
+/// \brief fail assert function, always halts
+/// \param expression the expression to validate
+/// \param description the description of the assertion
 #define assertf(expression, description) \
 	if(not(expression)) [[unlikely]] { \
-		_assert_impl(#expression, __FILE__, __LINE__, __PRETTY_FUNCTION__, description, true); \
+		_assert(#expression, __FILE__, __LINE__, __PRETTY_FUNCTION__, description, true); \
 	}
 
+///
+/// \brief debug assert function, only defined in debug mode
+/// \param expression the expression to validate
+/// \param description the description of the assertion
 #if FENNEC_RELEASE
 #define assertd(expression, description)
 #else

include/fennec/lang/bits.h

@@ -1,6 +1,6 @@
 // =====================================================================================================================
 //  fennec, a free and open source game engine
-//  Copyright © 2025  Medusa Slockbower
+//  Copyright © 2025 - 2026  Medusa Slockbower
 //
 //  This program is free software: you can redistribute it and/or modify
 //  it under the terms of the GNU General Public License as published by
@@ -17,14 +17,14 @@
 // =====================================================================================================================
 
 ///
-/// \file bits.h
+/// \file fennec/lang/bits.h
 /// \brief \ref fennec_lang_bit_manipulation
 ///
 ///
 /// \details
 /// \author Medusa Slockbower
 ///
-/// \copyright Copyright © 2025 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
+/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
 ///
 ///
 

include/fennec/lang/compare.h

@@ -1,6 +1,6 @@
 // =====================================================================================================================
 //  fennec, a free and open source game engine
-//  Copyright © 2025  Medusa Slockbower
+//  Copyright © 2025 - 2026  Medusa Slockbower
 //
 //  This program is free software: you can redistribute it and/or modify
 //  it under the terms of the GNU General Public License as published by
@@ -26,27 +26,58 @@ namespace fennec
 
 // equality ============================================================================================================
 
+///
+/// \brief Struct to test equality of two values
+/// \tparam T0 The first type
+/// \tparam T1 The second type
 template<typename T0, typename T1 = T0> struct equality;
 
+///
+/// \brief Implementations for two types that have a common equality operator \f$==\f$
+/// \tparam T0 The first type
+/// \tparam T1 The second type
 template<typename T0, typename T1> requires has_equals_v<T0, T1>
 struct equality<T0, T1> {
+	///
+	/// \brief operator to test the two values
+	/// \param x the value of type \f$T0\f$
+	/// \param y the value of type \f$T1\f$
+	/// \returns \f$true\f$ if equal, \f$false\f$ otherwise
 	constexpr bool operator()(const T0& x, const T1& y) const {
 		return x == y;
 	}
 };
 
+///
+/// \brief Implementations for two types that have a common less operator \f$<\f$
+/// \tparam T0 The first type
+/// \tparam T1 The second type
 template<typename T0, typename T1> requires(not has_equals_v<T0, T1>
 	                                        and has_less_v<T0, T1> and has_less_v<T1, T0>)
 struct equality<T0, T1> {
+	///
+	/// \brief operator to test the two values
+	/// \param x the value of type \f$T0\f$
+	/// \param y the value of type \f$T1\f$
+	/// \returns \f$true\f$ if equal, \f$false\f$ otherwise
 	constexpr bool operator()(const T0& x, const T1& y) const {
 		return not(x < y) and not(y < x);
 	}
 };
 
+///
+/// \brief Implementations for two types that have a common greater operator \f$>\f$
+/// \tparam T0 The first type
+/// \tparam T1 The second type
 template<typename T0, typename T1> requires(not(has_equals_v<T0, T1>)
 	                                        and(not has_less_v<T0, T1> or not has_less_v<T1, T0>)
 	                                        and(has_greater_v<T0, T1> and has_greater_v<T1, T0>))
 struct equality<T0, T1> {
+	///
+	/// \brief operator to test the two values
+	/// \param x the value of type \f$T0\f$
+	/// \param y the value of type \f$T1\f$
+	/// \returns \f$true\f$ if equal, \f$false\f$ otherwise
 	constexpr bool operator()(const T0& x, const T1& y) const {
 		return not(x > y) and not(y > x);
 	}
@@ -55,24 +86,72 @@ struct equality<T0, T1> {
 
 // inequality ==========================================================================================================
 
+///
+/// \brief Struct to test inequality of two values
+/// \tparam T0 The first type
+/// \tparam T1 The second type
 template<typename T0, typename T1 = T0> struct inequality;
 
+///
+/// \brief Implementations for two types that have a common inequality operator \f$\neq\f$
+/// \tparam T0 The first type
+/// \tparam T1 The second type
 template<typename T0, typename T1> requires has_nequals_v<T0, T1>
 struct inequality<T0, T1> {
+	///
+	/// \brief operator to test the two values
+	/// \param x the value of type \f$T0\f$
+	/// \param y the value of type \f$T1\f$
+	/// \returns \f$true\f$ if not equal, \f$false\f$ otherwise
 	constexpr bool operator()(const T0& x, const T1& y) const {
 		return x != y;
 	}
 };
 
+
+///
+/// \brief Implementations for two types that have a common equality operator \f$==\f$
+/// \tparam T0 The first type
+/// \tparam T1 The second type
+template<typename T0, typename T1> requires has_equals_v<T0, T1>
+struct inequality<T0, T1> {
+	///
+	/// \brief operator to test the two values
+	/// \param x the value of type \f$T0\f$
+	/// \param y the value of type \f$T1\f$
+	/// \returns \f$true\f$ if not equal, \f$false\f$ otherwise
+	constexpr bool operator()(const T0& x, const T1& y) const {
+		return not (x == y);
+	}
+};
+
+///
+/// \brief Implementations for two types that have a common less operator \f$<\f$
+/// \tparam T0 The first type
+/// \tparam T1 The second type
 template<typename T0, typename T1> requires has_less_v<T0, T1> and has_less_v<T1, T0>
 struct inequality<T0, T1> {
+	///
+	/// \brief operator to test the two values
+	/// \param x the value of type \f$T0\f$
+	/// \param y the value of type \f$T1\f$
+	/// \returns \f$true\f$ if not equal, \f$false\f$ otherwise
 	constexpr bool operator()(const T0& x, const T1& y) const {
 		return (x < y) or (y < x);
 	}
 };
 
+///
+/// \brief Implementations for two types that have a common greater operator \f$>\f$
+/// \tparam T0 The first type
+/// \tparam T1 The second type
 template<typename T0, typename T1> requires has_greater_v<T0, T1> and has_greater_v<T1, T0>
 struct inequality<T0, T1> {
+	///
+	/// \brief operator to test the two values
+	/// \param x the value of type \f$T0\f$
+	/// \param y the value of type \f$T1\f$
+	/// \returns \f$true\f$ if not equal, \f$false\f$ otherwise
 	constexpr bool operator()(const T0& x, const T1& y) const {
 		return (x > y) or (y > x);
 	}
@@ -81,8 +160,17 @@ struct inequality<T0, T1> {
 
 // less ================================================================================================================
 
+///
+/// \brief Struct to test if a value of type \f$T0\f$ is less than a value of type \f$T1\f$
+/// \tparam T0 The first type
+/// \tparam T1 The second type
 template<typename T0, typename T1 = T0> requires has_less_v<T0, T1>
 struct less {
+	///
+	/// \brief operator to test the two values
+	/// \param x the value of type \f$T0\f$
+	/// \param y the value of type \f$T1\f$
+	/// \returns \f$true\f$ if less, \f$false\f$ otherwise
 	constexpr bool operator()(const T0& x, const T1& y) const {
 		return x < y;
 	}
@@ -91,30 +179,57 @@ struct less {
 
 // less_equal ==========================================================================================================
 
+///
+/// \brief Struct to test if a value of type \f$T0\f$ is less than or equal to a value of type \f$T1\f$
+/// \tparam T0 The first type
+/// \tparam T1 The second type
 template<typename T0, typename T1 = T0> requires has_less_equals_v<T0, T1>
 struct less_equals {
+	///
+	/// \brief operator to test the two values
+	/// \param x the value of type \f$T0\f$
+	/// \param y the value of type \f$T1\f$
+	/// \returns \f$true\f$ if less than or equal, \f$false\f$ otherwise
 	constexpr bool operator()(const T0& x, const T1& y) const {
 		return x <= y;
 	}
 };
 
 
-// less ================================================================================================================
+// greater =============================================================================================================
 
+///
+/// \brief Struct to test if a value of type \f$T0\f$ is greater than a value of type \f$T1\f$
+/// \tparam T0 The first type
+/// \tparam T1 The second type
 template<typename T0, typename T1 = T0> requires has_greater_v<T0, T1>
 struct greater {
+	///
+	/// \brief operator to test the two values
+	/// \param x the value of type \f$T0\f$
+	/// \param y the value of type \f$T1\f$
+	/// \returns \f$true\f$ if greater, \f$false\f$ otherwise
 	constexpr bool operator()(const T0& x, const T1& y) const {
-		return x < y;
+		return x > y;
 	}
 };
 
 
 // less_equal ==========================================================================================================
 
+///
+/// \brief Struct to test if a value of type \f$T0\f$ is greater than or equal to a value of type \f$T1\f$
+/// \tparam T0 The first type
+/// \tparam T1 The second type
 template<typename T0, typename T1 = T0> requires has_greater_equals_v<T0, T1>
 struct greater_equals {
+	///
+	/// \brief operator to test the two values
+	/// \param x the value of type \f$T0\f$
+	/// \param y the value of type \f$T1\f$
+	/// \returns \f$true\f$ if greater than or equal, \f$false\f$ otherwise
 	constexpr bool operator()(const T0& x, const T1& y) const {
-		return x <= y;
+		return x >= y;
 	}
 };
 

include/fennec/lang/conditional_types.h

@@ -1,6 +1,6 @@
 // =====================================================================================================================
 //  fennec, a free and open source game engine
-//  Copyright © 2025  Medusa Slockbower
+//  Copyright © 2025 - 2026  Medusa Slockbower
 //
 //  This program is free software: you can redistribute it and/or modify
 //  it under the terms of the GNU General Public License as published by
@@ -17,14 +17,14 @@
 // =====================================================================================================================
 
 ///
-/// \file conditional_types.h
+/// \file fennec/lang/conditional_types.h
 /// \brief \ref fennec_lang_conditional_types
 ///
 ///
 /// \details
 /// \author Medusa Slockbower
 ///
-/// \copyright Copyright © 2025 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
+/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
 ///
 ///
 
@@ -75,7 +75,7 @@ namespace fennec
 /// \brief select between two types based on a condition
 ///
 /// \details Selects between \p TrueT and \p FalseT based on the boolean value \p b.
-///	         The chosen type is stored in `conditional::type`.
+///	         The chosen type is stored in `fennec::conditional::type`.
 /// \tparam B the value of the condition
 /// \tparam TrueT type to use when \f$B == true\f$
 /// \tparam FalseT type to use when \f$B == false\f$
@@ -84,45 +84,46 @@ struct conditional;
 
 
 ///
-/// \brief Shorthand for ```typename conditional<ConditionV, TrueT, FalseT>::type```
+/// \brief Shorthand for `typename fennec::conditional<ConditionV, TrueT, FalseT>::type`
 template<bool B, typename TrueT, typename FalseT>
 using conditional_t
 	= typename conditional<B, TrueT, FalseT>::type;
 
-
+#ifndef FENNEC_DOXYGEN
-// specialization of fennec::conditional for `true` case
+// specialization of fennec::conditional for \f$true\f$ case
 template<typename T, typename F>
 struct conditional<true, T, F> : type_identity<T>{};
 
 
-// specialization of fennec::conditional for `false` case
+// specialization of fennec::conditional for \f$false\f$ case
 template<typename T, typename F>
 struct conditional<false, T, F> : type_identity<F>{};
-
+#endif
 
 // fennec::detect ======================================================================================================
 
 ///
-/// \brief Detect whether `DetectT<ArgsT...>` is a valid type
+/// \brief Detect whether \f$DetectT<ArgsT...>\f$ is a valid type
 ///
-/// \details Selects `DetectT<ArgsT...>` if it exists, otherwise selects `DefaultT` The chosen type is stored in `detect::type` and
+/// \details Selects \f$DetectT<ArgsT...>\f$ if it exists, otherwise selects \f$DefaultT\f$ The chosen type is stored in `fennec::detect::type` and
-///          a boolean value is stored in `detect::is_detected` representing whether `DetectT<ArgsT...>` is found.
+///          a boolean value is stored in `fennec::detect::is_detected` representing whether \f$DetectT<ArgsT...>\f$ is found.
 /// \tparam DefaultT Default type
 /// \tparam DetectT Type to detect
-/// \tparam ArgsT Any template arguments for `DetectT<ArgsT>`
+/// \tparam ArgsT Any template arguments for \f$DetectT<ArgsT>\f$
 template<typename DefaultT, template<typename...> typename DetectT, typename...ArgsT>
 struct detect
 {
-	using type = DefaultT;
+	using type = DefaultT;                     //!< the detected type
-	static constexpr bool is_detected = false;
+	static constexpr bool is_detected = false; //!< whether it was detected
 };
 
 ///
-/// \brief Shorthand for ```typename detect<DefaultT, DetectT, ArgsT...>::type```
+/// \brief Shorthand for `typename fennec::detect<DefaultT, DetectT, ArgsT...>::type`
 template<typename DefaultT, template<typename...> typename DetectT, typename...ArgsT>
 using detect_t = typename detect<DefaultT, DetectT, ArgsT...>::type;
 
 
+#ifndef FENNEC_DOXYGEN
 // true case
 template<typename DefaultT, template<typename...> typename DetectT, typename...ArgsT>
 	requires requires { typename DetectT<ArgsT...>; }
@@ -131,6 +132,7 @@ struct detect<DefaultT, DetectT, ArgsT...>
 	using type = DetectT<ArgsT...>;
 	static constexpr bool is_detected = true;
 };
+#endif
 
 
 // fennec::enable_if ===================================================================================================
@@ -138,7 +140,7 @@ struct detect<DefaultT, DetectT, ArgsT...>
 ///
 /// \brief Leverage SFINAE to conditionally enable a function or class at compile-time
 ///
-/// \details If `B` is `true`, define a public member type `type`. Otherwise, there is no member. <br>
+/// \details If \f$B\f$ is \f$true\f$, define a public member type \f$type\f$. Otherwise, there is no member. <br>
 ///	         **Example Usage**
 ///	         \code{.cpp}
 ///          template<typename TypeT,
@@ -152,13 +154,15 @@ template<bool B, typename T = void>
 struct enable_if {};
 
 ///
-/// \brief Shorthand for ```typename enable_if<B, T>::type```
+/// \brief Shorthand for `typename fennec::enable_if<B, T>::type`
 template<bool B, typename T = void>
 using enable_if_t = typename enable_if<B, T>::type;
 
+#ifndef FENNEC_DOXYGEN
 // true case
 template<typename T>
 struct enable_if<true, T> { using type = T; };
+#endif
 
 }
 

include/fennec/lang/const_sequences.h

@@ -1,246 +0,0 @@
-// =====================================================================================================================
-//  fennec, a free and open source game engine
-//  Copyright © 2025  Medusa Slockbower
-//
-//  This program is free software: you can redistribute it and/or modify
-//  it under the terms of the GNU General Public License as published by
-//  the Free Software Foundation, either version 3 of the License, or
-//  (at your option) any later version.
-//
-//  This program is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//  GNU General Public License for more details.
-//
-//  You should have received a copy of the GNU General Public License
-//  along with this program.  If not, see <https://www.gnu.org/licenses/>.
-// =====================================================================================================================
-
-///
-/// \file sequences.h
-/// \brief \ref fennec_lang_sequences
-///
-///
-/// \details
-/// \author Medusa Slockbower
-///
-/// \copyright Copyright © 2025 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
-///
-///
-
-#ifndef FENNEC_LANG_SEQUENCES_H
-#define FENNEC_LANG_SEQUENCES_H
-
-///
-/// \page fennec_lang_sequences Sequences
-///
-/// \brief This header is part of the metaprogramming library. It defines structures for sequences of values, used during compile time.
-///
-/// \code #include <fennec/lang/sequences.h> \endcode
-///
-/// <table width="100%" class="fieldtable" id="table_fennec_lang_sequences">
-/// <tr><th style="vertical-align: top">Syntax
-///     <th style="vertical-align: top">Description
-///
-/// <tr><td width="50%" style="vertical-align: top"> <br>
-///         \ref fennec::sequence "sequence<ValueT, Values...>"<br>
-///     <td width="50%" style="vertical-align: top">
-///         \copydetails fennec::sequence
-///
-/// <tr><td width="50%" style="vertical-align: top"> <br>
-///         \ref fennec::integer_sequence "integer_sequence<IntT, Values...>"<br>
-///         \ref fennec::make_integer_sequence "typename make_integer_sequence<IntT, N>::type"<br>
-///         \ref fennec::make_integer_sequence_t "make_integer_sequence_t<IntT, N>"
-///     <td width="50%" style="vertical-align: top">
-///         \copydetails fennec::integer_sequence
-///
-/// <tr><td width="50%" style="vertical-align: top"> <br>
-///         \ref fennec::index_sequence "index_sequence<Indices...>"<br>
-///         \ref fennec::make_index_sequence "typename make_index_sequence<N>::type"<br>
-///         \ref fennec::make_index_sequence_t "make_index_sequence_t<N>"
-///     <td width="50%" style="vertical-align: top">
-///         \copydetails fennec::index_sequence
-///
-/// <tr><td width="50%" style="vertical-align: top"> <br>
-///         \ref fennec::concat_sequence "typename concat_sequence<SequenceT0, SequenceT1>::type"<br>
-///         \ref fennec::concat_sequence_t "concat_sequence_t<SequenceT0, SequenceT1>"<br>
-///     <td width="50%" style="vertical-align: top">
-///         \copydetails fennec::concat_sequence
-///
-/// </table>
-///
-
-#include <fennec/lang/type_traits.h>
-
-namespace fennec
-{
-
-// fennec::sequence ====================================================================================================
-
-///
-/// \brief metaprogramming sequence
-///
-/// \details Stores a sequence of values of type `ValueT` as a template pack.
-///          You can access the parameter pack in another template function, i.e.
-///          \code{cpp}
-///          template<typename TypeT, TypeT...Values>
-///          constexpr TypeT summation(sequence<TypeT, Values...>)
-///          {
-///              return (Values + ...);
-///          }
-///          \endcode
-/// \tparam ValueT type of the values
-/// \tparam Values sequence values
-template<typename ValueT, ValueT...Values> struct const_sequence
-{
-	/// \brief type of the sequence
-	using value_type = ValueT;
-
-	/// \brief self-referential type
-	using type = const_sequence;
-
-	///
-	/// \brief returns the number of elements
-	///
-	/// \return number of elements in the array
-	inline static constexpr size_t size() noexcept {
-		return sizeof...(Values);
-	}
-};
-
-
-
-// fennec::integer_sequence ============================================================================================
-
-///
-/// \brief metaprogramming integral sequence
-///
-/// \details A `fennec::sequence` specialized integer types.
-/// \tparam IntT type of the values, must satisfy ```fennec::is_integral<T>```
-/// \tparam Values sequence values
-template<typename IntT, IntT...Values> requires(is_integral_v<IntT>)
-struct const_integer_sequence : const_sequence<IntT, Values...>
-{
-	/// \brief type of the sequence
-	using value_type = IntT;
-
-	/// \brief self-referential type
-	using type = const_integer_sequence;
-
-	///
-	/// \brief returns the number of elements
-	///
-	/// \return number of elements in the array
-	inline static constexpr size_t size() noexcept {
-		return sizeof...(Values);
-	}
-};
-
-
-///
-/// \brief generate a fennec::integer_sequence \f$\left[\,0\,\ldots\,N\,\right)\f$
-///
-/// \details
-/// \tparam IntT type of the values, must satisfy ```fennec::is_integral<T>```
-/// \tparam N size of the sequence to generate
-template<typename IntT, size_t N> struct make_integer_sequence;
-
-///
-/// \brief shorthand for ```typename make_integer_sequence<T, N>::type```
-template<typename IntT, size_t N> using  make_integer_sequence_t = typename make_integer_sequence<IntT, N>::type;
-
-
-
-// fennec::index_sequence ==============================================================================================
-
-///
-/// \brief metaprogramming integral sequence
-///
-/// \details A `fennec::integer_sequence` specialized for sequences of `size_t` indices.
-/// \tparam Indices sequence values
-template<size_t...Indices> struct const_index_sequence : const_integer_sequence<size_t, Indices...>
-{
-	/// \brief type of the sequence
-	using value_type = size_t;
-
-	/// \brief self-referential type
-	using type = const_index_sequence;
-
-	///
-	/// \brief returns the number of elements
-	///
-	/// \return number of elements in the array
-	inline static constexpr size_t size() noexcept {
-		return sizeof...(Indices);
-	}
-};
-
-
-///
-/// \brief generate a fennec::index_sequence \f$\left[\,0\,\ldots\,N\,\right)\f$
-///
-/// \details
-/// \tparam T type of the values, must satisfy ```fennec::is_integral<T>```
-/// \tparam N size of the sequence to generate
-template<size_t N> struct make_index_sequence;
-
-///
-/// \brief shorthand for ```typename make_index_sequence<N>::type```
-template<size_t N> using  make_index_sequence_t = typename make_index_sequence<N>::type;
-
-
-
-// fennec::concat_sequence =============================================================================================
-
-///
-/// \brief concatenate two sequences
-///
-/// \details A tool for concatenating two `fennec::sequence` types.
-/// \tparam SequenceT0 lhs
-/// \tparam SequenceT1 rhs
-template<typename SequenceT0, typename SequenceT1> struct concat_sequence;
-
-///
-/// \brief shorthand for ```typename concat_sequence<SequenceT0, SequenceT1>::type```
-template<typename SequenceT0, typename SequenceT1> using concat_sequence_t
-	= typename concat_sequence<SequenceT0, SequenceT1>::type;
-
-
-
-// Internal ============================================================================================================
-
-// Implementation for Generating an integer_sequence
-template<typename T, size_t N> struct make_integer_sequence : concat_sequence_t<make_integer_sequence_t<T, N / 2>, make_integer_sequence_t<T, N - N / 2>>{};
-
-// Base Case of N=0
-template<typename T> struct make_integer_sequence<T, 0> : const_integer_sequence<T> {};
-
-// Base Case of N=1
-template<typename T> struct make_integer_sequence<T, 1> : const_integer_sequence<T, 0>{};
-
-
-// Implementation for Generating an index_sequence
-template<size_t N> struct make_index_sequence : concat_sequence_t<make_index_sequence_t<N / 2>, make_index_sequence_t<N - N / 2>>{};
-
-// Base Case of N=0
-template<> struct make_index_sequence<0> : const_index_sequence<> {};
-
-// Base Case of N=1
-template<> struct make_index_sequence<1> : const_index_sequence<0>{};
-
-
-// Specialization for integer sequences
-template<typename T, T...SequenceV0, T...SequenceV1>
-struct concat_sequence<const_integer_sequence<T, SequenceV0...>, const_integer_sequence<T, SequenceV1...>>
-	: const_integer_sequence<T, SequenceV0..., (sizeof...(SequenceV0) + SequenceV1)...>{};
-
-// Specialization for index sequences
-template<size_t...SequenceV0, size_t...SequenceV1>
-struct concat_sequence<const_index_sequence<SequenceV0...>, const_index_sequence<SequenceV1...>>
-	: const_index_sequence<SequenceV0..., (sizeof...(SequenceV0) + SequenceV1)...>{};
-
-
-
-}
-
-#endif // FENNEC_LANG_SEQUENCES_H

include/fennec/lang/constants.h

@@ -1,6 +1,6 @@
 // =====================================================================================================================
 //  fennec, a free and open source game engine
-//  Copyright © 2025  Medusa Slockbower
+//  Copyright © 2025 - 2026  Medusa Slockbower
 //
 //  This program is free software: you can redistribute it and/or modify
 //  it under the terms of the GNU General Public License as published by
@@ -17,14 +17,14 @@
 // =====================================================================================================================
 
 ///
-/// \file constants.h
+/// \file fennec/lang/constants.h
 /// \brief \ref fennec_lang_constants
 ///
 ///
 /// \details
 /// \author Medusa Slockbower
 ///
-/// \copyright Copyright © 2025 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
+/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
 ///
 ///
 

include/fennec/lang/declval.h

@@ -0,0 +1,52 @@
+// =====================================================================================================================
+//  fennec, a free and open source game engine
+//  Copyright © 2025 - 2026  Medusa Slockbower
+//
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+// =====================================================================================================================
+
+///
+/// \file fennec/lang/declval.h
+/// \brief
+///
+///
+/// \details
+/// \author Medusa Slockbower
+///
+/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
+///
+///
+
+#ifndef FENNEC_LANG_DECLVAL_H
+#define FENNEC_LANG_DECLVAL_H
+
+#include <fennec/lang/detail/_declval.h>
+
+namespace fennec
+{
+
+// fennec::declval =====================================================================================================
+
+///
+/// \brief Metaprogramming helper for testing values of type T
+/// \tparam T the type
+/// \returns a metavalue of type \f$T\f$
+template<typename T> auto declval() noexcept -> decltype(detail::_declval<T>(0)) {
+	static_assert(detail::_declval_protector<T>{}, "declval must not be used");
+	return detail::_declval<T>(0);
+}
+
+}
+
+#endif // FENNEC_LANG_DECLVAL_H

include/fennec/lang/detail/_bits.h

@@ -1,6 +1,6 @@
 // =====================================================================================================================
 //  fennec, a free and open source game engine
-//  Copyright © 2025  Medusa Slockbower
+//  Copyright © 2025 - 2026  Medusa Slockbower
 //
 //  This program is free software: you can redistribute it and/or modify
 //  it under the terms of the GNU General Public License as published by

include/fennec/lang/detail/_declval.h

@@ -0,0 +1,34 @@
+// =====================================================================================================================
+//  fennec, a free and open source game engine
+//  Copyright © 2025 - 2026  Medusa Slockbower
+//
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+// =====================================================================================================================
+
+#ifndef FENNEC_LANG_DETAIL_DECLVAL_H
+#define FENNEC_LANG_DETAIL_DECLVAL_H
+
+#include <fennec/lang/constants.h>
+
+namespace fennec::detail
+{
+
+template<typename T, typename U = T&&> U _declval(int);
+template<typename T>                   T _declval(long);
+
+template<typename T> struct _declval_protector : bool_constant<false> {};
+
+}
+
+#endif // FENNEC_LANG_DETAIL_DECLVAL_H

include/fennec/lang/detail/_function.h

@@ -1,6 +1,6 @@
 // =====================================================================================================================
 //  fennec, a free and open source game engine
-//  Copyright © 2025  Medusa Slockbower
+//  Copyright © 2025 - 2026  Medusa Slockbower
 //
 //  This program is free software: you can redistribute it and/or modify
 //  it under the terms of the GNU General Public License as published by
@@ -16,7 +16,18 @@
 //  along with this program.  If not, see <https://www.gnu.org/licenses/>.
 // =====================================================================================================================
 
-#ifndef FENNEC_CONCURRENCY_ATOMIC_H
-#define FENNEC_CONCURRENCY_ATOMIC_H
 
-#endif // FENNEC_CONCURRENCY_ATOMIC_H
+#ifndef FENNEC_LANG_DETAIL_FUNCTION_H
+#define FENNEC_LANG_DETAIL_FUNCTION_H
+
+#include <fennec/lang/utility.h>
+
+namespace fennec::detail
+{
+
+
+
+
+}
+
+#endif // FENNEC_LANG_DETAIL_FUNCTION_H

include/fennec/lang/detail/_int.h

@@ -1,6 +1,6 @@
 // =====================================================================================================================
 //  fennec, a free and open source game engine
-//  Copyright © 2025  Medusa Slockbower
+//  Copyright © 2025 - 2026  Medusa Slockbower
 //
 //  This program is free software: you can redistribute it and/or modify
 //  it under the terms of the GNU General Public License as published by
@@ -26,6 +26,8 @@
 #define __PTRDIFF_TYPE__ ptrdiff_t
 #endif
 
+// Include math since stdint will define its own versions of isinf and isnan
+#include <math.h>
 #include <stddef.h>
 #include <stdint.h>
 

include/fennec/lang/detail/_numeric_transforms.h

@@ -1,6 +1,6 @@
 // =====================================================================================================================
 //  fennec, a free and open source game engine
-//  Copyright © 2025  Medusa Slockbower
+//  Copyright © 2025 - 2026  Medusa Slockbower
 //
 //  This program is free software: you can redistribute it and/or modify
 //  it under the terms of the GNU General Public License as published by

include/fennec/lang/detail/_stdlib.h

@@ -1,6 +1,6 @@
 // =====================================================================================================================
 //  fennec, a free and open source game engine
-//  Copyright © 2025  Medusa Slockbower
+//  Copyright © 2025 - 2026  Medusa Slockbower
 //
 //  This program is free software: you can redistribute it and/or modify
 //  it under the terms of the GNU General Public License as published by

include/fennec/lang/detail/_type_sequences.h

@@ -1,6 +1,6 @@
 // =====================================================================================================================
 //  fennec, a free and open source game engine
-//  Copyright © 2025  Medusa Slockbower
+//  Copyright © 2025 - 2026  Medusa Slockbower
 //
 //  This program is free software: you can redistribute it and/or modify
 //  it under the terms of the GNU General Public License as published by
@@ -19,13 +19,19 @@
 #ifndef FENNEC_LANG_DETAIL_TYPE_SEQUENCES_H
 #define FENNEC_LANG_DETAIL_TYPE_SEQUENCES_H
 
+#include <fennec/math/common.h>
 #include <fennec/lang/type_transforms.h>
 
 namespace fennec::detail
 {
+	template<typename...TypesT> struct _type_sequence {};
 
 	template<typename FirstT, typename... RestT> struct _first_element : type_identity<FirstT> {};
 
+
+
+// fennec::nth_element =================================================================================================
+
 	template<size_t n, size_t i, typename...TypesT> struct _nth_element;
 
 	template<size_t n, size_t i> struct _nth_element<n, i> : type_identity<void> {};
@@ -35,6 +41,56 @@ namespace fennec::detail
 		n == i, HeadT,
 		typename _nth_element<n, i + 1, RestT...>::type
 	> {};
+
+
+
+// fennec::max_element_size ============================================================================================
+
+	template<size_t, typename...> struct _max_element_size;
+
+	template<size_t M, typename HeadT>
+	struct _max_element_size<M, HeadT>
+		: integral_constant<size_t, fennec::max(M, sizeof(HeadT))> {
+	};
+
+	template<size_t M, typename HeadT, typename...RestT>
+	struct _max_element_size<M, HeadT, RestT...>
+		: _max_element_size<fennec::max(M, sizeof(HeadT)), RestT...> {
+	};
+
+
+
+// fennec::find_element ================================================================================================
+
+	template<size_t N, typename, typename...> struct _find_element;
+
+	template<size_t N, typename FindT, typename HeadT>
+	struct _find_element<N, FindT, HeadT> : integral_constant<size_t, is_same_v<FindT, HeadT> ? N : N + 1> {};
+
+	template<size_t N, typename FindT, typename HeadT, typename...RestT>
+	struct _find_element<N, FindT, HeadT, RestT...>
+		: conditional_t<is_same_v<FindT, HeadT>, integral_constant<size_t, N>, _find_element<N + 1, FindT, RestT...>> {};
+
+
+// fennec::search_element ==============================================================================================
+
+	template<template<typename> typename, typename...> struct _search_element;
+
+	template<template<typename> typename SearchT> struct _search_element<SearchT> : type_identity<void> {};
+
+	template<template<typename> typename SearchT, typename HeadT, typename...RestT> requires(SearchT<HeadT>{})
+	struct _search_element<SearchT, HeadT, RestT...>
+		: conditional_t<SearchT<HeadT>{}, type_identity<HeadT>, _search_element<SearchT, RestT...>> {
+	};
+
+	template<template<typename, typename...> typename, typename, typename...> struct _search_element_args;
+
+	template<template<typename, typename...> typename SearchT, typename...ArgsT>
+	struct _search_element_args<SearchT, _type_sequence<ArgsT...>> : type_identity<void> {};
+
+	template<template<typename, typename...> typename SearchT, typename HeadT, typename...RestT, typename...ArgsT>
+	struct _search_element_args<SearchT, _type_sequence<ArgsT...>, HeadT, RestT...>
+		: conditional_t<SearchT<HeadT, ArgsT...>{}, type_identity<HeadT>, _search_element_args<SearchT, _type_sequence<ArgsT...>, RestT...>> {};
 }
 
 #endif // FENNEC_LANG_DETAIL_TYPE_SEQUENCES_H

include/fennec/lang/detail/_type_traits.h

@@ -1,6 +1,6 @@
 // =====================================================================================================================
 //  fennec, a free and open source game engine
-//  Copyright © 2025  Medusa Slockbower
+//  Copyright © 2025 - 2026  Medusa Slockbower
 //
 //  This program is free software: you can redistribute it and/or modify
 //  it under the terms of the GNU General Public License as published by
@@ -19,8 +19,9 @@
 #ifndef FENNEC_LANG_DETAIL_TYPE_TRAITS_H
 #define FENNEC_LANG_DETAIL_TYPE_TRAITS_H
 
+#include <fennec/lang/ranges.h>
 #include <fennec/lang/constants.h>
-#include <fennec/lang/float.h>
+#include <fennec/lang/declval.h>
 
 namespace fennec::detail
 {
@@ -54,6 +55,12 @@ namespace fennec::detail
 	template<>         struct _is_integral<llong_t>  : true_type {};
 	template<>         struct _is_integral<ullong_t> : true_type {};
 
+	template<typename>   struct _is_const          : false_type {};
+	template<typename T> struct _is_const<const T> : true_type {};
+
+	template<typename>   struct _is_volatile             : false_type {};
+	template<typename T> struct _is_volatile<volatile T> : true_type {};
+
 	// Most unsigned types will underflow `-1` to the types maximum value
 	template<typename TypeT> struct _is_signed   : bool_constant<TypeT(-1) < TypeT(0)> {};
 	template<typename TypeT> struct _is_unsigned : bool_constant<TypeT(-1) >= TypeT(0)> {};
@@ -62,14 +69,83 @@ namespace fennec::detail
 	template<>         struct _is_floating_point<float_t>  : true_type {};
 	template<>         struct _is_floating_point<double_t> : true_type {};
 
-	template<typename>   struct _is_pointer : false_type {};
+	template<typename>   struct _is_pointer     : false_type {};
 	template<typename T> struct _is_pointer<T*> : true_type {};
 
-	template<typename T, typename U = T&&> U _declval(int);
+	template<typename>   struct _is_reference      : false_type {};
-	template<typename T>                   T _declval(long);
+	template<typename T> struct _is_reference<T&>  : true_type {};
+	template<typename T> struct _is_reference<T&&> : true_type {};
 
-	template<typename T> struct _declval_protector : bool_constant<false> {};
+	template<typename>   struct _is_lvalue_reference     : false_type {};
+	template<typename T> struct _is_lvalue_reference<T&> : true_type  {};
 
+	template<typename>   struct _is_rvalue_reference      : false_type {};
+	template<typename T> struct _is_rvalue_reference<T&&> : true_type  {};
+
+	template<typename T> struct _is_complete {
+		template<typename U>
+		static auto test(U*)  -> bool_constant<sizeof(U) == sizeof(U)>;
+		static auto test(...) -> false_type;
+		using type = decltype(_is_complete::test(static_cast<T*>(nullptr)));
+	};
+
+	template<typename T> struct _is_destructible {
+		template<typename U, typename = decltype(declval<T&>().~T())>
+		static auto test(int) -> true_type;
+		template<typename>
+		static auto test(...) -> false_type;
+		using type = decltype(test<T>(0));
+	};
+
+	template<typename T> struct _is_nothrow_destructible {
+		template<typename U, typename = decltype(noexcept(declval<T&>().~T()))>
+		static auto test(int) -> true_type;
+		template<typename>
+		static auto test(...) -> false_type;
+		using type = decltype(test<T>(0));
+	};
+
+	// https://stackoverflow.com/questions/13830158/how-to-write-a-trait-which-checks-whether-a-type-is-iterable
+	template<typename T>
+	auto _is_iterable(int) -> decltype(
+		fennec::begin(declval<T&>()) != fennec::end(declval<T&>()),
+		void(),
+		++declval<decltype(fennec::begin(declval<T&>()))&>(),
+		void(*fennec::begin(declval<T&>())),
+		true_type{}
+	);
+
+	template<typename T>
+	auto _is_iterable(...) -> false_type;
+
+
+
+	template<typename T>
+	auto _is_indexable(int) -> decltype(
+		declval<T&>()[0],
+		true_type{}
+		);
+
+	template<typename T>
+	auto _is_indexable(...) -> false_type;
+
+
+
+	template<typename T>
+	auto _is_mappable(int) -> decltype(
+		declval<T&>()[declval<typename T::key_t&>()],
+		true_type{}
+	);
+
+	template<typename T>
+	auto _is_mappable(...) -> false_type;
+
+
+	template<typename B> auto _ptr_conv(const volatile B*)    -> true_type;
+	template<typename>   auto _ptr_conv(const volatile void*) -> false_type;
+
+	template<typename B, typename D> auto _is_base_of(int) -> decltype(detail::_ptr_conv<B>(static_cast<D*>(nullptr)));
+	template<typename,   typename>   auto _is_base_of(...) -> false_type;
 }
 
 #endif // FENNEC_LANG_DETAIL_TYPE_TRAITS_H

include/fennec/lang/detail/_type_transforms.h

@@ -1,6 +1,6 @@
 // =====================================================================================================================
 //  fennec, a free and open source game engine
-//  Copyright © 2025  Medusa Slockbower
+//  Copyright © 2025 - 2026  Medusa Slockbower
 //
 //  This program is free software: you can redistribute it and/or modify
 //  it under the terms of the GNU General Public License as published by
@@ -20,29 +20,72 @@
 #define FENNEC_LANG_DETAIL_TYPE_TRANSFORMS_H
 
 #include <fennec/lang/types.h>
+#include <fennec/lang/detail/_type_traits.h>
 
 namespace fennec::detail
 {
+	template<typename TypeT> struct _add_pointer            : type_identity<TypeT*> {};
+	template<typename TypeT> struct _add_pointer<TypeT&>    : type_identity<TypeT*> {};
+	template<typename TypeT> struct _remove_pointer         : type_identity<TypeT> {};
+	template<typename TypeT> struct _remove_pointer<TypeT*> : type_identity<TypeT> {};
 
-	template<typename _Tp, typename = void>
+	template<typename TypeT> struct _add_const                 : type_identity<const TypeT> {};
+	template<typename TypeT> struct _remove_const              : type_identity<TypeT> {};
+	template<typename TypeT> struct _remove_const<const TypeT> : type_identity<TypeT> {};
+
+	template<typename TypeT> struct _add_volatile                    : type_identity<volatile TypeT> {};
+	template<typename TypeT> struct _remove_volatile                 : type_identity<TypeT> {};
+	template<typename TypeT> struct _remove_volatile<volatile TypeT> : type_identity<TypeT> {};
+
+	template<typename TypeT> struct _add_cv                          : _add_const<typename _add_volatile<TypeT>::type> {};
+	template<typename TypeT> struct _remove_cv                       : type_identity<TypeT> {};
+	template<typename TypeT> struct _remove_cv<const          TypeT> : type_identity<TypeT> {};
+	template<typename TypeT> struct _remove_cv<volatile       TypeT> : type_identity<TypeT> {};
+	template<typename TypeT> struct _remove_cv<const volatile TypeT> : type_identity<TypeT> {};
+
+	template<typename TypeT>
+	struct _decay_selector : conditional_t<_is_const<const TypeT>{}, _remove_cv<TypeT>, _add_pointer<TypeT>>  {};
+
+	template<typename TypeT> requires requires { typename TypeT::decay_t; }
+	struct _decay_selector<TypeT> : type_identity<typename TypeT::decay_t> {};
+
+	template<typename TypeT, size_t N>
+	struct _decay_selector<TypeT[N]> : type_identity<TypeT*> {};
+
+	template<typename TypeT>
+	struct _decay_selector<TypeT[]> : type_identity<TypeT*> {};
+
+	template<typename TypeT> struct _decay {
+		using type = typename _decay_selector<TypeT>::type;
+	};
+
+	template<typename TypeT> struct _decay<TypeT&> {
+		using type = typename _decay_selector<TypeT>::type;
+	};
+
+	template<typename TypeT> struct _decay<TypeT&&> {
+		using type = typename _decay_selector<TypeT>::type;
+	};
+
+	template<typename TypeT, typename = void>
 	struct _add_lvalue_reference {
-		using type = _Tp;
+		using type = TypeT;
 	};
 
-	template<typename _Tp>
+	template<typename TypeT>
-	struct _add_lvalue_reference<_Tp, void_t<_Tp&>> {
+	struct _add_lvalue_reference<TypeT, void_t<TypeT&>> {
-		using type = _Tp&;
+		using type = TypeT&;
 	};
 
 
-	template<typename _Tp, typename = void>
+	template<typename TypeT, typename = void>
 	struct _add_rvalue_reference {
-		using type = _Tp;
+		using type = TypeT;
 	};
 
-	template<typename _Tp>
+	template<typename TypeT>
-	struct _add_rvalue_reference<_Tp, void_t<_Tp&&>> {
+	struct _add_rvalue_reference<TypeT, void_t<TypeT&&>> {
-		using type = _Tp&&;
+		using type = TypeT&&;
 	};
 
 }

include/fennec/lang/float.h

@@ -1,6 +1,6 @@
 // =====================================================================================================================
 //  fennec, a free and open source game engine
-//  Copyright © 2025  Medusa Slockbower
+//  Copyright © 2025 - 2026  Medusa Slockbower
 //
 //  This program is free software: you can redistribute it and/or modify
 //  it under the terms of the GNU General Public License as published by
@@ -17,13 +17,15 @@
 // =====================================================================================================================
 
 ///
-/// \file float.h
+/// \file fennec/lang/float.h
 /// \brief metaprogramming floating point type info
 ///
 ///
-/// \details this file is automatically generated for the current build environment
+/// \details This file is automatically generated for the current build environment.
 ///
-/// \copyright Copyright © 2025 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
+/// Environment for this build: GNU Linux x86_64
+///
+/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
 ///
 ///
 
@@ -58,30 +60,55 @@
 #undef FLT_DENORM_MIN
 #undef FLT_ROUND_ERR
 
+/// \brief Does \f$float\f$ have an infinity?
 #define FLT_HAS_INFINITY 1
+/// \brief Does \f$float\f$ have a quiet NaN?
 #define FLT_HAS_QUIET_NAN 1
+/// \brief Does \f$float\f$ have a signaling NaN?
 #define FLT_HAS_SIGNALING_NAN 1
+/// \brief Does \f$float\f$ use denormalization?
 #define FLT_HAS_DENORM 1
+/// \brief Does \f$float\f$ have loss with denormalization?
 #define FLT_HAS_DENORM_LOSS 0
+/// \brief What rounding style does \f$float\f$ use?
 #define FLT_ROUNDS 1
+/// \brief Does \f$float\f$ use the IEEE floating point specification?
 #define FLT_IS_IEC559 1
+/// \brief The number of mantissa bits in \f$float\f$.
 #define FLT_MANT_DIG 24
+/// \brief The number of decimal digits guaranteed to be preserved in a \f$float\f$ → \f$text\f$ → \f$float\f$.
 #define FLT_DIG 6
+/// \brief The decimal precision required to serialize and deserialize a \f$float\f$.
 #define FLT_DECIMAL_DIG 9
+/// \brief The radix, or integer base, used to represent a \f$float\f$.
 #define FLT_RADIX 2
+/// \brief The minimum negative integer such that \f${FLT_RADIX}^{FLT_MIN_EXP}\f$ results in a normalized \f$float\f$.
 #define FLT_MIN_EXP -125
+/// \brief The maximum positive integer such that \f${FLT_RADIX}^{FLT_MAX_EXP}\f$ results in a non-infinite \f$float\f$.
 #define FLT_MAX_EXP 128
+/// \brief The minimum negative integer such that \f${10}^{FLT_MIN_EXP}\f$ results in a normalized \f$float\f$.
 #define FLT_MIN_10_EXP -37
+/// \brief The maximum positive integer such that \f${10}^{FLT_MAX_EXP}\f$ results in a non-infinite \f$float\f$.
 #define FLT_MAX_10_EXP 38
+/// \brief Do arithmetics operations with \f$float\f$ trap?
 #define FLT_TRAPS 0
+/// \brief Do arithmetics operations with \f$float\f$ check for underflow?
 #define FLT_TINYNESS_BEFORE 0
+/// \brief Smallest positive, finite, normal value of \f$float\f$.
 #define FLT_MIN fennec::bit_cast<float>(0x800000)
+/// \brief Largest positive, finite value of \f$float\f$.
 #define FLT_MAX fennec::bit_cast<float>(0x7f7fffff)
+/// \brief The difference between \f$1.0\f$ and the next representable value of \f$float\f$.
 #define FLT_EPSILON fennec::bit_cast<float>(0x34000000)
+/// \brief A value representing \f$\inf\f$ of type \f$float\f$.
 #define FLT_INF fennec::bit_cast<float>(0x7f800000)
+/// \brief A value representing \f$NaN\f$ of type \f$float\f$ that does not trap.
 #define FLT_QUIET_NAN fennec::bit_cast<float>(0x7fc00000)
+/// \brief A value representing \f$NaN\f$ of type \f$float\f$ that traps.
 #define FLT_SIGNALING_NAN fennec::bit_cast<float>(0x7fa00000)
+/// \brief Smallest positive, finite, subnormal value of \f$float\f$.
 #define FLT_DENORM_MIN fennec::bit_cast<float>(0x1)
+/// \brief Maximum rounding error of type \f$float\f$.
 #define FLT_ROUND_ERR fennec::bit_cast<float>(0x3f000000)
 
 #undef DBL_HAS_INFINITY
@@ -110,30 +137,55 @@
 #undef DBL_DENORM_MIN
 #undef DBL_ROUND_ERR
 
+/// \brief Does \f$double\f$ have an infinity?
 #define DBL_HAS_INFINITY 1
+/// \brief Does \f$double\f$ have a quiet NaN?
 #define DBL_HAS_QUIET_NAN 1
+/// \brief Does \f$double\f$ have a signaling NaN?
 #define DBL_HAS_SIGNALING_NAN 1
+/// \brief Does \f$double\f$ use denormalization?
 #define DBL_HAS_DENORM 1
+/// \brief Does \f$double\f$ have loss with denormalization?
 #define DBL_HAS_DENORM_LOSS 0
+/// \brief What rounding style does \f$double\f$ use?
 #define DBL_ROUNDS 1
+/// \brief Does \f$double\f$ use the IEEE doubleing point specification?
 #define DBL_IS_IEC559 1
+/// \brief The number of mantissa bits in \f$double\f$.
 #define DBL_MANT_DIG 53
+/// \brief The number of decimal digits guaranteed to be preserved in a \f$double\f$ &rarr; \f$text\f$ &rarr; \f$double\f$.
 #define DBL_DIG 15
+/// \brief The decimal precision required to serialize and deserialize a \f$double\f$.
 #define DBL_DECIMAL_DIG 17
+/// \brief The radix, or integer base, used to represent a \f$double\f$.
 #define DBL_RADIX 2
+/// \brief The minimum negative integer such that \f${DBL_RADIX}^{DBL_MIN_EXP}\f$ results in a normalized \f$double\f$.
 #define DBL_MIN_EXP -1021
+/// \brief The maximum positive integer such that \f${DBL_RADIX}^{DBL_MAX_EXP}\f$ results in a non-infinite \f$double\f$.
 #define DBL_MAX_EXP 1024
+/// \brief The minimum negative integer such that \f${10}^{DBL_MIN_EXP}\f$ results in a normalized \f$double\f$.
 #define DBL_MIN_10_EXP -307
+/// \brief The maximum positive integer such that \f${10}^{DBL_MAX_EXP}\f$ results in a non-infinite \f$double\f$.
 #define DBL_MAX_10_EXP 308
+/// \brief Do arithmetics operations with \f$double\f$ trap?
 #define DBL_TRAPS 0
+/// \brief Do arithmetics operations with \f$double\f$ check for underflow?
 #define DBL_TINYNESS_BEFORE 0
+/// \brief Smallest positive, finite, normal value of \f$double\f$.
 #define DBL_MIN fennec::bit_cast<double>(0x10000000000000ll)
+/// \brief Largest positive, finite value of \f$double\f$.
 #define DBL_MAX fennec::bit_cast<double>(0x7fefffffffffffffll)
+/// \brief The difference between \f$1.0\f$ and the next representable value of \f$double\f$.
 #define DBL_EPSILON fennec::bit_cast<double>(0x3cb0000000000000ll)
+/// \brief A value representing \f$\inf\f$ of type \f$double\f$.
 #define DBL_INF fennec::bit_cast<double>(0x7ff0000000000000ll)
+/// \brief A value representing \f$NaN\f$ of type \f$double\f$ that does not trap.
 #define DBL_QUIET_NAN fennec::bit_cast<double>(0x7ff8000000000000ll)
+/// \brief A value representing \f$NaN\f$ of type \f$double\f$ that traps.
 #define DBL_SIGNALING_NAN fennec::bit_cast<double>(0x7ff4000000000000ll)
+/// \brief Smallest positive, finite, subnormal value of \f$double\f$.
 #define DBL_DENORM_MIN fennec::bit_cast<double>(0x1ll)
+/// \brief Maximum rounding error of type \f$double\f$.
 #define DBL_ROUND_ERR fennec::bit_cast<double>(0x3fe0000000000000ll)
 
 #endif // FENNEC_LANG_FLOAT_H

include/fennec/lang/function.h

@@ -0,0 +1,136 @@
+// =====================================================================================================================
+//  fennec, a free and open source game engine
+//  Copyright © 2025 - 2026  Medusa Slockbower
+//
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+// =====================================================================================================================
+
+///
+/// \file fennec/lang/function.h
+/// \brief
+///
+///
+/// \details
+/// \author Medusa Slockbower
+///
+/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
+///
+///
+
+
+#ifndef FENNEC_LANG_FUNCTION_H
+#define FENNEC_LANG_FUNCTION_H
+
+#include <fennec/lang/types.h>
+#include <fennec/lang/assert.h>
+#include <fennec/lang/utility.h>
+
+#include <fennec/lang/detail/_function.h>
+
+namespace fennec
+{
+///
+/// \brief a class capable of holding a function or non-capturing lambda
+template<typename> class function;
+
+///
+/// \brief a class capable of holding a function or non-capturing lambda
+/// \tparam ReturnT The return type of the function
+/// \tparam ArgsT The argument types of the function
+template<typename ReturnT, typename...ArgsT>
+class function<ReturnT(ArgsT...)> {
+public:
+	///
+	/// \brief default constructor
+	constexpr function() noexcept
+		: call(nullptr) {
+	}
+
+	///
+	/// \brief destructor
+	constexpr ~function() = default;
+
+	///
+	/// \brief copy constructor
+	/// \param func the function to copy
+	constexpr function(const function& func) noexcept = default;
+
+	///
+	/// \brief move constructor
+	/// \param func the function to take ownership of
+	constexpr function(function&& func) noexcept = default;
+
+	///
+	/// \brief function constructor
+	/// \param func the function to capture
+	constexpr function(ReturnT (*func)(ArgsT...))
+		: call(func) {
+	}
+
+	///
+	/// \brief null constructor
+	constexpr function(nullptr_t) noexcept : function() {}
+
+	///
+	/// \brief copy assignment
+	/// \param func the function to copy
+	/// \returns a reference to self
+	constexpr function& operator=(const function& func) = default;
+
+	///
+	/// \brief move assignment
+	/// \param func the function to capture
+	/// \returns a reference to self
+	constexpr function& operator=(function&& func) = default;
+
+	///
+	/// \brief null assignment
+	/// \returns a reference to self
+	constexpr function& operator=(nullptr_t) {
+		call = nullptr;
+		return *this;
+	}
+
+	///
+	/// \brief function assignment
+	/// \param func the function to capture
+	/// \returns a reference to self
+	constexpr function& operator=(ReturnT (*func)(ArgsT...)) {
+		call = func;
+		return *this;
+	}
+
+	///
+	/// \brief implicit bool check
+	/// \returns \f$true\f$ if a function is captured, \f$false\f$ otherwise
+	constexpr operator bool() const noexcept {
+		return call != nullptr;
+	}
+
+	///
+	/// \brief function call operator
+	/// \param args the arguments to call the function with
+	/// \returns the result of the function call
+	ReturnT operator()(ArgsT...args) const noexcept {
+		assertf(call != nullptr, "Attempted to call a null function object!");
+		return call(fennec::forward<ArgsT>(args)...);
+	}
+
+private:
+	ReturnT (*call)(ArgsT&&...) { nullptr };
+};
+
+}
+
+#endif // FENNEC_LANG_FUNCTION_H

include/fennec/lang/hashing.h

@@ -1,6 +1,6 @@
 // =====================================================================================================================
 //  fennec, a free and open source game engine
-//  Copyright © 2025  Medusa Slockbower
+//  Copyright © 2025 - 2026  Medusa Slockbower
 //
 //  This program is free software: you can redistribute it and/or modify
 //  it under the terms of the GNU General Public License as published by
@@ -21,6 +21,7 @@
 
 #include <fennec/lang/types.h>
 #include <fennec/lang/type_traits.h>
+#include <fennec/lang/bits.h>
 
 namespace fennec
 {
@@ -30,10 +31,13 @@ namespace fennec
 /// \tparam Key The type to hash
 template<typename Key> struct hash;
 
-// Murmur3 Hash for 64-bit ints
+/// \brief Murmur3 Hash for 64-bit ints
 template<>
 struct hash<uint64_t> {
-	using type_t = uint64_t;
+	using type_t = uint64_t; //!< the type of the hash
+	/// \brief hash operator
+	/// \param x the value to hash
+	/// \returns an integer hash for the value
 	constexpr size_t operator()(uint64_t x) const {
 		// Murmur3
 		x ^= x >> 33U;
@@ -45,16 +49,22 @@ struct hash<uint64_t> {
 	}
 };
 
-// Wrapper for casting ints
+/// \brief Hashing for integer types
+/// \tparam IntT the integer type
 template<typename IntT>
 	requires is_integral_v<IntT>
 struct hash<IntT> : hash<uint64_t> {
-	using type_t = IntT;
+	using type_t = IntT; //!< the type of the hash
 };
 
-// Wrapper for pointers
+/// \brief Hashing for pointer types
+/// \tparam PtrT The base type
 template<typename PtrT>
 struct hash<PtrT*> : hash<uintptr_t> {
+	using type_t = PtrT*; //!< the type of the hash
+	/// \brief hash operator
+	/// \param ptr the pointer to hash
+	/// \returns an integer hash for the value
 	constexpr size_t operator()(PtrT* ptr) const {
 		return hash<uintptr_t>::operator()((uintptr_t)(const void*)ptr);
 	}
@@ -63,6 +73,10 @@ struct hash<PtrT*> : hash<uintptr_t> {
 // Float
 template<>
 struct hash<float> : hash<uint32_t> {
+	using type_t = float; //!< the type of the hash
+	/// \brief hash operator
+	/// \param x the value to hash
+	/// \returns an integer hash for the value
 	constexpr size_t operator()(float x) const {
 		return hash<uint32_t>::operator()(bit_cast<uint32_t>(x));
 	}
@@ -70,6 +84,10 @@ struct hash<float> : hash<uint32_t> {
 
 template<>
 struct hash<double> : hash<uint64_t> {
+	using type_t = double; //!< the type of the hash
+	/// \brief hash operator
+	/// \param x the value to hash
+	/// \returns an integer hash for the value
 	constexpr size_t operator()(double x) const {
 		return hash<uint64_t>::operator()(bit_cast<uint64_t>(x));
 	}

include/fennec/lang/integer.h

@@ -1,6 +1,6 @@
 // =====================================================================================================================
 //  fennec, a free and open source game engine
-//  Copyright © 2025  Medusa Slockbower
+//  Copyright © 2025 - 2026  Medusa Slockbower
 //
 //  This program is free software: you can redistribute it and/or modify
 //  it under the terms of the GNU General Public License as published by
@@ -17,13 +17,15 @@
 // =====================================================================================================================
 
 ///
-/// \file integer.h
+/// \file fennec/lang/integer.h
 /// \brief metaprogramming integer type info
 ///
 ///
-/// \details this file is automatically generated for the current build environment
+/// \details This file is automatically generated for the current build environment.
 ///
-/// \copyright Copyright © 2025 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
+/// Environment for this build: GNU Linux x86_64
+///
+/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
 ///
 ///
 
@@ -51,114 +53,212 @@
 #undef ULLONG_MIN
 #undef ULLONG_MAX
 
+/// \brief Is \f$char\f$ signed?
 #define CHAR_IS_SIGNED true
+/// \brief Rounding style of type \f$char\f$.
 #define CHAR_ROUNDS 0x0
+/// \brief Number of radix digits represented by \f$char\f$.
 #define CHAR_RADIX_DIG 0x7
+/// \brief Number of decimal digits represented by \f$char\f$.
 #define CHAR_DIG 0x2
+/// \brief Number of decimal digits necessary to differentiate all values of type \f$char\f$.
 #define CHAR_DECIMAL_DIG 0x0
+/// \brief The radix, or integer base, used to represent a \f$char\f$.
 #define CHAR_RADIX 0x2
+/// \brief Do arithmetics operations with \f$char\f$ trap?
 #define CHAR_TRAPS 0xtrue
+/// \brief Smallest finite value of \f$char\f$.
 #define CHAR_MIN 0x80
+/// \brief Largest finite value of \f$char\f$.
 #define CHAR_MAX 0x7f
 
+/// \brief Is \f$wchar_t\f$ signed?
 #define WCHAR_IS_SIGNED true
+/// \brief Rounding style of type \f$wchar_t\f$.
 #define WCHAR_ROUNDS 0x0
+/// \brief Number of radix digits represented by \f$wchar_t\f$.
 #define WCHAR_RADIX_DIG 0x1f
+/// \brief Number of decimal digits represented by \f$wchar_t\f$.
 #define WCHAR_DIG 0x9
+/// \brief Number of decimal digits necessary to differentiate all values of type \f$wchar_t\f$.
 #define WCHAR_DECIMAL_DIG 0x0
+/// \brief The radix, or integer base, used to represent a \f$wchar_t\f$.
 #define WCHAR_RADIX 0x2
+/// \brief Do arithmetics operations with \f$wchar_t\f$ trap?
 #define WCHAR_TRAPS 0xtrue
+/// \brief Smallest finite value of \f$wchar_t\f$.
 #define WCHAR_MIN 0x80000000
+/// \brief Largest finite value of \f$wchar_t\f$.
 #define WCHAR_MAX 0x7fffffff
 
+/// \brief Is \f$signed char\f$ signed?
 #define SCHAR_ROUNDS 0x0
+/// \brief Rounding style of type \f$signed char\f$.
 #define SCHAR_RADIX_DIG 0x7
+/// \brief Number of radix digits represented by \f$signed char\f$.
 #define SCHAR_DIG 0x2
+/// \brief Number of decimal digits represented by \f$signed char\f$.
 #define SCHAR_DECIMAL_DIG 0x0
+/// \brief Number of decimal digits necessary to differentiate all values of type \f$signed char\f$.
 #define SCHAR_RADIX 0x2
+/// \brief Do arithmetics operations with \f$signed char\f$ trap?
 #define SCHAR_TRAPS 0xtrue
+/// \brief Smallest finite value of \f$signed char\f$.
 #define SCHAR_MIN 0x80
+/// \brief Largest finite value of \f$signed char\f$.
 #define SCHAR_MAX 0x7f
 
+/// \brief Is \f$unsigned char\f$ unsigned?
 #define UCHAR_ROUNDS 0x0
+/// \brief Rounding style of type \f$unsigned char\f$.
 #define UCHAR_RADIX_DIG 0x8
+/// \brief Number of radix digits represented by \f$unsigned char\f$.
 #define UCHAR_DIG 0x2
+/// \brief Number of decimal digits represented by \f$unsigned char\f$.
 #define UCHAR_DECIMAL_DIG 0x0
+/// \brief Number of decimal digits necessary to differentiate all values of type \f$unsigned char\f$.
 #define UCHAR_RADIX 0x2
+/// \brief Do arithmetics operations with \f$unsigned char\f$ trap?
 #define UCHAR_TRAPS 0xtrue
+/// \brief Smallest finite value of \f$unsigned char\f$.
 #define UCHAR_MIN 0x0
+/// \brief Largest finite value of \f$unsigned char\f$.
 #define UCHAR_MAX 0xff
 
+/// \brief Rounding style of type \f$short\f$.
 #define SHORT_ROUNDS 0x0
+/// \brief Number of radix digits represented by \f$short\f$.
 #define SHORT_RADIX_DIG 0xf
+/// \brief Number of decimal digits represented by \f$short\f$.
 #define SHORT_DIG 0x4
+/// \brief Number of decimal digits necessary to differentiate all values of type \f$short\f$.
 #define SHORT_DECIMAL_DIG 0x0
+/// \brief The radix, or integer base, used to represent a \f$short\f$.
 #define SHORT_RADIX 0x2
+/// \brief Do arithmetics operations with \f$short\f$ trap?
 #define SHORT_TRAPS 0xtrue
-#define SHORT_MIN 0x8000
+/// \brief Smallest finite value of \f$short\f$.
+#define SHORT_MIN 0xffff8000
+/// \brief Largest finite value of \f$short\f$.
 #define SHORT_MAX 0x7fff
 
+/// \brief Rounding style of type \f$unsigned short\f$.
 #define USHORT_ROUNDS 0x0
+/// \brief Number of radix digits represented by \f$unsigned short\f$.
 #define USHORT_RADIX_DIG 0x10
+/// \brief Number of decimal digits represented by \f$unsigned short\f$.
 #define USHORT_DIG 0x4
+/// \brief Number of decimal digits necessary to differentiate all values of type \f$unsigned short\f$.
 #define USHORT_DECIMAL_DIG 0x0
+/// \brief The radix, or integer base, used to represent a \f$unsigned short\f$.
 #define USHORT_RADIX 0x2
+/// \brief Do arithmetics operations with \f$unsigned short\f$ trap?
 #define USHORT_TRAPS 0xtrue
+/// \brief Smallest finite value of \f$unsigned short\f$.
 #define USHORT_MIN 0x0
+/// \brief Largest finite value of \f$unsigned short\f$.
 #define USHORT_MAX 0xffff
 
+/// \brief Rounding style of type \f$int\f$.
 #define INT_ROUNDS 0x0
+/// \brief Number of radix digits represented by \f$int\f$.
 #define INT_RADIX_DIG 0x1f
+/// \brief Number of decimal digits represented by \f$int\f$.
 #define INT_DIG 0x9
+/// \brief Number of decimal digits necessary to differentiate all values of type \f$int\f$.
 #define INT_DECIMAL_DIG 0x0
+/// \brief The radix, or integer base, used to represent a \f$int\f$.
 #define INT_RADIX 0x2
+/// \brief Do arithmetics operations with \f$int\f$ trap?
 #define INT_TRAPS 0xtrue
+/// \brief Smallest finite value of \f$int\f$.
 #define INT_MIN 0x80000000
+/// \brief Largest finite value of \f$int\f$.
 #define INT_MAX 0x7fffffff
 
+/// \brief Rounding style of type \f$unsigned int\f$.
 #define UINT_ROUNDS 0x0
+/// \brief Number of radix digits represented by \f$unsigned int\f$.
 #define UINT_RADIX_DIG 0x20
+/// \brief Number of decimal digits represented by \f$unsigned int\f$.
 #define UINT_DIG 0x9
+/// \brief Number of decimal digits necessary to differentiate all values of type \f$unsigned int\f$.
 #define UINT_DECIMAL_DIG 0x0
+/// \brief The radix, or unsigned integer base, used to represent a \f$unsigned int\f$.
 #define UINT_RADIX 0x2
+/// \brief Do arithmetics operations with \f$unsigned int\f$ trap?
 #define UINT_TRAPS 0xtrue
+/// \brief Smallest finite value of \f$unsigned int\f$.
 #define UINT_MIN 0x0
+/// \brief Largest finite value of \f$unsigned int\f$.
 #define UINT_MAX 0xffffffff
 
+/// \brief Rounding style of type \f$long int\f$.
 #define LONG_ROUNDS 0x0
+/// \brief Number of radix digits represented by \f$long int\f$.
 #define LONG_RADIX_DIG 0x3f
+/// \brief Number of decimal digits represented by \f$long int\f$.
 #define LONG_DIG 0x12
+/// \brief Number of decimal digits necessary to differentiate all values of type \f$long int\f$.
 #define LONG_DECIMAL_DIG 0x0
+/// \brief The radix, or long integer base, used to represent a \f$long int\f$.
 #define LONG_RADIX 0x2
+/// \brief Do arithmetics operations with \f$long int\f$ trap?
 #define LONG_TRAPS 0xtrue
+/// \brief Smallest finite value of \f$long int\f$.
 #define LONG_MIN 0x8000000000000000
+/// \brief Largest finite value of \f$long int\f$.
 #define LONG_MAX 0x7fffffffffffffff
 
+/// \brief Rounding style of type \f$unsigned long int\f$.
 #define ULONG_ROUNDS 0x0
+/// \brief Number of radix digits represented by \f$unsigned long int\f$.
 #define ULONG_RADIX_DIG 0x40
+/// \brief Number of decimal digits represented by \f$unsigned long int\f$.
 #define ULONG_DIG 0x13
+/// \brief Number of decimal digits necessary to differentiate all values of type \f$unsigned long int\f$.
 #define ULONG_DECIMAL_DIG 0x0
+/// \brief The radix, or unsigned long integer base, used to represent a \f$unsigned long int\f$.
 #define ULONG_RADIX 0x2
+/// \brief Do arithmetics operations with \f$unsigned long int\f$ trap?
 #define ULONG_TRAPS 0xtrue
+/// \brief Smallest finite value of \f$unsigned long int\f$.
 #define ULONG_MIN 0x0
+/// \brief Largest finite value of \f$unsigned long int\f$.
 #define ULONG_MAX 0xffffffffffffffff
 
+/// \brief Rounding style of type \f$long long\f$.
 #define LLONG_ROUNDS 0x0
+/// \brief Number of radix digits represented by \f$long long\f$.
 #define LLONG_RADIX_DIG 0x3f
+/// \brief Number of decimal digits represented by \f$long long\f$.
 #define LLONG_DIG 0x12
+/// \brief Number of decimal digits necessary to differentiate all values of type \f$long long\f$.
 #define LLONG_DECIMAL_DIG 0x0
+/// \brief The radix, or long longeger base, used to represent a \f$long long\f$.
 #define LLONG_RADIX 0x2
+/// \brief Do arithmetics operations with \f$long long\f$ trap?
 #define LLONG_TRAPS 0xtrue
+/// \brief Smallest finite value of \f$long long\f$.
 #define LLONG_MIN 0x8000000000000000
+/// \brief Largest finite value of \f$long long\f$.
 #define LLONG_MAX 0x7fffffffffffffff
 
+/// \brief Rounding style of type \f$unsigned long long\f$.
 #define ULLONG_ROUNDS 0x0
+/// \brief Number of radix digits represented by \f$unsigned long long\f$.
 #define ULLONG_RADIX_DIG 0x40
+/// \brief Number of decimal digits represented by \f$unsigned long long\f$.
 #define ULLONG_DIG 0x13
+/// \brief Number of decimal digits necessary to differentiate all values of type \f$unsigned long long\f$.
 #define ULLONG_DECIMAL_DIG 0x0
+/// \brief The radix, or unsigned long longeger base, used to represent a \f$unsigned long long\f$.
 #define ULLONG_RADIX 0x2
+/// \brief Do arithmetics operations with \f$unsigned long long\f$ trap?
 #define ULLONG_TRAPS 0xtrue
+/// \brief Smallest finite value of \f$unsigned long long\f$.
 #define ULLONG_MIN 0x0
+/// \brief Largest finite value of \f$unsigned long long\f$.
 #define ULLONG_MAX 0xffffffffffffffff
 
 #endif // FENNEC_LANG_INTEGER_H

include/fennec/lang/intrinsics.h

@@ -1,6 +1,6 @@
 // =====================================================================================================================
 //  fennec, a free and open source game engine
-//  Copyright © 2025  Medusa Slockbower
+//  Copyright © 2025 - 2026  Medusa Slockbower
 //
 //  This program is free software: you can redistribute it and/or modify
 //  it under the terms of the GNU General Public License as published by
@@ -17,10 +17,10 @@
 // =====================================================================================================================
 
 ///
-/// \file intrinsics.h
+/// \file fennec/lang/intrinsics.h
 /// \brief \ref fennec_lang_intrinsics
 ///
-/// \copyright Copyright © 2025 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
+/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
 ///
 ///
 
@@ -40,59 +40,59 @@
 /// <tr><th style="vertical-align: top">Syntax
 ///     <th style="vertical-align: top">Description
 /// <tr><td width="50%" style="vertical-align: top"> <br>
-///         `FENNEC_HAS_BUILTIN_BIT_CAST` <br>
+///         \f$FENNEC_HAS_BUILTIN_BIT_CAST\f$ <br>
-///         `Y FENNEC_BUILTIN_BIT_CAST(X)`
+///         \f$Y FENNEC_BUILTIN_BIT_CAST(X)\f$
 ///     <td width="50%" style="vertical-align: top">
-///         An intrinsic for doing a bitwise cast without using `reinterpret_cast`.
+///         An intrinsic for doing a bitwise cast without using \f$reinterpret_cast\f$.
 ///
 /// <tr><td width="50%" style="vertical-align: top"> <br>
-///         `FENNEC_HAS_BUILTIN_ADDRESSOF` <br>
+///         \f$FENNEC_HAS_BUILTIN_ADDRESSOF\f$ <br>
-///         `Y FENNEC_BUILTIN_ADDRESSOF(X)`
+///         \f$Y FENNEC_BUILTIN_ADDRESSOF(X)\f$
 ///     <td width="50%" style="vertical-align: top">
-///         Obtains the true address of an object in circumstances where `operator&` is overloaded.
+///         Obtains the true address of an object in circumstances where \f$operator&\f$ is overloaded.
 ///
 /// <tr><td width="50%" style="vertical-align: top"> <br>
-///         `FENNEC_HAS_BUILTIN_IS_CONVERTIBLE` <br>
+///         \f$FENNEC_HAS_BUILTIN_IS_CONVERTIBLE\f$ <br>
-///         `B FENNEC_BUILTIN_IS_CONVERTIBLE(X, Y)`
+///         \f$B FENNEC_BUILTIN_IS_CONVERTIBLE(X, Y)\f$
 ///     <td width="50%" style="vertical-align: top">
-///         Checks if type `X` can be converted to type `Y`.
+///         Checks if type \f$X\f$ can be converted to type \f$Y\f$.
 ///
 /// <tr><td width="50%" style="vertical-align: top"> <br>
-///         `FENNEC_HAS_BUILTIN_IS_EMPTY` <br>
+///         \f$FENNEC_HAS_BUILTIN_IS_EMPTY\f$ <br>
-///         `B FENNEC_BUILTIN_IS_EMPTY(X)`
+///         \f$B FENNEC_BUILTIN_IS_EMPTY(X)\f$
 ///     <td width="50%" style="vertical-align: top">
-///         Checks if type `X` stores no data.
+///         Checks if type \f$X\f$ stores no data.
 ///
 /// <tr><td width="50%" style="vertical-align: top"> <br>
-///         `FENNEC_HAS_BUILTIN_IS_POLYMORPHIC` <br>
+///         \f$FENNEC_HAS_BUILTIN_IS_POLYMORPHIC\f$ <br>
-///         `B FENNEC_BUILTIN_IS_POLYMORPHIC(X)`
+///         \f$B FENNEC_BUILTIN_IS_POLYMORPHIC(X)\f$
 ///     <td width="50%" style="vertical-align: top">
-///         Checks if type `X` is polymorphic, this is for classes only thus checks only for subtyping
+///         Checks if type \f$X\f$ is polymorphic, this is for classes only thus checks only for subtyping
 ///
 /// <tr><td width="50%" style="vertical-align: top"> <br>
-///         `FENNEC_HAS_BUILTIN_IS_FINAL` <br>
+///         \f$FENNEC_HAS_BUILTIN_IS_FINAL\f$ <br>
-///         `B FENNEC_BUILTIN_IS_FINAL(X)`
+///         \f$B FENNEC_BUILTIN_IS_FINAL(X)\f$
 ///     <td width="50%" style="vertical-align: top">
-///         Checks if type `X` is final, meaning a function or class cannot be derived from.
+///         Checks if type \f$X\f$ is final, meaning a function or class cannot be derived from.
 ///
 /// <tr><td width="50%" style="vertical-align: top"> <br>
-///         `FENNEC_HAS_BUILTIN_IS_ABSTRACT` <br>
+///         \f$FENNEC_HAS_BUILTIN_IS_ABSTRACT\f$ <br>
-///         `B FENNEC_BUILTIN_IS_ABSTRACT(X)`
+///         \f$B FENNEC_BUILTIN_IS_ABSTRACT(X)\f$
 ///     <td width="50%" style="vertical-align: top">
-///         Opposite of `FENNEC_BUILTIN_IS_FINAL`, checks if abstract, meaning `X` has at least one pure virtual function.
+///         Opposite of \f$FENNEC_BUILTIN_IS_FINAL\f$, checks if abstract, meaning \f$X\f$ has at least one pure virtual function.
 ///
 /// <tr><td width="50%" style="vertical-align: top"> <br>
-///         `FENNEC_HAS_BUILTIN_IS_STANDARD_LAYOUT` <br>
+///         \f$FENNEC_HAS_BUILTIN_IS_STANDARD_LAYOUT\f$ <br>
-///         `B FENNEC_BUILTIN_IS_STANDARD_LAYOUT(X)`
+///         \f$B FENNEC_BUILTIN_IS_STANDARD_LAYOUT(X)\f$
 ///     <td width="50%" style="vertical-align: top">
-///         Checks if `X` has a standard layout, here is [full criteria](https://www.cppreference.com/w/cpp/language/classes.html#Standard-layout_class)
+///         Checks if \f$X\f$ has a standard layout, here is [full criteria](https://www.cppreference.com/w/cpp/language/classes.html#Standard-layout_class)
 ///         for this trait
 ///
 /// <tr><td width="50%" style="vertical-align: top"> <br>
-///         `FENNEC_HAS_BUILTIN_IS_CONSTRUCTIBLE` <br>
+///         \f$FENNEC_HAS_BUILTIN_IS_CONSTRUCTIBLE\f$ <br>
-///         `B FENNEC_BUILTIN_IS_CONSTRUCTIBLE(X, ...)`
+///         \f$B FENNEC_BUILTIN_IS_CONSTRUCTIBLE(X, ...)\f$
 ///     <td width="50%" style="vertical-align: top">
-///         Checks if type `X` is constructible with args `...`, such that `X::X(...)` exists.
+///         Checks if type \f$X\f$ is constructible with args \f$\ldots\f$, such that \f$X::X(...)\f$ exists.
 ///
 /// </table>
 ///
@@ -102,6 +102,9 @@
 // Most major compilers support __has_builtin, notably GCC, MINGW, and CLANG
 #if defined(__has_builtin)
 
+
+// UTILITIES ===========================================================================================================
+
 // addressof is very difficult to implement without intrinsics.
 #if __has_builtin(__builtin_addressof)
 # define FENNEC_HAS_BUILTIN_ADDRESSOF 1
@@ -118,6 +121,37 @@
 # define FENNEC_HAS_BUILTIN_BIT_CAST 0
 #endif
 
+#if __has_builtin(__builtin_LINE)
+# define FENNEC_HAS_BUILTIN_LINE 1
+# define FENNEC_BUILTIN_LINE() __builtin_LINE()
+#else
+# define FENNEC_HAS_BUILTIN_LINE 0
+#endif
+
+#if __has_builtin(__builtin_COLUMN)
+# define FENNEC_HAS_BUILTIN_COLUMN 1
+# define FENNEC_BUILTIN_COLUMN() __builtin_COLUMN()
+#else
+# define FENNEC_HAS_BUILTIN_COLUMN 0
+#endif
+
+#if __has_builtin(__builtin_FILE)
+# define FENNEC_HAS_BUILTIN_FILE 1
+# define FENNEC_BUILTIN_FILE() __builtin_FILE()
+#else
+# define FENNEC_HAS_BUILTIN_FILE 0
+#endif
+
+#if __has_builtin(__builtin_FUNCTION)
+# define FENNEC_HAS_BUILTIN_FUNCTION 1
+# define FENNEC_BUILTIN_FUNCTION() __builtin_FUNCTION()
+#else
+# define FENNEC_HAS_BUILTIN_FUNCTION 0
+#endif
+
+
+// PROPERTIES ==========================================================================================================
+
 // Inconsistent without intrinsics
 #if __has_builtin(__is_abstract)
 # define FENNEC_HAS_BUILTIN_IS_ABSTRACT 1
@@ -134,6 +168,14 @@
 # define FENNEC_HAS_BUILTIN_IS_ARRAY
 #endif
 
+// Inconsistent without intrinsics
+#if __has_builtin(__is_bounded_array)
+# define FENNEC_HAS_BUILTIN_IS_BOUNDED_ARRAY 1
+# define FENNEC_BUILTIN_IS_BOUNDED_ARRAY(arg) __is_bounded_array(arg)
+#else
+# define FENNEC_HAS_BUILTIN_IS_BOUNDED_ARRAY
+#endif
+
 // Inconsistent without intrinsics
 #if __has_builtin(__is_class)
 # define FENNEC_HAS_BUILTIN_IS_CLASS 1
@@ -142,6 +184,36 @@
 # define FENNEC_HAS_BUILTIN_IS_CLASS
 #endif
 
+// Inconsistent without intrinsics
+#if __has_builtin(__is_scoped_enum)
+# define FENNEC_HAS_BUILTIN_IS_SCOPED_ENUM 1
+# define FENNEC_BUILTIN_IS_SCOPED_ENUM(arg) __is_scoped_enum(arg)
+#else
+# define FENNEC_HAS_BUILTIN_IS_SCOPED_ENUM
+#endif
+
+#if __has_builtin(__is_member_pointer)
+# define FENNEC_HAS_BUILTIN_IS_MEMBER_POINTER 1
+# define FENNEC_BUILTIN_IS_MEMBER_POINTER(arg) __is_member_pointer(arg)
+#else
+# define FENNEC_HAS_BUILTIN_IS_MEMBER_POINTER 0
+#endif
+
+#if __has_builtin(__is_member_function_pointer)
+# define FENNEC_HAS_BUILTIN_IS_MEMBER_FUNCTION_POINTER 1
+# define FENNEC_BUILTIN_IS_MEMBER_FUNCTION_POINTER(arg) __is_member_function_pointer(arg)
+#else
+# define FENNEC_HAS_BUILTIN_IS_MEMBER_FUNCTION_POINTER 0
+#endif
+
+#if __has_builtin(__is_member_object_pointer)
+# define FENNEC_HAS_BUILTIN_IS_MEMBER_OBJECT_POINTER 1
+# define FENNEC_BUILTIN_IS_MEMBER_OBJECT_POINTER(arg) __is_member_object_pointer(arg)
+#else
+# define FENNEC_HAS_BUILTIN_IS_MEMBER_OBJECT_POINTER 0
+#endif
+
+
 // CONSTRUCTORS ========================================================================================================
 
 // Difficult and Inconsistent without intrinsics
@@ -155,11 +227,19 @@
 // Difficult and Inconsistent without intrinsics
 #if __has_builtin(__is_trivially_constructible)
 # define FENNEC_HAS_BUILTIN_IS_TRIVIALLY_CONSTRUCTIBLE 1
-# define FENNEC_BUILTIN_IS_TRIVIALLY_CONSTRUCTIBLE(type) __is_trivially_constructible(type)
+# define FENNEC_BUILTIN_IS_TRIVIALLY_CONSTRUCTIBLE(type, ...) __is_trivially_constructible(type __VA_OPT__(,) __VA_ARGS__)
 #else
 # define FENNEC_HAS_BUILTIN_IS_TRIVIALLY_CONSTRUCTIBLE 0
 #endif
 
+// Difficult and Inconsistent without intrinsics
+#if __has_builtin(__is_nothrow_constructible)
+# define FENNEC_HAS_BUILTIN_IS_NOTHROW_CONSTRUCTIBLE 1
+# define FENNEC_BUILTIN_IS_NOTHROW_CONSTRUCTIBLE(type, ...) __is_nothrow_constructible(type __VA_OPT__(,) __VA_ARGS__)
+#else
+# define FENNEC_HAS_BUILTIN_IS_NOTHROW_CONSTRUCTIBLE 0
+#endif
+
 // Difficult and Inconsistent without intrinsics
 #if __has_builtin(__has_trivial_destructor)
 # define FENNEC_HAS_BUILTIN_IS_TRIVIALLY_DESTRUCTIBLE 1
@@ -179,6 +259,54 @@
 # define FENNEC_HAS_BUILTIN_IS_ASSIGNABLE 0
 #endif
 
+// Difficult and Inconsistent without intrinsics
+#if __has_builtin(__is_trivially_assignable)
+# define FENNEC_HAS_BUILTIN_IS_TRIVIALLY_ASSIGNABLE 1
+# define FENNEC_BUILTIN_IS_TRIVIALLY_ASSIGNABLE(a, b) __is_trivially_assignable(a, b)
+#else
+# define FENNEC_HAS_BUILTIN_IS_TRIVIALLY_ASSIGNABLE 0
+#endif
+
+// Difficult and Inconsistent without intrinsics
+#if __has_builtin(__is_nothrow_assignable)
+# define FENNEC_HAS_BUILTIN_IS_NOTHROW_ASSIGNABLE 1
+# define FENNEC_BUILTIN_IS_NOTHROW_ASSIGNABLE(a, b) __is_nothrow_assignable(a, b)
+#else
+# define FENNEC_HAS_BUILTIN_IS_NOTHROW_ASSIGNABLE 0
+#endif
+
+// Inconsistent without intrinsics
+#if __has_builtin(__is_trivial)
+# define FENNEC_HAS_BUILTIN_IS_TRIVIAL 1
+# define FENNEC_BUILTIN_IS_TRIVIAL(a) __is_trivial(a)
+#else
+# define FENNEC_HAS_BUILTIN_IS_TRIVIAL 0
+#endif
+
+// Difficult and Inconsistent without intrinsics
+#if __has_builtin(__is_trivially_copyable)
+# define FENNEC_HAS_BUILTIN_IS_TRIVIALLY_COPYABLE 1
+# define FENNEC_BUILTIN_IS_TRIVIALLY_COPYABLE(a) __is_trivially_copyable(a)
+#else
+# define FENNEC_HAS_BUILTIN_IS_TRIVIALLY_COPYABLE 0
+#endif
+
+// Impossible without instrinsics
+#if __has_builtin(__is_standard_layout)
+# define FENNEC_HAS_BUILTIN_IS_STANDARD_LAYOUT 1
+# define FENNEC_BUILTIN_IS_STANDARD_LAYOUT(arg) __is_standard_layout(arg)
+#else
+# define FENNEC_HAS_BUILTIN_IS_STANDARD_LAYOUT 0
+#endif
+
+// Impossible without instrinsics
+#if __has_builtin(__has_unique_object_representations)
+# define FENNEC_HAS_BUILTIN_HAS_UNIQUE_OBJECT_REPRESENTATIONS 1
+# define FENNEC_BUILTIN_HAS_UNIQUE_OBJECT_REPRESENTATIONS(arg) __has_unique_object_representations(arg)
+#else
+# define FENNEC_HAS_BUILTIN_HAS_UNIQUE_OBJECT_REPRESENTATIONS 0
+#endif
+
 
 // Type Traits
 // can_convert is also very difficult to implement without intrinsics
@@ -213,6 +341,14 @@
 # define FENNEC_HAS_BUILTIN_IS_ENUM 0
 #endif
 
+// Inconsistent without intrinsics.
+#if __has_builtin(__is_union)
+# define FENNEC_HAS_BUILTIN_IS_UNION 1
+# define FENNEC_BUILTIN_IS_UNION(arg) __is_union(arg)
+#else
+# define FENNEC_HAS_BUILTIN_IS_UNION 0
+#endif
+
 // Inconsistent without intrinsics
 #if __has_builtin(__is_final)
 # define FENNEC_HAS_BUILTIN_IS_FINAL 1
@@ -221,12 +357,36 @@
 # define FENNEC_HAS_BUILTIN_IS_FINAL 0
 #endif
 
-// Inconsistent with dynamic intrinsics, requires a massive table for static intrinsics
+// Inconsistent without intrinsics
-#if __has_builtin(__is_fundamental)
+#if __has_builtin(__is_aggregate)
-# define FENNEC_HAS_BUILTIN_IS_FUNDAMENTAL 1
+# define FENNEC_HAS_BUILTIN_IS_AGGREGATE 1
-# define FENNEC_BUILTIN_IS_FUNDAMENTAL(arg) __is_fundamental(arg)
+# define FENNEC_BUILTIN_IS_AGGREGATE(arg) __is_aggregate(arg)
 #else
-# define FENNEC_HAS_BUILTIN_IS_FUNDAMENTAL 0
+# define FENNEC_HAS_BUILTIN_IS_AGGREGATE 0
+#endif
+
+// Inconsistent without intrinsics
+#if __has_builtin(__builtin_is_implicit_lifetime)
+# define FENNEC_HAS_BUILTIN_IS_IMPLICIT_LIFETIME 1
+# define FENNEC_BUILTIN_IS_IMPLICIT_LIFETIME(arg) __builtin_is_implicit_lifetime(arg)
+#else
+# define FENNEC_HAS_BUILTIN_IS_IMPLICIT_LIFETIME 0
+#endif
+
+// Inconsistent without intrinsics
+#if __has_builtin(__is_function)
+# define FENNEC_HAS_BUILTIN_IS_FUNCTION 1
+# define FENNEC_BUILTIN_IS_FUNCTION(arg) __is_function(arg)
+#else
+# define FENNEC_HAS_BUILTIN_IS_FUNCTION 0
+#endif
+
+// Inconsistent without intrinsics
+#if __has_builtin(__is_object)
+# define FENNEC_HAS_BUILTIN_IS_OBJECT 1
+# define FENNEC_BUILTIN_IS_OBJECT(arg) __is_object(arg)
+#else
+# define FENNEC_HAS_BUILTIN_IS_FUNCTION 0
 #endif
 
 // Inconsistent without intrinsics
@@ -237,14 +397,6 @@
 # define FENNEC_HAS_BUILTIN_IS_POLYMORPHIC 0
 #endif
 
-// Impossible without instrinsics
-#if __has_builtin(__is_standard_layout)
-# define FENNEC_HAS_BUILTIN_IS_STANDARD_LAYOUT 1
-# define FENNEC_BUILTIN_IS_STANDARD_LAYOUT(arg) __is_standard_layout(arg)
-#else
-# define FENNEC_HAS_BUILTIN_IS_STANDARD_LAYOUT 0
-#endif
-
 
 // For compilers without or differently named builtins
 #else

include/fennec/lang/lang.h

@@ -1,6 +1,6 @@
 // =====================================================================================================================
 //  fennec, a free and open source game engine
-//  Copyright © 2025  Medusa Slockbower
+//  Copyright © 2025 - 2026  Medusa Slockbower
 //
 //  This program is free software: you can redistribute it and/or modify
 //  it under the terms of the GNU General Public License as published by
@@ -17,14 +17,14 @@
 // =====================================================================================================================
 
 ///
-/// \file lang.h
+/// \file fennec/lang/lang.h
 /// \brief \ref fennec_lang
 ///
 ///
 /// \details
 /// \author Medusa Slockbower
 ///
-/// \copyright Copyright © 2025 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
+/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
 ///
 ///
 

include/fennec/lang/limits.h

@@ -1,6 +1,6 @@
 // =====================================================================================================================
 //  fennec, a free and open source game engine
-//  Copyright © 2025  Medusa Slockbower
+//  Copyright © 2025 - 2026  Medusa Slockbower
 //
 //  This program is free software: you can redistribute it and/or modify
 //  it under the terms of the GNU General Public License as published by
@@ -17,14 +17,14 @@
 // =====================================================================================================================
 
 ///
-/// \file limits.h
+/// \file fennec/lang/limits.h
 /// \brief \ref fennec_lang_limits
 ///
 ///
 /// \details
 /// \author Medusa Slockbower
 ///
-/// \copyright Copyright © 2025 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
+/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
 ///
 ///
 
@@ -222,42 +222,42 @@ enum float_round_style
 /// \tparam TypeT Numeric types, may be overloaded for custom types
 template<typename TypeT> struct numeric_limits
 {
-	static constexpr bool is_specialized    = false; ///< Check if the template is specialized for TypeT
+	static constexpr bool is_specialized    = false; //!< Check if the template is specialized for TypeT
-	static constexpr bool is_signed         = false; ///< Check if TypeT is signed
+	static constexpr bool is_signed         = false; //!< Check if TypeT is signed
-	static constexpr bool is_integer        = false; ///< Check if TypeT is of an integral type
+	static constexpr bool is_integer        = false; //!< Check if TypeT is of an integral type
-	static constexpr bool is_exact          = false; ///< Check if TypeT is exact in its precision
+	static constexpr bool is_exact          = false; //!< Check if TypeT is exact in its precision
-	static constexpr bool has_infinity      = false; ///< Check if TypeT can hold a value representing infinity
+	static constexpr bool has_infinity      = false; //!< Check if TypeT can hold a value representing infinity
-	static constexpr bool has_quiet_nan     = false; ///< Check if TypeT can hold a non-signaling nan
+	static constexpr bool has_quiet_nan     = false; //!< Check if TypeT can hold a non-signaling nan
-	static constexpr bool has_signaling_nan = false; ///< Check if TypeT can hold a signaling nan
+	static constexpr bool has_signaling_nan = false; //!< Check if TypeT can hold a signaling nan
-	static constexpr bool has_denorm        = false; ///< Check if TypeT denormalizes
+	static constexpr bool has_denorm        = false; //!< Check if TypeT denormalizes
-	static constexpr bool has_denorm_loss   = false; ///< Check if TypeT has precision loss when denormalized
+	static constexpr bool has_denorm_loss   = false; //!< Check if TypeT has precision loss when denormalized
-	static constexpr bool is_iec559         = false; ///< Check if a TypeT representing a float is IEC 559 or IEEE 754
+	static constexpr bool is_iec559         = false; //!< Check if a TypeT representing a float is IEC 559 or IEEE 754
-	static constexpr bool is_bounded        = false; ///< Check if TypeT represents a finite set of values
+	static constexpr bool is_bounded        = false; //!< Check if TypeT represents a finite set of values
-	static constexpr bool is_modulo         = false; ///< Check if TypeT can handle modulo arithmetic
+	static constexpr bool is_modulo         = false; //!< Check if TypeT can handle modulo arithmetic
-	static constexpr bool tinyness_before   = false; ///< Check if TypeT checks for tinyness before rounding
+	static constexpr bool tinyness_before   = false; //!< Check if TypeT checks for tinyness before rounding
-	static constexpr bool traps             = false; ///< Check if TypeT can cause operations to trap
+	static constexpr bool traps             = false; //!< Check if TypeT can cause operations to trap
 
-	static constexpr int  radix             = 0; ///< Get the base representation of the type
+	static constexpr int  radix             = 0; //!< Get the base representation of the type
-	static constexpr int  digits            = 0; ///< Get the number of radix digits TypeT represents
+	static constexpr int  digits            = 0; //!< Get the number of radix digits TypeT represents
-	static constexpr int  digits10          = 0; ///< Get the number of decimal digits TypeT represents
+	static constexpr int  digits10          = 0; //!< Get the number of decimal digits TypeT represents
-	static constexpr int  max_digits10      = 0; ///< Get the maximum number of decimal digits TypeT represents
+	static constexpr int  max_digits10      = 0; //!< Get the maximum number of decimal digits TypeT represents
-	static constexpr int  min_exponent      = 0; ///< Get the minimum number of radix digits that represent the exponent of TypeT
+	static constexpr int  min_exponent      = 0; //!< Get the minimum number of radix digits that represent the exponent of TypeT
-	static constexpr int  min_exponent10    = 0; ///< Get the minimum number of decimal digits that represent the exponent of TypeT
+	static constexpr int  min_exponent10    = 0; //!< Get the minimum number of decimal digits that represent the exponent of TypeT
-	static constexpr int  max_exponent      = 0; ///< Get the maximum number of radix digits that represent the exponent of TypeT
+	static constexpr int  max_exponent      = 0; //!< Get the maximum number of radix digits that represent the exponent of TypeT
-	static constexpr int  max_exponent10    = 0; ///< Get the maximum number of decimal digits that represent the exponent of TypeT
+	static constexpr int  max_exponent10    = 0; //!< Get the maximum number of decimal digits that represent the exponent of TypeT
 
-	static constexpr float_round_style rounding_style = round_indeterminate; ///< The rounding style of TypeT
+	static constexpr float_round_style rounding_style = round_indeterminate; //!< The rounding style of TypeT
 
 	// This is very poorly named and defined in the C++ Standard so these functions differ
-	static constexpr TypeT min()           { return TypeT(); } ///< Returns the minimum finite value of TypeT
+	static constexpr TypeT min()           { return TypeT(); } //!< \returns the minimum finite value of TypeT
-	static constexpr TypeT max()           { return TypeT(); } ///< Returns the maximum finite value of TypeT
+	static constexpr TypeT max()           { return TypeT(); } //!< \returns the maximum finite value of TypeT
-	static constexpr TypeT lowest()        { return TypeT(); } ///< Returns the smallest positive value of TypeT
+	static constexpr TypeT lowest()        { return TypeT(); } //!< \returns the smallest positive value of TypeT
-	static constexpr TypeT epsilon()       { return TypeT(); } ///< Returns the difference between 1.0 and the next representable value
+	static constexpr TypeT epsilon()       { return TypeT(); } //!< \returns the difference between 1.0 and the next representable value
-	static constexpr TypeT round_error()   { return TypeT(); } ///< Returns the max rounding error of TypeT
+	static constexpr TypeT round_error()   { return TypeT(); } //!< \returns the max rounding error of TypeT
-	static constexpr TypeT infinity()      { return TypeT(); } ///< Returns a value of TypeT holding a positive infinity
+	static constexpr TypeT infinity()      { return TypeT(); } //!< \returns a value of TypeT holding a positive infinity
-	static constexpr TypeT quiet_NaN()     { return TypeT(); } ///< Returns a value of TypeT holding a quiet NaN
+	static constexpr TypeT quiet_NaN()     { return TypeT(); } //!< \returns a value of TypeT holding a quiet NaN
-	static constexpr TypeT signaling_NaN() { return TypeT(); } ///< Returns a value of TypeT holding a signaling NaN
+	static constexpr TypeT signaling_NaN() { return TypeT(); } //!< \returns a value of TypeT holding a signaling NaN
-	static constexpr TypeT denorm_min()    { return TypeT(); } ///< Returns a value of TypeT holding the smallest positive subnormal
+	static constexpr TypeT denorm_min()    { return TypeT(); } //!< \returns a value of TypeT holding the smallest positive subnormal
 };
 
 // Overload definitions for basic types

include/fennec/lang/metaprogramming.h

@@ -1,6 +1,6 @@
 // =====================================================================================================================
 //  fennec, a free and open source game engine
-//  Copyright © 2025  Medusa Slockbower
+//  Copyright © 2025 - 2026  Medusa Slockbower
 //
 //  This program is free software: you can redistribute it and/or modify
 //  it under the terms of the GNU General Public License as published by
@@ -17,14 +17,14 @@
 // =====================================================================================================================
 
 ///
-/// \file metaprogramming.h
+/// \file fennec/lang/metaprogramming.h
 /// \brief \ref fennec_lang
 ///
 ///
 /// \details
 /// \author Medusa Slockbower
 ///
-/// \copyright Copyright © 2025 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
+/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
 ///
 ///
 
@@ -42,7 +42,8 @@
 /// - \subpage fennec_lang_constants
 /// - \subpage fennec_lang_conditional_types
 /// - \subpage fennec_lang_numeric_transforms
-/// - \subpage fennec_lang_sequences
+/// - \subpage fennec_lang_metasequences
+/// - \subpage fennec_lang_type_identity
 /// - \subpage fennec_lang_type_sequences
 /// - \subpage fennec_lang_type_traits
 /// - \subpage fennec_lang_type_transforms

include/fennec/lang/metasequences.h

@@ -0,0 +1,246 @@
+// =====================================================================================================================
+//  fennec, a free and open source game engine
+//  Copyright © 2025 - 2026  Medusa Slockbower
+//
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+// =====================================================================================================================
+
+///
+/// \file fennec/lang/metasequences.h
+/// \brief \ref fennec_lang_metasequences
+///
+///
+/// \details
+/// \author Medusa Slockbower
+///
+/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
+///
+///
+
+#ifndef FENNEC_LANG_SEQUENCES_H
+#define FENNEC_LANG_SEQUENCES_H
+
+///
+/// \page fennec_lang_metasequences Metasequences
+///
+/// \brief This header is part of the metaprogramming library. It defines structures for metasequences of values, used during compile time.
+///
+/// \code #include <fennec/lang/metasequences.h> \endcode
+///
+/// <table width="100%" class="fieldtable" id="table_fennec_lang_metasequences">
+/// <tr><th style="vertical-align: top">Syntax
+///     <th style="vertical-align: top">Description
+///
+/// <tr><td width="50%" style="vertical-align: top"> <br>
+///         \ref fennec::metasequence "metasequence<ValueT, Values...>"<br>
+///     <td width="50%" style="vertical-align: top">
+///         \copydetails fennec::metasequence
+///
+/// <tr><td width="50%" style="vertical-align: top"> <br>
+///         \ref fennec::integer_metasequence "integer_metasequence<IntT, Values...>"<br>
+///         \ref fennec::make_integer_metasequence "typename make_integer_metasequence<IntT, N>::type"<br>
+///         \ref fennec::make_integer_metasequence_t "make_integer_metasequence_t<IntT, N>"
+///     <td width="50%" style="vertical-align: top">
+///         \copydetails fennec::integer_metasequence
+///
+/// <tr><td width="50%" style="vertical-align: top"> <br>
+///         \ref fennec::index_metasequence "index_metasequence<Indices...>"<br>
+///         \ref fennec::make_index_metasequence "typename make_index_metasequence<N>::type"<br>
+///         \ref fennec::make_index_metasequence_t "make_index_metasequence_t<N>"
+///     <td width="50%" style="vertical-align: top">
+///         \copydetails fennec::index_metasequence
+///
+/// <tr><td width="50%" style="vertical-align: top"> <br>
+///         \ref fennec::concat_metasequence "typename concat_metasequence<metasequenceT0, metasequenceT1>::type"<br>
+///         \ref fennec::concat_metasequence_t "concat_metasequence_t<metasequenceT0, metasequenceT1>"<br>
+///     <td width="50%" style="vertical-align: top">
+///         \copydetails fennec::concat_metasequence
+///
+/// </table>
+///
+
+#include <fennec/lang/type_traits.h>
+
+namespace fennec
+{
+
+// fennec::metasequence ====================================================================================================
+
+///
+/// \brief metaprogramming sequence
+///
+/// \details Stores a sequence of values of type \f$ValueT\f$ as a template pack.
+///          You can access the parameter pack in another template function, i.e.
+///          \code{cpp}
+///          template<typename TypeT, TypeT...Values>
+///          constexpr TypeT summation(metasequence<TypeT, Values...>)
+///          {
+///              return (Values + ...);
+///          }
+///          \endcode
+/// \tparam ValueT type of the values
+/// \tparam Values sequence values
+template<typename ValueT, ValueT...Values> struct metasequence
+{
+	/// \brief type of the metasequence
+	using value_type = ValueT;
+
+	/// \brief self-referential type
+	using type = metasequence;
+
+	///
+	/// \brief returns the number of elements
+	///
+	/// \return number of elements in the array
+	inline static constexpr size_t size() noexcept {
+		return sizeof...(Values);
+	}
+};
+
+
+
+// fennec::integer_metasequence ============================================================================================
+
+///
+/// \brief metaprogramming integral metasequence
+///
+/// \details A `fennec::metasequence` specialized integer types.
+/// \tparam IntT type of the values, must satisfy `fennec::is_integral<T>`
+/// \tparam Values sequence values
+template<typename IntT, IntT...Values> requires(is_integral_v<IntT>)
+struct integer_metasequence : metasequence<IntT, Values...>
+{
+	/// \brief type of the sequence
+	using value_type = IntT;
+
+	/// \brief self-referential type
+	using type = integer_metasequence;
+
+	///
+	/// \brief returns the number of elements
+	///
+	/// \return number of elements in the array
+	inline static constexpr size_t size() noexcept {
+		return sizeof...(Values);
+	}
+};
+
+
+///
+/// \brief generate a fennec::integer_metasequence \f$\left[\,0\,\ldots\,N\,\right)\f$
+///
+/// \details
+/// \tparam IntT type of the values, must satisfy `fennec::is_integral<T>`
+/// \tparam N size of the metasequence to generate
+template<typename IntT, size_t N> struct make_integer_metasequence;
+
+///
+/// \brief shorthand for `typename fennec::make_integer_sequence<T, N>::type`
+template<typename IntT, size_t N> using  make_integer_metasequence_t = typename make_integer_metasequence<IntT, N>::type;
+
+
+
+// fennec::index_metasequence ==============================================================================================
+
+///
+/// \brief metaprogramming integral metasequence
+///
+/// \details A `fennec::integer_metasequence` specialized for sequences of `size_t` indices.
+/// \tparam Indices sequence values
+template<size_t...Indices> struct index_metasequence : integer_metasequence<size_t, Indices...>
+{
+	/// \brief type of the sequence
+	using value_type = size_t;
+
+	/// \brief self-referential type
+	using type = index_metasequence;
+
+	///
+	/// \brief returns the number of elements
+	///
+	/// \return number of elements in the array
+	inline static constexpr size_t size() noexcept {
+		return sizeof...(Indices);
+	}
+};
+
+
+///
+/// \brief generate a fennec::index_metasequence \f$\left[\,0\,\ldots\,N\,\right)\f$
+///
+/// \details
+/// \tparam T type of the values, must satisfy `fennec::is_integral<T>`
+/// \tparam N size of the sequence to generate
+template<size_t N> struct make_index_metasequence;
+
+///
+/// \brief shorthand for `typename fennec::make_index_metasequence<N>::type`
+template<size_t N> using  make_index_metasequence_t = typename make_index_metasequence<N>::type;
+
+
+
+// fennec::concat_metasequence =============================================================================================
+
+///
+/// \brief concatenate two metasequences
+///
+/// \details A tool for concatenating two `fennec::metasequence` types.
+/// \tparam SequenceT0 lhs
+/// \tparam SequenceT1 rhs
+template<typename SequenceT0, typename SequenceT1> struct concat_metasequence;
+
+///
+/// \brief shorthand for `typename fennec::concat_metasequence<SequenceT0, SequenceT1>::type`
+template<typename SequenceT0, typename SequenceT1> using concat_metasequence_t
+	= typename concat_metasequence<SequenceT0, SequenceT1>::type;
+
+
+
+// Internal ============================================================================================================
+
+// Implementation for Generating an integer_sequence
+template<typename T, size_t N> struct make_integer_metasequence : concat_metasequence_t<make_integer_metasequence_t<T, N / 2>, make_integer_metasequence_t<T, N - N / 2>>{};
+
+// Base Case of N=0
+template<typename T> struct make_integer_metasequence<T, 0> : integer_metasequence<T> {};
+
+// Base Case of N=1
+template<typename T> struct make_integer_metasequence<T, 1> : integer_metasequence<T, 0>{};
+
+
+// Implementation for Generating an index_sequence
+template<size_t N> struct make_index_metasequence : concat_metasequence_t<make_index_metasequence_t<N / 2>, make_index_metasequence_t<N - N / 2>>{};
+
+// Base Case of N=0
+template<> struct make_index_metasequence<0> : index_metasequence<> {};
+
+// Base Case of N=1
+template<> struct make_index_metasequence<1> : index_metasequence<0>{};
+
+
+// Specialization for integer sequences
+template<typename T, T...SequenceV0, T...SequenceV1>
+struct concat_metasequence<integer_metasequence<T, SequenceV0...>, integer_metasequence<T, SequenceV1...>>
+	: integer_metasequence<T, SequenceV0..., (sizeof...(SequenceV0) + SequenceV1)...>{};
+
+// Specialization for index sequences
+template<size_t...SequenceV0, size_t...SequenceV1>
+struct concat_metasequence<index_metasequence<SequenceV0...>, index_metasequence<SequenceV1...>>
+	: index_metasequence<SequenceV0..., (sizeof...(SequenceV0) + SequenceV1)...>{};
+
+
+
+}
+
+#endif // FENNEC_LANG_SEQUENCES_H

include/fennec/lang/numeric_transforms.h

@@ -1,6 +1,6 @@
 // =====================================================================================================================
 //  fennec, a free and open source game engine
-//  Copyright © 2025  Medusa Slockbower
+//  Copyright © 2025 - 2026  Medusa Slockbower
 //
 //  This program is free software: you can redistribute it and/or modify
 //  it under the terms of the GNU General License as published by
@@ -17,14 +17,14 @@
 // =====================================================================================================================
 
 ///
-/// \file numeric_transforms.h
+/// \file fennec/lang/numeric_transforms.h
 /// \brief \ref fennec_lang_numeric_transforms
 ///
 ///
 /// \details
 /// \author Medusa Slockbower
 ///
-/// \copyright Copyright © 2025 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
+/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
 ///
 
 #ifndef FENNEC_LANG_NUMERIC_TRANSFORMS_H

include/fennec/lang/ranges.h

@@ -0,0 +1,104 @@
+// =====================================================================================================================
+//  fennec, a free and open source game engine
+//  Copyright © 2025 - 2026  Medusa Slockbower
+//
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+// =====================================================================================================================
+
+///
+/// \file fennec/lang/ranges.h
+/// \brief
+///
+///
+/// \details
+/// \author Medusa Slockbower
+///
+/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
+///
+///
+
+#ifndef FENNEC_LANG_RANGES_H
+#define FENNEC_LANG_RANGES_H
+
+#include <fennec/lang/types.h>
+
+namespace fennec
+{
+
+///
+/// \brief C++ Iterator Specification \f$begin()\f$
+/// \tparam ContainerT the container type
+/// \param c the container to iterate on
+/// \returns an iterator at the start of the container
+template<typename ContainerT>
+inline constexpr auto begin(ContainerT& c) noexcept(noexcept(c.begin())) -> decltype(c.begin()) {
+	return c.begin();
+}
+
+///
+/// \brief C++ Iterator Specification \f$begin()\f$
+/// \tparam ContainerT the container type
+/// \param c the container to iterate on
+/// \returns an iterator at the start of the container
+template<typename ContainerT>
+inline constexpr auto begin(const ContainerT& c) noexcept(noexcept(c.begin())) -> decltype(c.begin()) {
+	return c.begin();
+}
+
+///
+/// \brief C++ Iterator Specification \f$begin()\f$
+/// \tparam T the element type
+/// \tparam N the bounds of the array
+/// \param arr a bounded array to iterate on
+/// \returns an iterator at the start of the array
+template<typename T, size_t N>
+inline constexpr T* begin(T (&arr)[N]) noexcept {
+	return arr;
+}
+
+
+///
+/// \brief C++ Iterator Specification \f$end()\f$
+/// \tparam ContainerT the container type
+/// \param c the container to iterate on
+/// \returns an iterator at the end of the container
+template<typename ContainerT>
+inline constexpr auto end(ContainerT& c) noexcept(noexcept(c.end())) -> decltype(c.end()) {
+	return c.end();
+}
+
+///
+/// \brief C++ Iterator Specification \f$end()\f$
+/// \tparam ContainerT the container type
+/// \param c the container to iterate on
+/// \returns an iterator at the end of the container
+template<typename ContainerT>
+inline constexpr auto end(const ContainerT& c) noexcept(noexcept(c.end())) -> decltype(c.end()) {
+	return c.end();
+}
+
+///
+/// \brief C++ Iterator Specification \f$end()\f$
+/// \tparam T the element type
+/// \tparam N the bounds of the array
+/// \param arr a bounded array to iterate on
+/// \returns an iterator at the end of the array
+template<typename T, size_t N>
+inline constexpr T* end(T (&arr)[N]) noexcept {
+	return arr + N;
+}
+
+}
+
+#endif // FENNEC_LANG_RANGES_H

include/fennec/lang/static_constructor.h

@@ -1,6 +1,6 @@
 // =====================================================================================================================
 //  fennec, a free and open source game engine
-//  Copyright © 2025  Medusa Slockbower
+//  Copyright © 2025 - 2026  Medusa Slockbower
 //
 //  This program is free software: you can redistribute it and/or modify
 //  it under the terms of the GNU General Public License as published by
@@ -19,10 +19,19 @@
 #ifndef FENNEC_LANG_STARTUP_H
 #define FENNEC_LANG_STARTUP_H
 
-// Helper for running a function before main()
+///
-#define STATIC_CONSTRUCTOR(f) \
+/// \brief Macro for running a function before main
+/// \param f the name of the function
+#define FENNEC_PRIVATE_STATIC_CONSTRUCTOR(f) \
 	inline static void f(void); \
 	struct f##_t_ { inline f##_t_(void) { f(); } }; inline static f##_t_ f##_; \
 	inline static void f(void)
 
+///
+/// \brief Macro for running a function before main in a class scope
+/// \param f the name of the function
+#define FENNEC_CLASS_STATIC_CONSTRUCTOR(f) \
+	struct f##_t_ { inline f##_t_(void) { f(); } }; inline static f##_t_ f##_; \
+	inline static void f(void)
+
 #endif // FENNEC_LANG_STARTUP_H

include/fennec/lang/type_identity.h

@@ -1,6 +1,6 @@
 // =====================================================================================================================
 //  fennec, a free and open source game engine
-//  Copyright © 2025  Medusa Slockbower
+//  Copyright © 2025 - 2026  Medusa Slockbower
 //
 //  This program is free software: you can redistribute it and/or modify
 //  it under the terms of the GNU General Public License as published by

include/fennec/lang/type_operators.h

@@ -1,6 +1,6 @@
 // =====================================================================================================================
 //  fennec, a free and open source game engine
-//  Copyright © 2025  Medusa Slockbower
+//  Copyright © 2025 - 2026  Medusa Slockbower
 //
 //  This program is free software: you can redistribute it and/or modify
 //  it under the terms of the GNU General Public License as published by
@@ -26,26 +26,38 @@ namespace fennec
 
 // has_equals ==========================================================================================================
 
+///
+/// \brief Checks if a type has a defined equality operator
+/// \tparam T0 The first type
+/// \tparam T1 The second type
 template<typename T0, typename T1 = T0>
 struct has_equals {
+private:
 	// Use SFINAE to check for the operator
 	template<typename U, typename V> static auto test(U*) -> decltype(declval<U>() == declval<V>());
 	template<typename, typename>     static auto test(...) -> false_type;
 
-	static constexpr bool value = is_same_v<bool, decltype(test<T0, T1>(0))>;
+public:
+	static constexpr bool value = is_same_v<bool, decltype(test<T0, T1>(0))>; //!< The result of the check
 };
 
 template<typename T0, typename T1 = T0> constexpr bool has_equals_v = has_equals<T0, T1>::value;
 
 // has_nequals =========================================================================================================
 
+///
+/// \brief Checks if a type has a defined inequality operator
+/// \tparam T0 The first type
+/// \tparam T1 The second type
 template<typename T0, typename T1 = T0>
 struct has_nequals {
+private:
 	// Use SFINAE to check for the operator
 	template<typename U, typename V> static auto test(U*) -> decltype(declval<U>() != declval<V>());
 	template<typename, typename>     static auto test(...) -> false_type;
 
-	static constexpr bool value = is_same_v<bool, decltype(test<T0, T1>(0))>;
+public:
+	static constexpr bool value = is_same_v<bool, decltype(test<T0, T1>(0))>; //!< The result of the check
 };
 
 template<typename T0, typename T1 = T0> constexpr bool has_nequals_v = has_nequals<T0, T1>::value;
@@ -53,13 +65,19 @@ template<typename T0, typename T1 = T0> constexpr bool has_nequals_v = has_nequa
 
 // has_less ============================================================================================================
 
+///
+/// \brief Checks if a type has a defined less operator
+/// \tparam T0 The first type
+/// \tparam T1 The second type
 template<typename T0, typename T1 = T0>
 struct has_less {
+private:
 	// Use SFINAE to check for the operator
 	template<typename U, typename V> static auto test(U*) -> decltype(declval<U>() < declval<V>());
 	template<typename, typename>     static auto test(...) -> false_type;
 
-	static constexpr bool value = is_same_v<bool, decltype(test<T0, T1>(0))>;
+public:
+	static constexpr bool value = is_same_v<bool, decltype(test<T0, T1>(0))>; //!< The result of the check
 };
 
 template<typename T0, typename T1 = T0> constexpr bool has_less_v = has_less<T0, T1>::value;
@@ -67,13 +85,19 @@ template<typename T0, typename T1 = T0> constexpr bool has_less_v = has_less<T0,
 
 // has_less_equals =====================================================================================================
 
+///
+/// \brief Checks if a type has a defined less equals operator
+/// \tparam T0 The first type
+/// \tparam T1 The second type
 template<typename T0, typename T1 = T0>
 struct has_less_equals {
+private:
 	// Use SFINAE to check for the operator
 	template<typename U, typename V> static auto test(U*) -> decltype(declval<U>() <= declval<V>());
 	template<typename, typename>     static auto test(...) -> false_type;
 
-	static constexpr bool value = is_same_v<bool, decltype(test<T0, T1>(0))>;
+public:
+	static constexpr bool value = is_same_v<bool, decltype(test<T0, T1>(0))>; //!< The result of the check
 };
 
 template<typename T0, typename T1 = T0> constexpr bool has_less_equals_v = has_less_equals<T0, T1>::value;
@@ -81,13 +105,19 @@ template<typename T0, typename T1 = T0> constexpr bool has_less_equals_v = has_l
 
 // has_greater =========================================================================================================
 
+///
+/// \brief Checks if a type has a defined greater operator
+/// \tparam T0 The first type
+/// \tparam T1 The second type
 template<typename T0, typename T1 = T0>
 struct has_greater {
+private:
 	// Use SFINAE to check for the operator
 	template<typename U, typename V> static auto test(U*) -> decltype(declval<U>() > declval<V>());
 	template<typename, typename>     static auto test(...) -> false_type;
 
-	static constexpr bool value = is_same_v<bool, decltype(test<T0, T1>(0))>;
+public:
+	static constexpr bool value = is_same_v<bool, decltype(test<T0, T1>(0))>; //!< The result of the check
 };
 
 template<typename T0, typename T1 = T0> constexpr bool has_greater_v = has_greater<T0, T1>::value;
@@ -95,13 +125,19 @@ template<typename T0, typename T1 = T0> constexpr bool has_greater_v = has_great
 
 // has_greater_equals ==================================================================================================
 
+///
+/// \brief Checks if a type has a defined greater equals operator
+/// \tparam T0 The first type
+/// \tparam T1 The second type
 template<typename T0, typename T1 = T0>
 struct has_greater_equals {
+private:
 	// Use SFINAE to check for the operator
 	template<typename U, typename V> static auto test(U*) -> decltype(declval<U>() >= declval<V>());
 	template<typename, typename>     static auto test(...) -> false_type;
 
-	static constexpr bool value = is_same_v<bool, decltype(test<T0, T1>(0))>;
+public:
+	static constexpr bool value = is_same_v<bool, decltype(test<T0, T1>(0))>; //!< The result of the check
 };
 
 template<typename T0, typename T1 = T0> constexpr bool has_greater_equals_v = has_greater_equals<T0, T1>::value;

include/fennec/lang/type_sequences.h

@@ -1,6 +1,6 @@
 // =====================================================================================================================
 //  fennec, a free and open source game engine
-//  Copyright © 2025  Medusa Slockbower
+//  Copyright © 2025 - 2026  Medusa Slockbower
 //
 //  This program is free software: you can redistribute it and/or modify
 //  it under the terms of the GNU General Public License as published by
@@ -17,14 +17,14 @@
 // =====================================================================================================================
 
 ///
-/// \file type_sequences.h
+/// \file fennec/lang/type_sequences.h
 /// \brief \ref fennec_lang_type_sequences
 ///
 ///
 /// \details
 /// \author Medusa Slockbower
 ///
-/// \copyright Copyright © 2025 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
+/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
 ///
 ///
 
@@ -51,6 +51,12 @@
 ///         \ref fennec::replace_first_element "typename replace_first_element<ClassT, SubT, OriginT, RestT...>::type"<br>
 ///     <td width="50%" style="vertical-align: top">
 ///         \copydoc fennec::replace_first_element
+///
+/// <tr><td width="50%" style="vertical-align: top"> <br>
+///         \ref fennec::is_unique "is_unique<TypesT...>::value"<br>
+///         \ref fennec::is_unique_v "is_unique_v<TypesT...>"
+///     <td width="50%" style="vertical-align: top">
+///         \copydoc fennec::is_unique
 /// </table>
 ///
 
@@ -59,23 +65,47 @@
 namespace fennec
 {
 
+
+template<typename...TypesT> struct type_sequence {};
+
+
+// fennec::first_element ===============================================================================================
+
 ///
 /// \brief Get the first element of a template parameter pack
 /// \tparam TypesT the Parameter Pack
 template<typename...TypesT> struct first_element : detail::_first_element<TypesT...> {};
 
 ///
-/// \brief alias for first_element<TypesT>::type
+/// \brief alias for `first_element<TypesT...>::type`
+/// \tparam TypesT the Parameter Pack
 template<typename...TypesT> using first_element_t = typename first_element<TypesT...>::type;
 
 
-template<size_t n, typename...TypesT> struct nth_element : detail::_nth_element<n, 0, TypesT...> {};
 
+// fennec::nth_element =================================================================================================
 
 ///
-/// \brief Take a Template with a Pack `ClassT<ArgsT...>` and replace the first `ArgT` of `ArgsT...` with `SubT`
+/// \brief Gets the type of the nth element of the type sequence `TypesT...`
+/// \tparam n The index in the type sequence
+/// \tparam TypesT The type sequence
+template<size_t n, typename...TypesT> struct nth_element : detail::_nth_element<n, 0, TypesT...> {};
+
+///
+/// \brief alias for nth_element<n, TypesT>::type
+/// \tparam n The index in the type sequence
+/// \tparam TypesT the Parameter Pack
+template<size_t n, typename...TypesT> using nth_element_t = nth_element<n, TypesT...>::type;
+
+
+
+// fennec::replace_first_element =======================================================================================
+
+///
+/// \brief Take a Template with a Pack `ClassT<ArgsT...>` and replace the first \f$ArgT\f$ of `ArgsT...` with \f$SubT\f$
 template<typename ClassT, typename SubT> struct replace_first_element { };
 
+#ifndef FENNEC_DOXYGEN
 // Implementation
 template<
 	template<typename, typename...> class ClassT              // The Base Template
@@ -83,6 +113,106 @@ template<
 ,	typename... RestT>                                        // The Rest of the Parameter Pack
 struct replace_first_element<ClassT<OriginT, RestT...>, SubT> // Specialization
 	{ using type = ClassT<SubT, RestT...>; };                 // Definition
+#endif
+
+
+
+// fennec::max_element_size ============================================================================================
+
+///
+/// \brief Gets the max value of the size of each type in the sequence, i.e. `max(sizeof(Ts)...)`
+/// \tparam Ts The type sequence to check
+template<typename...Ts> struct max_element_size : detail::_max_element_size<0, Ts...> {};
+
+///
+/// \brief Shorthand for `max_element_size<Ts...>::value`
+/// \tparam Ts The type sequence to check
+template<typename...Ts> constexpr size_t max_element_size_v = max_element_size<Ts...>::value;
+
+
+
+// fennec::find_element ================================================================================================
+
+///
+/// \brief Finds the index of \f$T\f$ in \f$Ts\f$, if \f$T\f$ is not found, results in `sizeof...(Ts)`
+/// \tparam T The type to find
+/// \tparam Ts The type sequence to check
+template<typename T, typename...Ts> struct find_element : detail::_find_element<0, T, Ts...> {};
+
+///
+/// \brief Shorthand for `find_element<T, Ts...>::value`
+/// \tparam T The type to find
+/// \tparam Ts The type sequence to check
+template<typename T, typename...Ts> constexpr size_t find_element_v = find_element<T, Ts...>::value;
+
+
+
+// fennec::search_element ==============================================================================================
+
+
+///
+/// \brief Find the first element in `TypesT...` that satisfies `SearchT<T>`
+/// \tparam SearchT A type that satisfies `template<typename>` and contains `static constexpr bool value;` to use for searching
+/// \tparam TypesT The type sequence to search
+template<template<typename> typename SearchT, typename...TypesT> struct search_element : detail::_search_element<SearchT, TypesT...> {};
+
+///
+/// \brief Shorthand for `search_element_t<T, Ts...>::type`
+/// \tparam SearchT A type that satisfies `template<typename>` and contains `static constexpr bool value;` to use for searching
+/// \tparam TypesT The type sequence to search
+template<template<typename> typename SearchT, typename...TypesT> using search_element_t = search_element<SearchT, TypesT...>::type;
+
+template<template<typename, typename...> typename, typename, typename...> struct search_element_args;
+
+///
+/// \brief Find the first element `T` in `TypesT...` that satisfies `SearchT<T, ArgsT...>`
+/// \tparam SearchT A type that satisfies `template<typename>` and contains `static constexpr bool value;` to use for searching
+/// \tparam TypesT The type sequence to search
+/// \tparam ArgsT The arguments for the search
+template<template<typename, typename...> typename SearchT, typename...TypesT, typename...ArgsT>
+struct search_element_args<SearchT, type_sequence<ArgsT...>, TypesT...>
+	: detail::_search_element_args<SearchT, detail::_type_sequence<ArgsT...>, TypesT...> {
+};
+
+
+
+
+// fennec::contains_element ============================================================================================
+
+///
+/// \brief Checks if the type sequence `Ts...` contains \f$T\f$
+/// \tparam T The type to find
+/// \tparam Ts The type sequence to check
+template<typename T, typename...Ts> struct contains_element : bool_constant<(is_same_v<T, Ts> or ...)> {};
+
+///
+/// \brief Shorthand for `contains_element_v<T, Ts...>::value`
+/// \tparam T The type to find
+/// \tparam Ts The type sequence to check
+template<typename T, typename...Ts> constexpr bool contains_element_v = contains_element<T, Ts...>::value;
+
+
+
+// fennec::is_unique ===================================================================================================
+
+///
+/// \brief Checks if all types in a type sequence are unique
+/// \tparam Ts The type sequence to check
+template<typename...Ts> struct is_unique : false_type {};
+
+#ifndef FENNEC_DOXYGEN
+// Single type case
+template<typename T>  struct is_unique<T> : true_type {};
+
+// Recursion case
+template<typename T, typename...Ts> requires(not is_same_v<T, Ts> && ...)
+struct is_unique<T, Ts...> : is_unique<Ts...> {};
+#endif
+
+///
+/// \brief Shorthand for `is_unique<Ts...>::value`
+/// \tparam Ts The type sequence to check
+template<typename...Ts> constexpr bool is_unique_v = is_unique<Ts...>::value;
 
 }
 

include/fennec/lang/type_transforms.h

@@ -1,6 +1,6 @@
 // =====================================================================================================================
 //  fennec, a free and open source game engine
-//  Copyright © 2025  Medusa Slockbower
+//  Copyright © 2025 - 2026  Medusa Slockbower
 //
 //  This program is free software: you can redistribute it and/or modify
 //  it under the terms of the GNU General License as published by
@@ -17,21 +17,23 @@
 // =====================================================================================================================
 
 ///
-/// \file type_transforms.h
+/// \file fennec/lang/type_transforms.h
 /// \brief \ref fennec_lang_type_transforms
 ///
 ///
 /// \details
 /// \author Medusa Slockbower
 ///
-/// \copyright Copyright © 2025 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
+/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
 ///
 ///
 
 #ifndef FENNEC_LANG_TYPE_TRANSFORMS_H
 #define FENNEC_LANG_TYPE_TRANSFORMS_H
 
+#include <fennec/lang/conditional_types.h>
 #include <fennec/lang/type_identity.h>
+#include <fennec/lang/detail/_type_traits.h>
 #include <fennec/lang/detail/_type_transforms.h>
 
 ///
@@ -42,8 +44,22 @@
 ///
 /// \code #include <fennec/lang/type_transforms.h> \endcode
 ///
+/// \section fennec_lang_type_transforms_section_decay_conversions Decay Conversions
 ///
-/// <table width="100%" class="fieldtable" id="table_fennec_lang_type_transforms">
+/// <table width="100%" class="fieldtable" id="fennec_lang_type_transforms_decay_conversions">
+/// <tr><th style="vertical-align: top">Syntax
+///     <th style="vertical-align: top">Description
+/// <tr><td width="50%" style="vertical-align: top"> <br>
+///         \ref fennec::decay "decay<TypeT>::type"<br>
+///         \ref fennec::decay_t "decay_t<TypeT>"
+///     <td width="50%" style="vertical-align: top">
+///         \copydetails fennec::decay
+///
+/// </table>
+///
+/// \section fennec_lang_type_transforms_section_pointer_conversions Pointer Conversions
+///
+/// <table width="100%" class="fieldtable" id="fennec_lang_type_transforms_pointer_conversions">
 /// <tr><th style="vertical-align: top">Syntax
 ///     <th style="vertical-align: top">Description
 /// <tr><td width="50%" style="vertical-align: top"> <br>
@@ -59,17 +75,49 @@
 ///         \copydetails fennec::remove_pointer
 ///
 /// <tr><td width="50%" style="vertical-align: top"> <br>
+///         \ref fennec::strip_pointers "strip_pointers<TypeT>::type"<br>
+///         \ref fennec::strip_pointers_t "strip_pointers<TypeT>"
+///     <td width="50%" style="vertical-align: top">
+///         \copydetails fennec::strip_pointers
+///
+/// </table>
+///
+/// \section fennec_lang_type_transforms_section_reference_conversions Reference Conversions
+///
+/// <table width="100%" class="fieldtable" id="fennec_lang_type_transforms_reference_conversions">
+/// <tr><th style="vertical-align: top">Syntax
+///     <th style="vertical-align: top">Description
+/// <tr><td width="50%" style="vertical-align: top"> <br>
 ///         \ref fennec::add_reference "add_reference<TypeT>::type"<br>
 ///         \ref fennec::add_reference_t "add_reference_t<TypeT>"
 ///     <td width="50%" style="vertical-align: top">
 ///         \copydetails fennec::add_reference
 ///
 /// <tr><td width="50%" style="vertical-align: top"> <br>
+///         \ref fennec::add_lvalue_reference "add_lvalue_reference<TypeT>::type"<br>
+///         \ref fennec::add_lvalue_reference_t "add_lvalue_reference_t<TypeT>"
+///     <td width="50%" style="vertical-align: top">
+///         \copydetails fennec::add_lvalue_reference
+///
+/// <tr><td width="50%" style="vertical-align: top"> <br>
+///         \ref fennec::add_rvalue_reference "add_rvalue_reference<TypeT>::type"<br>
+///         \ref fennec::add_rvalue_reference_t "add_rvalue_reference_t<TypeT>"
+///     <td width="50%" style="vertical-align: top">
+///         \copydetails fennec::add_rvalue_reference
+///
+/// <tr><td width="50%" style="vertical-align: top"> <br>
 ///         \ref fennec::remove_reference "remove_reference<TypeT>::type"<br>
 ///         \ref fennec::remove_reference_t "remove_reference_t<TypeT>"
 ///     <td width="50%" style="vertical-align: top">
 ///         \copydetails fennec::remove_reference
 ///
+/// </table>
+///
+/// \section fennec_lang_type_transforms_section_cv_conversions Const — Volatile Conversions
+///
+/// <table width="100%" class="fieldtable" id="fennec_lang_type_transforms_cv_conversions">
+/// <tr><th style="vertical-align: top">Syntax
+///     <th style="vertical-align: top">Description
 /// <tr><td width="50%" style="vertical-align: top"> <br>
 ///         \ref fennec::add_const "add_const<TypeT>::type"<br>
 ///         \ref fennec::add_const_t "add_const_t<TypeT>"
@@ -107,16 +155,22 @@
 ///         \copydetails fennec::remove_cv
 ///
 /// <tr><td width="50%" style="vertical-align: top"> <br>
-///         \ref fennec::add_cvr "add_cvr<TypeT>::type"<br>
+///         \ref fennec::add_cvref "add_cvref<TypeT>::type"<br>
-///         \ref fennec::add_cvr_t "add_cvr_t<TypeT>"
+///         \ref fennec::add_cvref_t "add_cvref_t<TypeT>"
 ///     <td width="50%" style="vertical-align: top">
-///         \copydetails fennec::add_cvr
+///         \copydetails fennec::add_cvref
 ///
 /// <tr><td width="50%" style="vertical-align: top"> <br>
-///         \ref fennec::remove_cvr "remove_cvr<TypeT>::type"<br>
+///         \ref fennec::remove_cvref "remove_cvref<TypeT>::type"<br>
-///         \ref fennec::remove_cvr_t "remove_cvr_t<TypeT>"
+///         \ref fennec::remove_cvref_t "remove_cvref_t<TypeT>"
 ///     <td width="50%" style="vertical-align: top">
-///         \copydetails fennec::remove_cvr
+///         \copydetails fennec::remove_cvref
+///
+/// <tr><td width="50%" style="vertical-align: top"> <br>
+///         \ref fennec::remove_cvrefptr "remove_cvrefptr<TypeT>::type"<br>
+///         \ref fennec::remove_cvrefptr_t "remove_cvrefptr_t<TypeT>"
+///     <td width="50%" style="vertical-align: top">
+///         \copydetails fennec::remove_cvrefptr
 ///
 /// </table>
 ///
@@ -125,14 +179,26 @@
 namespace fennec
 {
 
+// Decay Conversions ===================================================================================================
+
+///
+/// \brief decays a type into its most basic form
+/// \tparam T the type to decay
+template<typename T> struct decay : detail::_decay<T> {};
+
+///
+/// \brief shorthand for `typename decay<T>::type`
+/// \tparam T the type to decay
+template<typename T> using decay_t = typename decay<T>::type;
+
 // Pointer Conversions =================================================================================================
 
 ///
-/// \brief adds a pointer level to \p T
+/// \brief adds a pointer level to \f$T\f$
 ///
-/// \details adds a pointer to the provided type such that `T` becomes `T*`
+/// \details adds a pointer to the provided type such that \f$T\f$ becomes \f$T*\f$
 /// \tparam T Resultant Type
-template<typename T> struct add_pointer : type_identity<T*>{};
+template<typename T> struct add_pointer : detail::_add_pointer<T>{};
 
 ///
 /// \brief shorthand for `typename add_pointer<T>::type`
@@ -140,212 +206,209 @@ template<typename T> using add_pointer_t = typename add_pointer<T>::type;
 
 
 ///
-/// \brief removes a pointer level from \p T
+/// \brief removes a pointer level from \f$T\f$
 ///
-/// \details removes a pointer from the provided type such that `T*` becomes `T`
+/// \details removes a pointer from the provided type such that \f$T*\f$ becomes \f$T\f$
 /// \tparam T Resultant Type
-template<typename T> struct remove_pointer : type_identity<T> {};
+template<typename T> struct remove_pointer : detail::_remove_pointer<T> {};
-
-// specialization for T*
-template<typename T> struct remove_pointer<T*> : type_identity<T> {};
 
 ///
 /// \brief shorthand for `typename remove_pointer<T>::type`
 template<typename T> using remove_pointer_t = typename remove_pointer<T>::type;
 
 
+///
+/// \brief removes all pointer levels from \f$T\f$
+///
+/// \details removes all pointers from the provided type such that \f$T*\f$, \f$T**\f$, etc. becomes \f$T\f$
+/// \tparam T Resultant Type
+template<typename T> struct strip_pointers : conditional_t<
+			detail::_is_pointer<T>::value,
+			strip_pointers<remove_pointer_t<T>>,
+			type_identity<T>
+		> {};
+
+///
+/// \brief shorthand for `typename strip_pointers<T>::type`
+template<typename T> using strip_pointers_t = strip_pointers<T>::type;
+
+
 
 // Reference Conversions ===============================================================================================
 
 ///
-/// \brief add a reference to \p T
+/// \brief add a reference to \f$T\f$
 ///
-/// \details adds a pointer to the provided type such that `T` becomes `T&`
+/// \details adds a pointer to the provided type such that \f$T\f$ becomes \f$T\&\f$
 /// \tparam T Resultant Type
 template<typename T> struct add_reference : type_identity<T&> {};
 
 ///
-/// \brief shorthand for `typename add_reference<T>::type`
+/// \brief shorthand for `typename fennec::add_reference<T>::type`
 template<typename T> using  add_reference_t = typename add_reference<T>::type;
 
 
 ///
-/// \brief remove a reference from \p T
+/// \brief add a lvalue reference to \f$T\f$
 ///
-/// \details removes references from the provided type such that `T&` and `T&&` become `T`
+/// \details adds a lvalue reference to the provided type such that \f$T\f$ becomes \f$T\&\f$
-/// \tparam T Reference Type
-template<typename T> struct remove_reference : type_identity<T> {};
-
-// specialization for `T&`
-template<typename T> struct remove_reference<T&> : type_identity<T> {};
-
-// specialization for `T&&`
-template<typename T> struct remove_reference<T&&> : type_identity<T> {};
-
-///
-/// \brief shorthand for `typename remove_reference<T>::type`
-template<typename T> using  remove_reference_t = typename remove_reference<T>::type;
-
-
-///
-/// \brief add a lvalue reference to \p T
-///
-/// \details adds a lvalue reference to the provided type such that 'T' becomes 'T&'
 /// \tparam T Reference Type
 template<typename T> struct add_lvalue_reference : detail::_add_lvalue_reference<T> {};
 
 ///
-/// \brief shorthand for `typename remove_reference<T>::type`
+/// \brief shorthand for `typename fennec::add_lvalue_reference<T>::type`
 template<typename T> using  add_lvalue_reference_t = typename add_lvalue_reference<T>::type;
 
 
 ///
-/// \brief add a rvalue reference to \p T
+/// \brief add a rvalue reference to \f$T\f$
 ///
-/// \details adds a rvalue reference to the provided type such that 'T' becomes 'T&&'
+/// \details adds a rvalue reference to the provided type such that \f$T\f$ becomes \f$T\&\&\f$
 /// \tparam T Reference Type
 template<typename T> struct add_rvalue_reference : detail::_add_rvalue_reference<T> {};
 
 ///
-/// \brief shorthand for `typename remove_reference<T>::type`
+/// \brief shorthand for `typename fennec::add_rvalue_reference<T>::type`
 template<typename T> using  add_rvalue_reference_t = typename add_rvalue_reference<T>::type;
 
 
+///
+/// \brief remove a reference from \f$T\f$
+///
+/// \details removes references from the provided type such that \f$T\&\f$ and \f$T\&\&\f$ become \f$T\f$
+/// \tparam T Reference Type
+template<typename T> struct remove_reference : type_identity<T> {};
+
+// specialization for T&
+template<typename T> struct remove_reference<T&> : type_identity<T> {};
+
+// specialization for T&&
+template<typename T> struct remove_reference<T&&> : type_identity<T> {};
+
+///
+/// \brief shorthand for `typename fennec::remove_reference<T>::type`
+template<typename T> using  remove_reference_t = typename remove_reference<T>::type;
+
+
 
 // Const & Volatile Conversions ========================================================================================
 
 ///
-/// \brief add the const qualifier to the provided type \p T
+/// \brief add the const qualifier to the provided type \f$T\f$
 ///
-/// \details adds const qualification to the provided type such that `T` becomes `const T`
+/// \details adds const qualification to the provided type such that \f$T\f$ becomes \f$const\quad T\f$
 /// \tparam T Reference Type
-template<typename T> struct add_const : type_identity<const T> {};
+template<typename T> struct add_const : detail::_add_const<T> {};
 
 ///
-/// \brief shorthand for `typename add_const<T>::type`
+/// \brief shorthand for `typename fennec::add_const<T>::type`
 template<typename T> using add_const_t = typename add_const<T>::type;
 
-// specialization for const types
-template<typename T> struct add_const<const T> : type_identity<const T> {};
-
 
 ///
-/// \brief remove the const qualifier from the provided type \p T
+/// \brief remove the const qualifier from the provided type \f$T\f$
 ///
-/// \details removes const qualification from the provided type such that `const T` becomes `T`
+/// \details removes const qualification from the provided type such that \f$const\quad T\f$ becomes \f$T\f$
 /// \tparam T Reference Type
-template<typename T> struct remove_const : type_identity<T> {};
+template<typename T> struct remove_const : detail::_remove_const<T> {};
 
 ///
-/// \brief shorthand for `typename remove_const<T>::type`
+/// \brief shorthand for `typename fennec::remove_const<T>::type`
 template<typename T> using remove_const_t = typename remove_const<T>::type;
 
-// specialization for const types
-template<typename T> struct remove_const<const T> : type_identity<T> {};
-
 
 
 ///
-/// \brief add the volatile qualifier to the provided type \p T
+/// \brief add the volatile qualifier to the provided type \f$T\f$
 ///
-/// \details removes references from the provided type such that `T` becomes `volatile T`
+/// \details removes references from the provided type such that \f$T\f$ becomes \f$volatile\quad T\f$
 /// \tparam T Reference Type
-template<typename T> struct add_volatile : type_identity<volatile T> {};
+template<typename T> struct add_volatile : detail::_add_volatile<T> {};
 
 ///
-/// \brief shorthand for `typename add_volatile<T>::type`
+/// \brief shorthand for `typename fennec::add_volatile<T>::type`
 template<typename T> using add_volatile_t = typename add_volatile<T>::type;
 
-// specialization for volatile types
-template<typename T> struct add_volatile<volatile T> : type_identity<volatile T> {};
-
 
 ///
-/// \brief remove the volatile qualifier from the provided type \p T
+/// \brief remove the volatile qualifier from the provided type \f$T\f$
 ///
-/// \details removes references from the provided type such that `volatile T` becomes `T`
+/// \details removes references from the provided type such that \f$volatile\quad T\f$ becomes \f$T\f$
 /// \tparam T Reference Type
-template<typename T> struct remove_volatile : type_identity<T> {};
+template<typename T> struct remove_volatile : detail::_remove_volatile<T> {};
 
 ///
-/// \brief shorthand for `typename remove_volatile<T>::type`
+/// \brief shorthand for `typename fennec::remove_volatile<T>::type`
 template<typename T> using remove_volatile_t = typename remove_volatile<T>::type;
 
-// specialization for volatile types
-template<typename T> struct remove_volatile<volatile T> : type_identity<T> {};
-
 
 
 ///
-/// \brief remove the volatile qualifier from the provided type \p T
+/// \brief remove the volatile qualifier from the provided type \f$T\f$
 ///
-/// \details removes references from the provided type such that `T`, `const T`, and `volatile T` become
+/// \details removes references from the provided type such that \f$T\f$, \f$const\quad T\f$, and \f$volatile\quad T\f$
-///          `const volatile T`
+///			 become \f$const volatile T\f$
 /// \tparam T Reference Type
-template<typename T> struct add_cv : type_identity<const volatile T> {};
+template<typename T> struct add_cv : detail::_add_cv<T> {};
 
 ///
-/// \brief shorthand for `typename add_cv<T>::type`
+/// \brief shorthand for `typename fennec::add_cv<T>::type`
 template<typename T> using add_cv_t = typename add_cv<T>::type;
 
-// specialization for const types
-template<typename T> struct add_cv<const T> : type_identity<const volatile T> {};
-
-// specialization for volatile types
-template<typename T> struct add_cv<volatile T> : type_identity<const volatile T> {};
-
-// specialization for const volatile types
-template<typename T> struct add_cv<const volatile T> : type_identity<const volatile T> {};
-
 
 
 ///
-/// \brief remove the const and volatile qualifiers from the provided type \p T
+/// \brief remove the const and volatile qualifiers from the provided type \f$T\f$
 ///
-/// \details removes const and volatile from the provided type such that `const T`, `volatile T`, and
+/// \details removes const and volatile from the provided type such that \f$const\quad T\f$, \f$volatile\quad T\f$, and
-///          `const volatile T` become `T`
+///          \f$const\quad volatile\quad T\f$ become \f$T\f$
 /// \tparam T Reference Type
-template<typename T> struct remove_cv : type_identity<T> {};
+template<typename T> struct remove_cv : detail::_remove_cv<T> {};
-
-// specialization for const types
-template<typename T> struct remove_cv<const T> : type_identity<T> {};
-
-// specialization for volatile types
-template<typename T> struct remove_cv<volatile T> : type_identity<T> {};
-
-// specialization for const volatile types
-template<typename T> struct remove_cv<const volatile T> : type_identity<T> {};
 
 ///
-/// \brief shorthand for `typename remove_cv<T>::type`
+/// \brief shorthand for `typename fennec::remove_cv<T>::type`
 template<typename T> using remove_cv_t = typename remove_cv<T>::type;
 
 
 
 ///
-/// \brief add a reference and the const volatile qualifiers from the provided type \p T
+/// \brief add a reference and the const volatile qualifiers from the provided type \f$T\f$
 ///
 /// \details adds references and const volatile qualifiers to the provided type.
 /// \tparam T Reference Type
-template<typename T> struct add_cvr : type_identity<add_reference_t<add_cv_t<T>>> {};
+template<typename T> struct add_cvref : type_identity<add_reference_t<add_cv_t<T>>> {};
 
 ///
-/// \brief shorthand for `typename add_cvr<T>::type`
+/// \brief shorthand for `typename fennec::add_cvr<T>::type`
-template<typename T> using add_cvr_t = typename add_cvr<T>::type;
+template<typename T> using add_cvref_t = typename add_cvref<T>::type;
 
 
 
 ///
-/// \brief removes references as well as the const and volatile qualifiers from the provided type \p T
+/// \brief removes references as well as the const and volatile qualifiers from the provided type \f$T\f$
 ///
 /// \details removes const and volatile from the provided type such that
 /// \tparam T Reference Type
-template<typename T> struct remove_cvr : type_identity<remove_cv_t<remove_reference_t<T>>> {};
+template<typename T> struct remove_cvref : type_identity<remove_cv_t<remove_reference_t<T>>> {};
 
 
 ///
-/// \brief shorthand for `typename remove_cvr<T>::type`
+/// \brief shorthand for `typename fennec::remove_cvr<T>::type`
-template<typename T> using remove_cvr_t = typename remove_cvr<T>::type;
+template<typename T> using remove_cvref_t = typename remove_cvref<T>::type;
+
+
+
+///
+/// \brief removes references and pointers as well as the const and volatile qualifiers from the provided type \f$T\f$
+///
+/// \details removes const and volatile from the provided type such that
+/// \tparam T Reference Type
+template<typename T> struct remove_cvrefptr : type_identity<remove_cv_t<remove_reference_t<strip_pointers_t<T>>>> {};
+
+
+///
+/// \brief shorthand for `typename fennec::remove_cvrp_t<T>::type`
+template<typename T> using remove_cvrefptr_t = typename remove_cvrefptr<T>::type;
 
 }
 

include/fennec/lang/types.h

@@ -1,6 +1,6 @@
 // =====================================================================================================================
 //  fennec, a free and open source game engine
-//  Copyright © 2025  Medusa Slockbower
+//  Copyright © 2025 - 2026  Medusa Slockbower
 //
 //  This program is free software: you can redistribute it and/or modify
 //  it under the terms of the GNU General Public License as published by
@@ -17,14 +17,14 @@
 // =====================================================================================================================
 
 ///
-/// \file types.h
+/// \file fennec/lang/types.h
 /// \brief \ref fennec_lang_types
 ///
 ///
 /// \details
 /// \author Medusa Slockbower
 ///
-/// \copyright Copyright © 2025 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
+/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
 ///
 ///
 
@@ -192,6 +192,16 @@
 ///     \copybrief fennec::ptrdiff_t
 ///
 /// <tr><td width="50%" style="vertical-align: top"> <br>
+///		<tt>\ref fennec::empty_t "empty_t"</tt>
+///     <td width="50%" style="vertical-align: top">
+///     \copybrief fennec::empty_t
+///
+/// <tr><td width="50%" style="vertical-align: top"> <br>
+///		<tt>\ref fennec::undefined_t "undefined_t"</tt>
+///     <td width="50%" style="vertical-align: top">
+///     \copybrief fennec::undefined_t
+///
+/// <tr><td width="50%" style="vertical-align: top"> <br>
 ///		<tt>\ref fennec::void_t "void_t"</tt>
 ///     <td width="50%" style="vertical-align: top">
 ///     \copybrief fennec::void_t
@@ -203,8 +213,6 @@
 
 #include <fennec/lang/detail/_int.h>
 
-#include <fennec/lang/conditional_types.h>
-
 namespace fennec
 {
 	// Basic Types =========================================================================================================
@@ -213,26 +221,28 @@ namespace fennec
 	/// \name Basic Types
 	/// @{
 
-	using bool_t = bool; ///< \brief A conditional type
+	using bool_t = bool; //!< \brief A conditional type.
 
-	using char_t  = char;          ///< \brief A type capable of holding an ascii value
+	using byte_t = unsigned char; //!< \brief A type capable of holding a single byte.
-	using schar_t = signed char;   ///< \brief A type with the size of a char, capable of holding a signed 8-bit integer
-	using uchar_t = unsigned char; ///< \brief A type with the size of a char, capable of holding an unsigned 8-bit integer
 
-	using short_t = signed short;    ///< \brief A signed short type, capable of holding signed 16-bit integer
+	using char_t  = char;          //!< \brief A type capable of holding an ascii value.
-	using ushort_t = unsigned short; ///< \brief An unsigned short type, capable of holding an unsigned signed 16-bit integer
+	using schar_t = signed char;   //!< \brief A type with the size of a char, capable of holding a signed 8-bit integer.
+	using uchar_t = unsigned char; //!< \brief A type with the size of a char, capable of holding an unsigned 8-bit integer.
 
-	using int_t = signed int;    ///< \brief A signed integer type, size varies by implementation, but typically 32-bit
+	using short_t = signed short;    //!< \brief A signed short type, capable of holding signed 16-bit integer.
-	using uint_t = unsigned int; ///< \brief An unsigned integer type, size varies by implementation, but typically 32-bit
+	using ushort_t = unsigned short; //!< \brief An unsigned short type, capable of holding an unsigned signed 16-bit integer.
 
-	using long_t  = signed long;   ///< \brief A signed integer type, with a size of at least 32-bits
+	using int_t = signed int;    //!< \brief A signed integer type, size varies by implementation, but typically 32-bit.
-	using ulong_t = unsigned long; ///< \brief An unsigned integer type, with a size of at least 32-bits
+	using uint_t = unsigned int; //!< \brief An unsigned integer type, size varies by implementation, but typically 32-bit.
 
-	using llong_t  = signed long long;   ///< \brief A signed integer type, with a size of 64-bits
+	using long_t  = signed long;   //!< \brief A signed integer type, with a size of at least 32-bits.
-	using ullong_t = unsigned long long; ///< \brief An unsigned integer type, with a size of 64-bits
+	using ulong_t = unsigned long; //!< \brief An unsigned integer type, with a size of at least 32-bits.
 
-	using float_t = float;   ///< \brief A single-precision floating-point type, typically with a size of 32-bits
+	using llong_t  = signed long long;   //!< \brief A signed integer type, with a size of 64-bits.
-	using double_t = double; ///< \brief A double-precision floating-point type, typically with a size of 64-bits
+	using ullong_t = unsigned long long; //!< \brief An unsigned integer type, with a size of 64-bits.
+
+	using float_t = float;   //!< \brief A single-precision floating-point type, typically with a size of 32-bits.
+	using double_t = double; //!< \brief A double-precision floating-point type, typically with a size of 64-bits.
 
 	/// @}
 
@@ -242,18 +252,18 @@ namespace fennec
 	/// \name Special Types
 	/// @{
 
-	using nullptr_t = decltype(nullptr); ///< \brief Null Pointer Type
+	using  nullptr_t = decltype(nullptr); //!< \brief Null Pointer Type.
-	using intptr_t  = intptr_t;          ///< \brief Signed Integer Capable of Holding a Pointer to void
+	using  intptr_t  = intptr_t;          //!< \brief Signed Integer Capable of Holding a Pointer to void.
-	using uintptr_t = uintptr_t;         ///< \brief Unsigned Integer Capable of Holding a Pointer to void
+	using  uintptr_t = uintptr_t;         //!< \brief Unsigned Integer Capable of Holding a Pointer to void.
-	using intmax_t  = intmax_t;   ///< \brief Maximum Width Signed Integer Type
+	using  intmax_t  = intmax_t;          //!< \brief Maximum Width Signed Integer Type.
-	using uintmax_t = uintmax_t;  ///< \brief Maximum Width Unsigned Integer Type
+	using  uintmax_t = uintmax_t;         //!< \brief Maximum Width Unsigned Integer Type.
-	using size_t    = size_t;     ///< \brief Unsigned Integer Type Returned By `sizeof`, `sizeof...`, and `alignof`
+	using  size_t    = size_t;            //!< \brief Unsigned Integer Type Returned By `sizeof`, `sizeof...`, and `alignof`.
-	using ptrdiff_t = __PTRDIFF_TYPE__;  ///< \brief Signed Integer Type Returned by the Subtraction of two Pointers
+	using  ptrdiff_t = __PTRDIFF_TYPE__;  //!< \brief Signed Integer Type Returned by the Subtraction of two Pointers.
-	struct empty_t  {};
+	struct empty_t     {};                //!< \brief A struct resembling an empty type.
 
 
-	class undefined_t;                         ///< \brief undefined class for SFINAE
+	class undefined_t;                         //!< \brief Undefined class for SFINAE.
-	template<typename...> using void_t = void; ///< \brief Void type used for SFINAE
+	template<typename...> using void_t = void; //!< \brief Void type used for SFINAE.
 
 	/// @}
 
@@ -264,15 +274,15 @@ namespace fennec
 	/// \name Sized Integer Types
 	/// @{
 
-	using int8_t  = ::int8_t;  ///< \brief Signed 8-bit integer
+	using int8_t  = ::int8_t;  //!< \brief Signed 8-bit integer.
-	using int16_t = ::int16_t; ///< \brief Signed 16-bit integer
+	using int16_t = ::int16_t; //!< \brief Signed 16-bit integer.
-	using int32_t = ::int32_t; ///< \brief Signed 32-bit integer
+	using int32_t = ::int32_t; //!< \brief Signed 32-bit integer.
-	using int64_t = ::int64_t; ///< \brief Signed 64-bit integer
+	using int64_t = ::int64_t; //!< \brief Signed 64-bit integer.
 
-	using uint8_t  = ::uint8_t;  ///< \brief Unsigned 8-bit integer
+	using uint8_t  = ::uint8_t;  //!< \brief Unsigned 8-bit integer.
-	using uint16_t = ::uint16_t; ///< \brief Unsigned 16-bit integer
+	using uint16_t = ::uint16_t; //!< \brief Unsigned 16-bit integer.
-	using uint32_t = ::uint32_t; ///< \brief Unsigned 32-bit integer
+	using uint32_t = ::uint32_t; //!< \brief Unsigned 32-bit integer.
-	using uint64_t = ::uint64_t; ///< \brief Unsigned 64-bit integer
+	using uint64_t = ::uint64_t; //!< \brief Unsigned 64-bit integer.
 
 	/// @}
 
@@ -282,9 +292,9 @@ namespace fennec
 	/// \name Sized Floating-Point Types
 	/// @{
 
-	//using float16_t = _Float16; ///< \brief A half-precision floating-point scalar
+	//using float16_t = _Float16; //!< \brief A half-precision floating-point scalar
-	//using float32_t = _Float32; ///< \brief A single-precision floating-point scalar
+	//using float32_t = _Float32; //!< \brief A single-precision floating-point scalar
-	//using float64_t = _Float64; ///< \brief A double-precision floating-point scalar
+	//using float64_t = _Float64; //!< \brief A double-precision floating-point scalar
 
 	/// @}
 

include/fennec/lang/utility.h

@@ -1,6 +1,6 @@
 // =====================================================================================================================
 //  fennec, a free and open source game engine
-//  Copyright © 2025  Medusa Slockbower
+//  Copyright © 2025 - 2026  Medusa Slockbower
 //
 //  This program is free software: you can redistribute it and/or modify
 //  it under the terms of the GNU General Public License as published by
@@ -17,14 +17,14 @@
 // =====================================================================================================================
 
 ///
-/// \file utility.h
+/// \file fennec/lang/utility.h
 /// \brief \ref fennec_lang_utility
 ///
 ///
 /// \details
 /// \author Medusa Slockbower
 ///
-/// \copyright Copyright © 2025 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
+/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
 ///
 ///
 
@@ -76,10 +76,21 @@ template<typename T> constexpr T&& forward(remove_reference_t<T>& x) noexcept {
 	return static_cast<T&&>(x);
 }
 
+#ifndef FENNEC_DOXYGEN
 // specialization for T&&
 template<typename T> constexpr T&& forward(remove_reference_t<T>&& x) noexcept {
 	return static_cast<T&&>(x);
 }
+#endif
+
+
+/// \brief Copies \f$v\f$ to a new object of `decay_t<T>`
+/// \tparam T The type
+/// \param v The object
+/// \returns A stack allocated copy of \f$v\f$ in `decay_t<T>`
+template<typename T> constexpr decay_t<T> decay_copy(T&& v) {
+	return fennec::forward<T>(v);
+}
 
 
 ///
@@ -123,9 +134,18 @@ constexpr void swap(T& x, T& y) noexcept {
 /// \param x first value
 /// \param y second value
 template<typename T> constexpr void swap(T& x, T& y) noexcept {
+#if FENNEC_COMPILER_GCC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
+#endif
+
 	T a = fennec::move(x);
 	x = fennec::move(y);
 	y = fennec::move(a);
+
+#if FENNEC_COMPILER_GCC
+#pragma GCC diagnostic pop
+#endif
 }
 
 }