Shuffle stuff around

- Use the new and improved hierarchy I figured out when making Prospero chat
- Re-add NSIS scripts, again from Prospero
- Update most build and utility scripts with their most recent versions

41 files changed, 2211 insertions, 0 deletions

diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt
new file mode 100644
index 0000000..7a3edfc
--- /dev/null
+++ b/src/core/CMakeLists.txt
@@ -0,0 +1,28 @@
+execute_process(COMMAND git rev-parse --short=8 HEAD
+    WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}"
+    OUTPUT_VARIABLE GIT_COMMIT_HASH
+    OUTPUT_STRIP_TRAILING_WHITESPACE)
+configure_file("${CMAKE_CURRENT_LIST_DIR}/version.cc.in" "${CMAKE_CURRENT_LIST_DIR}/version.cc")
+
+add_library(core STATIC
+    "${CMAKE_CURRENT_LIST_DIR}/pch.hh"
+    "${CMAKE_CURRENT_LIST_DIR}/threading.cc"
+    "${CMAKE_CURRENT_LIST_DIR}/threading.hh"
+    "${CMAKE_CURRENT_LIST_DIR}/version.cc"
+    "${CMAKE_CURRENT_LIST_DIR}/version.hh")
+target_compile_features(core PUBLIC cxx_std_20)
+target_include_directories(core PUBLIC "${PROJECT_SOURCE_DIR}/src")
+target_precompile_headers(core PRIVATE "${CMAKE_CURRENT_LIST_DIR}/pch.hh")
+target_link_libraries(core PUBLIC enet emhash glm physfs spdlog stb thread_pool)
+
+add_subdirectory(config)
+add_subdirectory(io)
+add_subdirectory(math)
+add_subdirectory(resource)
+add_subdirectory(utils)
+
+if(WIN32)
+    target_compile_definitions(core PUBLIC _CRT_SECURE_NO_WARNINGS)
+    target_compile_definitions(core PUBLIC _USE_MATH_DEFINES)
+    target_compile_definitions(core PUBLIC NOMINMAX)
+endif()
diff --git a/src/core/config/CMakeLists.txt b/src/core/config/CMakeLists.txt
new file mode 100644
index 0000000..39752d4
--- /dev/null
+++ b/src/core/config/CMakeLists.txt
@@ -0,0 +1,7 @@
+target_sources(core PRIVATE
+    "${CMAKE_CURRENT_LIST_DIR}/boolean.cc"
+    "${CMAKE_CURRENT_LIST_DIR}/boolean.hh"
+    "${CMAKE_CURRENT_LIST_DIR}/ivalue.hh"
+    "${CMAKE_CURRENT_LIST_DIR}/number.hh"
+    "${CMAKE_CURRENT_LIST_DIR}/string.cc"
+    "${CMAKE_CURRENT_LIST_DIR}/string.hh")
diff --git a/src/core/config/boolean.cc b/src/core/config/boolean.cc
new file mode 100644
index 0000000..45d5a38
--- /dev/null
+++ b/src/core/config/boolean.cc
@@ -0,0 +1,43 @@
+#include "core/pch.hh"
+
+#include "core/config/boolean.hh"
+
+config::Boolean::Boolean(bool default_value)
+{
+    m_value = default_value;
+}
+
+void config::Boolean::set(std::string_view value)
+{
+    m_value = from_string(value);
+}
+
+std::string_view config::Boolean::get(void) const
+{
+    return to_string(m_value);
+}
+
+bool config::Boolean::get_value(void) const
+{
+    return m_value;
+}
+
+void config::Boolean::set_value(bool value)
+{
+    m_value = value;
+}
+
+std::string_view config::Boolean::to_string(bool value)
+{
+    if(value) {
+        return "true";
+    }
+    else {
+        return "false";
+    }
+}
+
+bool config::Boolean::from_string(std::string_view value)
+{
+    return value == "true" && value != "false";
+}
diff --git a/src/core/config/boolean.hh b/src/core/config/boolean.hh
new file mode 100644
index 0000000..cfd8b0b
--- /dev/null
+++ b/src/core/config/boolean.hh
@@ -0,0 +1,25 @@
+#pragma once
+
+#include "core/config/ivalue.hh"
+
+namespace config
+{
+class Boolean : public IValue {
+public:
+    explicit Boolean(bool default_value = false);
+    virtual ~Boolean(void) = default;
+
+    virtual void set(std::string_view value) override;
+    virtual std::string_view get(void) const override;
+
+    bool get_value(void) const;
+    void set_value(bool value);
+
+private:
+    bool m_value;
+
+public:
+    static std::string_view to_string(bool value);
+    static bool from_string(std::string_view value);
+};
+} // namespace config
diff --git a/src/core/config/ivalue.hh b/src/core/config/ivalue.hh
new file mode 100644
index 0000000..13e9a3a
--- /dev/null
+++ b/src/core/config/ivalue.hh
@@ -0,0 +1,11 @@
+#pragma once
+
+namespace config
+{
+class IValue {
+public:
+    virtual ~IValue(void) = default;
+    virtual void set(std::string_view value) = 0;
+    virtual std::string_view get(void) const = 0;
+};
+} // namespace config
diff --git a/src/core/config/number.hh b/src/core/config/number.hh
new file mode 100644
index 0000000..4f185e1
--- /dev/null
+++ b/src/core/config/number.hh
@@ -0,0 +1,130 @@
+#pragma once
+
+#include "core/config/ivalue.hh"
+
+#include "core/math/concepts.hh"
+
+namespace config
+{
+template<math::arithmetic T>
+class Number : public IValue {
+public:
+    explicit Number(T default_value = T(0));
+    explicit Number(T default_value, T min_value, T max_value);
+    virtual ~Number(void) = default;
+
+    virtual void set(std::string_view value) override;
+    virtual std::string_view get(void) const override;
+
+    T get_value(void) const;
+    void set_value(T value);
+
+    T get_min_value(void) const;
+    T get_max_value(void) const;
+    void set_limits(T min_value, T max_value);
+
+private:
+    T m_value;
+    T m_min_value;
+    T m_max_value;
+    std::string m_string;
+};
+} // namespace config
+
+namespace config
+{
+class Int final : public Number<int> {
+public:
+    using Number<int>::Number;
+};
+
+class Float final : public Number<float> {
+public:
+    using Number<float>::Number;
+};
+
+class Unsigned final : public Number<unsigned int> {
+public:
+    using Number<unsigned int>::Number;
+};
+
+class Unsigned64 final : public Number<std::uint64_t> {
+public:
+    using Number<std::uint64_t>::Number;
+};
+
+class SizeType final : public Number<std::size_t> {
+public:
+    using Number<std::size_t>::Number;
+};
+} // namespace config
+
+template<math::arithmetic T>
+inline config::Number<T>::Number(T default_value)
+{
+    m_value = default_value;
+    m_min_value = std::numeric_limits<T>::lowest();
+    m_max_value = std::numeric_limits<T>::max();
+    m_string = std::to_string(default_value);
+}
+
+template<math::arithmetic T>
+inline config::Number<T>::Number(T default_value, T min_value, T max_value)
+{
+    m_value = default_value;
+    m_min_value = min_value;
+    m_max_value = max_value;
+    m_string = std::to_string(default_value);
+}
+
+template<math::arithmetic T>
+inline void config::Number<T>::set(std::string_view value)
+{
+    T parsed_value;
+    auto result = std::from_chars(value.data(), value.data() + value.size(), parsed_value);
+
+    if(result.ec == std::errc()) {
+        m_value = std::clamp(parsed_value, m_min_value, m_max_value);
+        m_string = std::to_string(m_value);
+    }
+}
+
+template<math::arithmetic T>
+inline std::string_view config::Number<T>::get(void) const
+{
+    return m_string;
+}
+
+template<math::arithmetic T>
+inline T config::Number<T>::get_value(void) const
+{
+    return m_value;
+}
+
+template<math::arithmetic T>
+inline void config::Number<T>::set_value(T value)
+{
+    m_value = std::clamp(value, m_min_value, m_max_value);
+    m_string = std::to_string(m_value);
+}
+
+template<math::arithmetic T>
+inline T config::Number<T>::get_min_value(void) const
+{
+    return m_min_value;
+}
+
+template<math::arithmetic T>
+inline T config::Number<T>::get_max_value(void) const
+{
+    return m_max_value;
+}
+
+template<math::arithmetic T>
+inline void config::Number<T>::set_limits(T min_value, T max_value)
+{
+    m_min_value = min_value;
+    m_max_value = max_value;
+    m_value = std::clamp(m_value, m_min_value, m_max_value);
+    m_string = std::to_string(m_value);
+}
diff --git a/src/core/config/string.cc b/src/core/config/string.cc
new file mode 100644
index 0000000..198b448
--- /dev/null
+++ b/src/core/config/string.cc
@@ -0,0 +1,18 @@
+#include "core/pch.hh"
+
+#include "core/config/string.hh"
+
+config::String::String(std::string_view default_value)
+{
+    m_value = default_value;
+}
+
+void config::String::set(std::string_view value)
+{
+    m_value = value;
+}
+
+std::string_view config::String::get(void) const
+{
+    return m_value;
+}
diff --git a/src/core/config/string.hh b/src/core/config/string.hh
new file mode 100644
index 0000000..8fd3901
--- /dev/null
+++ b/src/core/config/string.hh
@@ -0,0 +1,31 @@
+#pragma once
+
+#include "core/config/ivalue.hh"
+
+namespace config
+{
+class String : public IValue {
+public:
+    explicit String(std::string_view default_value);
+    virtual ~String(void) = default;
+
+    virtual void set(std::string_view value) override;
+    virtual std::string_view get(void) const override;
+
+    constexpr const std::string& get_value(void) const noexcept;
+    constexpr const char* c_str(void) const noexcept;
+
+private:
+    std::string m_value;
+};
+} // namespace config
+
+constexpr const std::string& config::String::get_value(void) const noexcept
+{
+    return m_value;
+}
+
+constexpr const char* config::String::c_str(void) const noexcept
+{
+    return m_value.c_str();
+}
diff --git a/src/core/io/CMakeLists.txt b/src/core/io/CMakeLists.txt
new file mode 100644
index 0000000..3fe9fb1
--- /dev/null
+++ b/src/core/io/CMakeLists.txt
@@ -0,0 +1,9 @@
+target_sources(core PRIVATE
+    "${CMAKE_CURRENT_LIST_DIR}/buffer.cc"
+    "${CMAKE_CURRENT_LIST_DIR}/buffer.hh"
+    "${CMAKE_CURRENT_LIST_DIR}/cmdline.cc"
+    "${CMAKE_CURRENT_LIST_DIR}/cmdline.hh"
+    "${CMAKE_CURRENT_LIST_DIR}/config_map.cc"
+    "${CMAKE_CURRENT_LIST_DIR}/config_map.hh"
+    "${CMAKE_CURRENT_LIST_DIR}/physfs.cc"
+    "${CMAKE_CURRENT_LIST_DIR}/physfs.hh")
diff --git a/src/core/io/buffer.cc b/src/core/io/buffer.cc
new file mode 100644
index 0000000..0f781a0
--- /dev/null
+++ b/src/core/io/buffer.cc
@@ -0,0 +1,345 @@
+#include "core/pch.hh"
+
+#include "core/io/buffer.hh"
+
+#include "core/math/constexpr.hh"
+
+io::ReadBuffer::ReadBuffer(const ReadBuffer& other)
+{
+    reset(other.data(), other.size());
+}
+
+io::ReadBuffer::ReadBuffer(const void* data, std::size_t size)
+{
+    assert(data);
+
+    reset(data, size);
+}
+
+io::ReadBuffer::ReadBuffer(const ENetPacket* packet)
+{
+    assert(packet);
+
+    reset(packet);
+}
+
+io::ReadBuffer::ReadBuffer(PHYSFS_File* file)
+{
+    assert(file);
+
+    reset(file);
+}
+
+std::size_t io::ReadBuffer::size(void) const
+{
+    return m_vector.size();
+}
+
+const std::byte* io::ReadBuffer::data(void) const
+{
+    return m_vector.data();
+}
+
+void io::ReadBuffer::reset(const void* data, std::size_t size)
+{
+    assert(data);
+
+    auto bytes = reinterpret_cast<const std::byte*>(data);
+    m_vector.assign(bytes, bytes + size);
+    m_position = 0U;
+}
+
+void io::ReadBuffer::reset(const ENetPacket* packet)
+{
+    assert(packet);
+
+    auto bytes_ptr = reinterpret_cast<const std::byte*>(packet->data);
+    m_vector.assign(bytes_ptr, bytes_ptr + packet->dataLength);
+    m_position = 0;
+}
+
+void io::ReadBuffer::reset(PHYSFS_File* file)
+{
+    assert(file);
+
+    m_vector.resize(PHYSFS_fileLength(file));
+    m_position = 0;
+
+    PHYSFS_seek(file, 0);
+    PHYSFS_readBytes(file, m_vector.data(), m_vector.size());
+}
+
+template<>
+std::byte io::ReadBuffer::read<std::byte>(void)
+{
+    if(m_position < m_vector.size()) {
+        auto result = m_vector[m_position];
+        m_position += 1U;
+        return result;
+    }
+
+    m_position += 1U;
+    return static_cast<std::byte>(0x00);
+}
+
+template<>
+std::uint8_t io::ReadBuffer::read<std::uint8_t>(void)
+{
+    if((m_position + 1U) <= m_vector.size()) {
+        auto result = static_cast<std::uint8_t>(m_vector[m_position]);
+        m_position += 1U;
+        return result;
+    }
+
+    m_position += 1U;
+    return 0;
+}
+
+template<>
+std::uint16_t io::ReadBuffer::read<std::uint16_t>(void)
+{
+    if((m_position + 2U) <= m_vector.size()) {
+        auto result = UINT16_C(0x0000);
+        result |= (UINT16_C(0x00FF) & static_cast<std::uint16_t>(m_vector[m_position + 0U])) << 8U;
+        result |= (UINT16_C(0x00FF) & static_cast<std::uint16_t>(m_vector[m_position + 1U])) << 0U;
+        m_position += 2U;
+        return result;
+    }
+
+    m_position += 2U;
+    return 0;
+}
+
+template<>
+std::uint32_t io::ReadBuffer::read<std::uint32_t>(void)
+{
+    if((m_position + 4U) <= m_vector.size()) {
+        auto result = UINT32_C(0x00000000);
+        result |= (UINT32_C(0x000000FF) & static_cast<std::uint32_t>(m_vector[m_position + 0U])) << 24U;
+        result |= (UINT32_C(0x000000FF) & static_cast<std::uint32_t>(m_vector[m_position + 1U])) << 16U;
+        result |= (UINT32_C(0x000000FF) & static_cast<std::uint32_t>(m_vector[m_position + 2U])) << 8U;
+        result |= (UINT32_C(0x000000FF) & static_cast<std::uint32_t>(m_vector[m_position + 3U])) << 0U;
+        m_position += 4U;
+        return result;
+    }
+
+    m_position += 4U;
+    return 0;
+}
+
+template<>
+std::uint64_t io::ReadBuffer::read<std::uint64_t>(void)
+{
+    if((m_position + 8U) <= m_vector.size()) {
+        auto result = UINT64_C(0x0000000000000000);
+        result |= (UINT64_C(0x00000000000000FF) & static_cast<std::uint64_t>(m_vector[m_position + 0U])) << 56U;
+        result |= (UINT64_C(0x00000000000000FF) & static_cast<std::uint64_t>(m_vector[m_position + 1U])) << 48U;
+        result |= (UINT64_C(0x00000000000000FF) & static_cast<std::uint64_t>(m_vector[m_position + 2U])) << 40U;
+        result |= (UINT64_C(0x00000000000000FF) & static_cast<std::uint64_t>(m_vector[m_position + 3U])) << 32U;
+        result |= (UINT64_C(0x00000000000000FF) & static_cast<std::uint64_t>(m_vector[m_position + 4U])) << 24U;
+        result |= (UINT64_C(0x00000000000000FF) & static_cast<std::uint64_t>(m_vector[m_position + 5U])) << 16U;
+        result |= (UINT64_C(0x00000000000000FF) & static_cast<std::uint64_t>(m_vector[m_position + 6U])) << 8U;
+        result |= (UINT64_C(0x00000000000000FF) & static_cast<std::uint64_t>(m_vector[m_position + 7U])) << 0U;
+        m_position += 8U;
+        return result;
+    }
+
+    m_position += 8U;
+    return 0;
+}
+
+template<>
+float io::ReadBuffer::read<float>(void)
+{
+    return std::bit_cast<float>(read<std::uint32_t>());
+}
+
+template<>
+std::int8_t io::ReadBuffer::read<std::int8_t>(void)
+{
+    return std::bit_cast<std::int8_t>(read<std::uint8_t>());
+}
+
+template<>
+std::int16_t io::ReadBuffer::read<std::int16_t>(void)
+{
+    return std::bit_cast<std::int16_t>(read<std::uint16_t>());
+}
+
+template<>
+std::int32_t io::ReadBuffer::read<std::int32_t>(void)
+{
+    return std::bit_cast<std::int32_t>(read<std::uint32_t>());
+}
+
+template<>
+std::int64_t io::ReadBuffer::read<std::int64_t>(void)
+{
+    return std::bit_cast<std::int64_t>(read<std::uint64_t>());
+}
+
+template<>
+std::string io::ReadBuffer::read<std::string>(void)
+{
+    std::string result;
+    result.resize(read<std::uint16_t>());
+
+    for(std::size_t i = 0; i < result.size(); ++i) {
+        if(m_position < m_vector.size()) {
+            result[i] = static_cast<char>(m_vector[m_position]);
+        }
+
+        m_position += 1U;
+    }
+
+    return result;
+}
+
+void io::ReadBuffer::read(void* buffer, std::size_t size)
+{
+    auto bytes = reinterpret_cast<std::byte*>(buffer);
+    auto amount_to_read = std::min(size, m_vector.size() - m_position);
+
+    if(amount_to_read > 0) {
+        std::copy(m_vector.cbegin() + m_position, m_vector.cbegin() + m_position + amount_to_read, bytes);
+    }
+
+    m_position += size;
+}
+
+io::WriteBuffer::WriteBuffer(const WriteBuffer& other)
+{
+    m_vector = other.m_vector;
+}
+
+std::size_t io::WriteBuffer::size(void) const
+{
+    return m_vector.size();
+}
+
+const std::byte* io::WriteBuffer::data(void) const
+{
+    return m_vector.data();
+}
+
+void io::WriteBuffer::reset(void)
+{
+    m_vector.clear();
+}
+
+void io::WriteBuffer::write(const WriteBuffer& other)
+{
+    m_vector.insert(m_vector.end(), other.m_vector.begin(), other.m_vector.end());
+}
+
+void io::WriteBuffer::write(const void* data, std::size_t size)
+{
+    assert(data);
+
+    auto bytes = reinterpret_cast<const std::byte*>(data);
+    m_vector.insert(m_vector.end(), bytes, bytes + size);
+}
+
+template<>
+void io::WriteBuffer::write<std::byte>(const std::byte value)
+{
+    m_vector.push_back(value);
+}
+
+template<>
+void io::WriteBuffer::write<std::uint8_t>(const std::uint8_t value)
+{
+    m_vector.push_back(static_cast<std::byte>(value));
+}
+
+template<>
+void io::WriteBuffer::write<std::uint16_t>(const std::uint16_t value)
+{
+    m_vector.push_back(static_cast<std::byte>(UINT16_C(0xFF) & ((value & UINT16_C(0xFF00)) >> 8U)));
+    m_vector.push_back(static_cast<std::byte>(UINT16_C(0xFF) & ((value & UINT16_C(0x00FF)) >> 0U)));
+}
+
+template<>
+void io::WriteBuffer::write<std::uint32_t>(const std::uint32_t value)
+{
+    m_vector.push_back(static_cast<std::byte>(UINT32_C(0xFF) & ((value & UINT32_C(0xFF000000)) >> 24U)));
+    m_vector.push_back(static_cast<std::byte>(UINT32_C(0xFF) & ((value & UINT32_C(0x00FF0000)) >> 16U)));
+    m_vector.push_back(static_cast<std::byte>(UINT32_C(0xFF) & ((value & UINT32_C(0x0000FF00)) >> 8U)));
+    m_vector.push_back(static_cast<std::byte>(UINT32_C(0xFF) & ((value & UINT32_C(0x000000FF)) >> 0U)));
+}
+
+template<>
+void io::WriteBuffer::write<std::uint64_t>(const std::uint64_t value)
+{
+    m_vector.push_back(static_cast<std::byte>(UINT64_C(0xFF) & ((value & UINT64_C(0xFF00000000000000)) >> 56U)));
+    m_vector.push_back(static_cast<std::byte>(UINT64_C(0xFF) & ((value & UINT64_C(0x00FF000000000000)) >> 48U)));
+    m_vector.push_back(static_cast<std::byte>(UINT64_C(0xFF) & ((value & UINT64_C(0x0000FF0000000000)) >> 40U)));
+    m_vector.push_back(static_cast<std::byte>(UINT64_C(0xFF) & ((value & UINT64_C(0x000000FF00000000)) >> 32U)));
+    m_vector.push_back(static_cast<std::byte>(UINT64_C(0xFF) & ((value & UINT64_C(0x00000000FF000000)) >> 24U)));
+    m_vector.push_back(static_cast<std::byte>(UINT64_C(0xFF) & ((value & UINT64_C(0x0000000000FF0000)) >> 16U)));
+    m_vector.push_back(static_cast<std::byte>(UINT64_C(0xFF) & ((value & UINT64_C(0x000000000000FF00)) >> 8U)));
+    m_vector.push_back(static_cast<std::byte>(UINT64_C(0xFF) & ((value & UINT64_C(0x00000000000000FF)) >> 0U)));
+}
+
+template<>
+void io::WriteBuffer::write(const float value)
+{
+    write(std::bit_cast<std::uint32_t>(value));
+}
+
+template<>
+void io::WriteBuffer::write(const std::int8_t value)
+{
+    write(std::bit_cast<std::uint8_t>(value));
+}
+
+template<>
+void io::WriteBuffer::write(const std::int16_t value)
+{
+    write(std::bit_cast<std::uint16_t>(value));
+}
+
+template<>
+void io::WriteBuffer::write(const std::int32_t value)
+{
+    write(std::bit_cast<std::uint32_t>(value));
+}
+
+template<>
+void io::WriteBuffer::write(const std::int64_t value)
+{
+    write(std::bit_cast<std::uint64_t>(value));
+}
+
+template<>
+void io::WriteBuffer::write<std::string_view>(const std::string_view value)
+{
+    write<std::uint16_t>(static_cast<std::uint16_t>(value.size()));
+
+    for(const auto& character : value) {
+        m_vector.push_back(static_cast<std::byte>(character));
+    }
+}
+
+PHYSFS_File* io::WriteBuffer::to_file(const std::string& path, bool append) const
+{
+    PHYSFS_File* file = nullptr;
+
+    if(append) {
+        file = PHYSFS_openAppend(path.c_str());
+    }
+    else {
+        file = PHYSFS_openWrite(path.c_str());
+    }
+
+    if(file) {
+        PHYSFS_writeBytes(file, m_vector.data(), m_vector.size());
+    }
+
+    return file;
+}
+
+ENetPacket* io::WriteBuffer::to_packet(enet_uint32 flags) const
+{
+    return enet_packet_create(m_vector.data(), m_vector.size(), flags);
+}
diff --git a/src/core/io/buffer.hh b/src/core/io/buffer.hh
new file mode 100644
index 0000000..96a37b1
--- /dev/null
+++ b/src/core/io/buffer.hh
@@ -0,0 +1,88 @@
+namespace io
+{
+class ReadBuffer final {
+public:
+    ReadBuffer(void) = default;
+    explicit ReadBuffer(const ReadBuffer& other);
+    explicit ReadBuffer(const void* data, std::size_t size);
+    explicit ReadBuffer(const ENetPacket* packet);
+    explicit ReadBuffer(PHYSFS_File* file);
+    virtual ~ReadBuffer(void) = default;
+
+    std::size_t size(void) const;
+    const std::byte* data(void) const;
+
+    void reset(const void* data, std::size_t size);
+    void reset(const ENetPacket* packet);
+    void reset(PHYSFS_File* file);
+
+    constexpr void rewind(void);
+    constexpr bool is_ended(void) const;
+
+    void read(void* buffer, std::size_t size);
+
+    template<typename T>
+    T read(void);
+
+    template<typename T>
+    ReadBuffer& operator>>(T& value);
+
+private:
+    std::vector<std::byte> m_vector;
+    std::size_t m_position;
+};
+} // namespace io
+
+namespace io
+{
+class WriteBuffer final {
+public:
+    WriteBuffer(void) = default;
+    explicit WriteBuffer(const WriteBuffer& other);
+    virtual ~WriteBuffer(void) = default;
+
+    std::size_t size(void) const;
+    const std::byte* data(void) const;
+
+    void reset(void);
+
+    void write(const WriteBuffer& other);
+    void write(const void* data, std::size_t size);
+
+    template<typename T>
+    void write(const T value);
+
+    template<typename T>
+    WriteBuffer& operator<<(const T value);
+
+    PHYSFS_File* to_file(const std::string& path, bool append = false) const;
+    ENetPacket* to_packet(enet_uint32 flags = ENET_PACKET_FLAG_RELIABLE) const;
+
+private:
+    std::vector<std::byte> m_vector;
+};
+} // namespace io
+
+constexpr void io::ReadBuffer::rewind(void)
+{
+    m_position = 0;
+}
+
+constexpr bool io::ReadBuffer::is_ended(void) const
+{
+    return m_position >= m_vector.size();
+}
+
+template<typename T>
+io::ReadBuffer& io::ReadBuffer::operator>>(T& value)
+{
+    value = read<T>();
+    return *this;
+}
+
+template<typename T>
+io::WriteBuffer& io::WriteBuffer::operator<<(const T value)
+{
+    write<T>(value);
+    return *this;
+}
diff --git a/src/core/io/cmdline.cc b/src/core/io/cmdline.cc
new file mode 100644
index 0000000..7a00f37
--- /dev/null
+++ b/src/core/io/cmdline.cc
@@ -0,0 +1,95 @@
+#include "core/pch.hh"
+
+#include "core/io/cmdline.hh"
+
+// Valid options always start with OPTION_PREFIX, can contain
+// a bunch of OPTION_PREFIX'es inside and never end with one
+constexpr static char OPTION_PREFIX = '-';
+
+static std::unordered_map<std::string, std::string> options;
+
+static inline bool is_option_string(const std::string& string)
+{
+    if(string.find_last_of(OPTION_PREFIX) >= (string.size() - 1)) {
+        return false;
+    }
+
+    return string[0] == OPTION_PREFIX;
+}
+
+static inline std::string get_option(const std::string& string)
+{
+    std::size_t i;
+    for(i = 0; string[i] == OPTION_PREFIX; ++i) {
+        // empty
+    }
+
+    return std::string(string.cbegin() + i, string.cend());
+}
+
+void io::cmdline::create(int argc, char** argv)
+{
+    for(int idx = 1; idx < argc; ++idx) {
+        std::string string = argv[idx];
+
+        if(!is_option_string(string)) {
+            spdlog::warn("cmdline: non-argument at {}: {}", idx, string);
+            continue;
+        }
+
+        auto option_string = get_option(string);
+        auto next_idx = idx + 1;
+
+        if(next_idx < argc) {
+            std::string argument = argv[next_idx];
+
+            if(!is_option_string(argument)) {
+                options.insert_or_assign(option_string, argument);
+                idx = next_idx;
+                continue;
+            }
+        }
+
+        // The option is either last or has no
+        // argument (happens when there is a valid
+        // option right next to the one we're parsing)
+        options.insert_or_assign(option_string, std::string());
+    }
+}
+
+void io::cmdline::insert(std::string_view option)
+{
+    options.insert_or_assign(std::string(option), std::string());
+}
+
+void io::cmdline::insert(std::string_view option, std::string_view argument)
+{
+    options.insert_or_assign(std::string(option), std::string(argument));
+}
+
+std::string_view io::cmdline::get(std::string_view option, std::string_view fallback)
+{
+    auto it = options.find(std::string(option));
+
+    if(it == options.cend()) {
+        return fallback;
+    }
+
+    return it->second;
+}
+
+const char* io::cmdline::get_cstr(std::string_view option, const char* fallback)
+{
+    auto it = options.find(std::string(option));
+
+    if(it == options.cend()) {
+        return fallback;
+    }
+
+    return it->second.c_str();
+}
+
+bool io::cmdline::contains(std::string_view option)
+{
+    return options.count(std::string(option));
+}
diff --git a/src/core/io/cmdline.hh b/src/core/io/cmdline.hh
new file mode 100644
index 0000000..e90433c
--- /dev/null
+++ b/src/core/io/cmdline.hh
@@ -0,0 +1,11 @@
+#pragma once
+
+namespace io::cmdline
+{
+void create(int argc, char** argv);
+void insert(std::string_view option);
+void insert(std::string_view option, std::string_view argument);
+std::string_view get(std::string_view option, std::string_view fallback = "");
+const char* get_cstr(std::string_view option, const char* fallback = nullptr);
+bool contains(std::string_view option);
+} // namespace io::cmdline
diff --git a/src/core/io/config_map.cc b/src/core/io/config_map.cc
new file mode 100644
index 0000000..57692a7
--- /dev/null
+++ b/src/core/io/config_map.cc
@@ -0,0 +1,136 @@
+#include "core/pch.hh"
+
+#include "core/io/config_map.hh"
+
+#include "core/config/ivalue.hh"
+
+#include "core/io/cmdline.hh"
+
+#include "core/utils/string.hh"
+
+#include "core/version.hh"
+
+void io::ConfigMap::load_cmdline(void)
+{
+    for(auto it : m_values) {
+        if(auto value = io::cmdline::get_cstr(it.first.c_str())) {
+            it.second->set(value);
+        }
+    }
+}
+
+bool io::ConfigMap::load_file(std::string_view path)
+{
+    if(auto file = PHYSFS_openRead(std::string(path).c_str())) {
+        auto source = std::string(PHYSFS_fileLength(file), char(0x00));
+        PHYSFS_readBytes(file, source.data(), source.size());
+        PHYSFS_close(file);
+
+        std::string line;
+        std::string kv_string;
+        std::istringstream stream(source);
+
+        while(std::getline(stream, line)) {
+            auto comment = line.find_first_of('#');
+
+            if(comment == std::string::npos) {
+                kv_string = utils::trim_whitespace(line);
+            }
+            else {
+                kv_string = utils::trim_whitespace(line.substr(0, comment));
+            }
+
+            if(utils::is_whitespace(kv_string)) {
+                // Ignore empty or commented out lines
+                continue;
+            }
+
+            auto separator = kv_string.find('=');
+
+            if(separator == std::string::npos) {
+                spdlog::warn("config: {}: invalid line: {}", path, line);
+                continue;
+            }
+
+            auto kv_name = utils::trim_whitespace(kv_string.substr(0, separator));
+            auto kv_value = utils::trim_whitespace(kv_string.substr(separator + 1));
+
+            auto kv_pair = m_values.find(kv_name);
+
+            if(kv_pair == m_values.cend()) {
+                spdlog::warn("config: {}: unknown key: {}", path, kv_name);
+                continue;
+            }
+
+            kv_pair->second->set(kv_value.c_str());
+        }
+
+        return true;
+    }
+
+    return false;
+}
+
+bool io::ConfigMap::save_file(std::string_view path) const
+{
+    std::ostringstream stream;
+
+    auto curtime = std::time(nullptr);
+
+    stream << "# Voxelius " << version::triplet << " configuration file" << std::endl;
+    stream << "# Generated at: " << std::put_time(std::gmtime(&curtime), "%Y-%m-%d %H:%M:%S %z") << std::endl << std::endl;
+
+    for(const auto& it : m_values) {
+        stream << it.first << "=";
+        stream << it.second->get();
+        stream << std::endl;
+    }
+
+    if(auto file = PHYSFS_openWrite(std::string(path).c_str())) {
+        auto source = stream.str();
+        PHYSFS_writeBytes(file, source.data(), source.size());
+        PHYSFS_close(file);
+        return true;
+    }
+
+    return false;
+}
+
+bool io::ConfigMap::set_value(std::string_view name, std::string_view value)
+{
+    auto kv_pair = m_values.find(std::string(name));
+
+    if(kv_pair != m_values.cend()) {
+        kv_pair->second->set(value);
+        return true;
+    }
+
+    return false;
+}
+
+std::string_view io::ConfigMap::get_value(std::string_view name) const
+{
+    auto kv_pair = m_values.find(std::string(name));
+    if(kv_pair != m_values.cend()) {
+        return kv_pair->second->get();
+    }
+
+    return std::string_view();
+}
+
+void io::ConfigMap::add_value(std::string_view name, config::IValue& vref)
+{
+    m_values.insert_or_assign(std::string(name), &vref);
+}
+
+const config::IValue* io::ConfigMap::find(std::string_view name) const
+{
+    auto kv_pair = m_values.find(std::string(name));
+
+    if(kv_pair != m_values.cend()) {
+        return kv_pair->second;
+    }
+    else {
+        return nullptr;
+    }
+}
diff --git a/src/core/io/config_map.hh b/src/core/io/config_map.hh
new file mode 100644
index 0000000..b0cd579
--- /dev/null
+++ b/src/core/io/config_map.hh
@@ -0,0 +1,29 @@
+#pragma once
+
+namespace config
+{
+class IValue;
+} // namespace config
+
+namespace io
+{
+class ConfigMap final {
+public:
+    ConfigMap(void) = default;
+    virtual ~ConfigMap(void) = default;
+
+    void load_cmdline(void);
+    bool load_file(std::string_view path);
+    bool save_file(std::string_view path) const;
+
+    bool set_value(std::string_view name, std::string_view value);
+    std::string_view get_value(std::string_view name) const;
+
+    void add_value(std::string_view name, config::IValue& vref);
+
+    const config::IValue* find(std::string_view name) const;
+
+private:
+    std::unordered_map<std::string, config::IValue*> m_values;
+};
+} // namespace io
diff --git a/src/core/io/physfs.cc b/src/core/io/physfs.cc
new file mode 100644
index 0000000..1c36f88
--- /dev/null
+++ b/src/core/io/physfs.cc
@@ -0,0 +1,76 @@
+#include "core/pch.hh"
+
+#include "core/io/physfs.hh"
+
+bool io::read_file(std::string_view path, std::vector<std::byte>& buffer)
+{
+    auto file = PHYSFS_openRead(std::string(path).c_str());
+
+    if(file == nullptr) {
+        spdlog::error("physfs: {}: {}", path, physfs_error());
+        return false;
+    }
+
+    PHYSFS_sint64 file_size = PHYSFS_fileLength(file);
+    buffer.resize(static_cast<std::size_t>(file_size));
+
+    PHYSFS_readBytes(file, buffer.data(), file_size);
+    PHYSFS_close(file);
+
+    return true;
+}
+
+bool io::read_file(std::string_view path, std::string& buffer)
+{
+    auto file = PHYSFS_openRead(std::string(path).c_str());
+
+    if(file == nullptr) {
+        spdlog::error("physfs: {}: {}", path, physfs_error());
+        return false;
+    }
+
+    PHYSFS_sint64 file_size = PHYSFS_fileLength(file);
+    buffer.resize(static_cast<std::size_t>(file_size));
+
+    PHYSFS_readBytes(file, buffer.data(), file_size);
+    PHYSFS_close(file);
+
+    return true;
+}
+
+bool io::write_file(std::string_view path, const std::vector<std::byte>& buffer)
+{
+    auto file = PHYSFS_openWrite(std::string(path).c_str());
+
+    if(file == nullptr) {
+        spdlog::error("physfs: {}: {}", path, physfs_error());
+        return false;
+    }
+
+    PHYSFS_writeBytes(file, buffer.data(), static_cast<PHYSFS_uint64>(buffer.size()));
+    PHYSFS_close(file);
+
+    return true;
+}
+
+bool io::write_file(std::string_view path, const std::string& buffer)
+{
+    auto file = PHYSFS_openWrite(std::string(path).c_str());
+
+    if(file == nullptr) {
+        spdlog::error("physfs: {}: {}", path, physfs_error());
+        return false;
+    }
+
+    PHYSFS_writeBytes(file, buffer.data(), static_cast<PHYSFS_uint64>(buffer.size()));
+    PHYSFS_close(file);
+
+    return true;
+}
+
+std::string_view io::physfs_error(void)
+{
+    auto error_code = PHYSFS_getLastErrorCode();
+    auto error_string = PHYSFS_getErrorByCode(error_code);
+    return std::string_view(error_string, std::strlen(error_string));
+}
diff --git a/src/core/io/physfs.hh b/src/core/io/physfs.hh
new file mode 100644
index 0000000..01282ad
--- /dev/null
+++ b/src/core/io/physfs.hh
@@ -0,0 +1,14 @@
+#pragma once
+
+namespace io
+{
+bool read_file(std::string_view path, std::vector<std::byte>& buffer);
+bool read_file(std::string_view path, std::string& buffer);
+bool write_file(std::string_view path, const std::vector<std::byte>& buffer);
+bool write_file(std::string_view path, const std::string& buffer);
+} // namespace io
+
+namespace io
+{
+std::string_view physfs_error(void);
+} // namespace io
diff --git a/src/core/math/CMakeLists.txt b/src/core/math/CMakeLists.txt
new file mode 100644
index 0000000..bcb45aa
--- /dev/null
+++ b/src/core/math/CMakeLists.txt
@@ -0,0 +1,8 @@
+target_sources(core PRIVATE
+    "${CMAKE_CURRENT_LIST_DIR}/aabb.hh"
+    "${CMAKE_CURRENT_LIST_DIR}/angles.hh"
+    "${CMAKE_CURRENT_LIST_DIR}/concepts.hh"
+    "${CMAKE_CURRENT_LIST_DIR}/constexpr.hh"
+    "${CMAKE_CURRENT_LIST_DIR}/crc64.cc"
+    "${CMAKE_CURRENT_LIST_DIR}/crc64.hh"
+    "${CMAKE_CURRENT_LIST_DIR}/vectors.hh")
diff --git a/src/core/math/aabb.hh b/src/core/math/aabb.hh
new file mode 100644
index 0000000..a235a9b
--- /dev/null
+++ b/src/core/math/aabb.hh
@@ -0,0 +1,111 @@
+#pragma once
+
+#include "core/math/concepts.hh"
+
+namespace math
+{
+template<arithmetic T>
+class AABB {
+public:
+    using value_type = T;
+    using vector_type = glm::vec<3, T>;
+
+    constexpr AABB(void) = default;
+    constexpr explicit AABB(const vector_type& start, const vector_type& end);
+    virtual ~AABB(void) = default;
+
+    constexpr void set_bounds(const vector_type& start, const vector_type& end);
+    constexpr void set_offset(const vector_type& base, const vector_type& size);
+
+    constexpr bool contains(const vector_type& point) const;
+    constexpr bool intersect(const AABB<value_type>& other_box) const;
+
+    constexpr AABB<value_type> combine(const AABB<value_type>& other_box) const;
+    constexpr AABB<value_type> multiply(const AABB<value_type>& other_box) const;
+    constexpr AABB<value_type> push(const vector_type& vector) const;
+
+public:
+    vector_type min {};
+    vector_type max {};
+};
+} // namespace math
+
+namespace math
+{
+using AABBf = AABB<float>;
+} // namespace math
+
+template<math::arithmetic T>
+constexpr math::AABB<T>::AABB(const vector_type& start, const vector_type& end)
+{
+    set_bounds(start, end);
+}
+
+template<math::arithmetic T>
+constexpr void math::AABB<T>::set_bounds(const vector_type& start, const vector_type& end)
+{
+    min = start;
+    max = end;
+}
+
+template<math::arithmetic T>
+constexpr void math::AABB<T>::set_offset(const vector_type& base, const vector_type& size)
+{
+    min = base;
+    max = base + size;
+}
+
+template<math::arithmetic T>
+constexpr bool math::AABB<T>::contains(const vector_type& point) const
+{
+    auto result = true;
+    result = result && (point.x >= min.x) && (point.x <= max.x);
+    result = result && (point.y >= min.y) && (point.y <= max.y);
+    result = result && (point.z >= min.z) && (point.z <= max.z);
+    return result;
+}
+
+template<math::arithmetic T>
+constexpr bool math::AABB<T>::intersect(const AABB<value_type>& other_box) const
+{
+    auto result = true;
+    result = result && (min.x <= other_box.max.x) && (max.x >= other_box.min.x);
+    result = result && (min.y <= other_box.max.y) && (max.y >= other_box.min.y);
+    result = result && (min.z <= other_box.max.z) && (max.z >= other_box.min.z);
+    return result;
+}
+
+template<math::arithmetic T>
+constexpr math::AABB<T> math::AABB<T>::combine(const AABB<value_type>& other_box) const
+{
+    AABB<value_type> result;
+    result.min.x = glm::min(min.x, other_box.min.x);
+    result.min.y = glm::min(min.y, other_box.min.y);
+    result.min.z = glm::min(min.z, other_box.min.z);
+    result.max.x = glm::max(max.x, other_box.max.x);
+    result.max.y = glm::max(max.y, other_box.max.y);
+    result.max.z = glm::max(max.z, other_box.max.z);
+    return result;
+}
+
+template<math::arithmetic T>
+constexpr math::AABB<T> math::AABB<T>::multiply(const AABB<value_type>& other_box) const
+{
+    AABB<value_type> result;
+    result.min.x = glm::max(min.x, other_box.min.x);
+    result.min.y = glm::max(min.y, other_box.min.y);
+    result.min.z = glm::max(min.z, other_box.min.z);
+    result.max.x = glm::min(max.x, other_box.max.x);
+    result.max.y = glm::min(max.y, other_box.max.y);
+    result.max.z = glm::min(max.z, other_box.max.z);
+    return result;
+}
+
+template<math::arithmetic T>
+constexpr math::AABB<T> math::AABB<T>::push(const vector_type& vector) const
+{
+    AABB<value_type> result;
+    result.min = min + vector;
+    result.max = max + vector;
+    return result;
+}
diff --git a/src/core/math/angles.hh b/src/core/math/angles.hh
new file mode 100644
index 0000000..174f320
--- /dev/null
+++ b/src/core/math/angles.hh
@@ -0,0 +1,103 @@
+#pragma once
+
+#include "core/math/constexpr.hh"
+
+constexpr float A180 = math::radians(180.0f);
+constexpr float A360 = math::radians(360.0f);
+
+namespace math
+{
+float wrap_180(float angle);
+float wrap_360(float angle);
+} // namespace math
+
+namespace math
+{
+glm::fvec3 wrap_180(const glm::fvec3& angles);
+glm::fvec3 wrap_360(const glm::fvec3& angles);
+} // namespace math
+
+namespace math
+{
+void vectors(const glm::fvec3& angles, glm::fvec3& forward);
+void vectors(const glm::fvec3& angles, glm::fvec3* forward, glm::fvec3* right, glm::fvec3* up);
+} // namespace math
+
+inline float math::wrap_180(float angle)
+{
+    const auto result = std::fmod(angle + A180, A360);
+
+    if(result < 0.0f) {
+        return result + A180;
+    }
+
+    return result - A180;
+}
+
+inline float math::wrap_360(float angle)
+{
+    return std::fmod(std::fmod(angle, A360) + A360, A360);
+}
+
+inline glm::fvec3 math::wrap_180(const glm::fvec3& angles)
+{
+    return glm::fvec3 {
+        math::wrap_180(angles.x),
+        math::wrap_180(angles.y),
+        math::wrap_180(angles.z),
+    };
+}
+
+inline glm::fvec3 math::wrap_360(const glm::fvec3& angles)
+{
+    return glm::fvec3 {
+        math::wrap_360(angles.x),
+        math::wrap_360(angles.y),
+        math::wrap_360(angles.z),
+    };
+}
+
+inline void math::vectors(const glm::fvec3& angles, glm::fvec3& forward)
+{
+    const float cosp = std::cos(angles.x);
+    const float cosy = std::cos(angles.y);
+    const float sinp = std::sin(angles.x);
+    const float siny = std::sin(angles.y);
+
+    forward.x = cosp * siny * (-1.0f);
+    forward.y = sinp;
+    forward.z = cosp * cosy * (-1.0f);
+}
+
+inline void math::vectors(const glm::fvec3& angles, glm::fvec3* forward, glm::fvec3* right, glm::fvec3* up)
+{
+    if(!forward && !right && !up) {
+        // There's no point in figuring out
+        // direction vectors if nothing is passed
+        // in the function to store that stuff in
+        return;
+    }
+
+    const auto pcv = glm::cos(angles);
+    const auto psv = glm::sin(angles);
+    const auto ncv = pcv * (-1.0f);
+    const auto nsv = psv * (-1.0f);
+
+    if(forward) {
+        forward->x = pcv.x * nsv.y;
+        forward->y = psv.x;
+        forward->z = pcv.x * ncv.y;
+    }
+
+    if(right) {
+        right->x = pcv.z * pcv.y;
+        right->y = psv.z * pcv.y;
+        right->z = nsv.y;
+    }
+
+    if(up) {
+        up->x = psv.x * psv.y * pcv.z + ncv.y * psv.z;
+        up->y = pcv.x * pcv.z;
+        up->z = nsv.x * ncv.y * pcv.z + psv.y * psv.z;
+    }
+}
diff --git a/src/core/math/concepts.hh b/src/core/math/concepts.hh
new file mode 100644
index 0000000..6ad5cb7
--- /dev/null
+++ b/src/core/math/concepts.hh
@@ -0,0 +1,11 @@
+#pragma once
+
+namespace math
+{
+template<typename type>
+concept arithmetic = std::is_arithmetic_v<type>;
+template<typename type>
+concept signed_arithmetic = std::is_arithmetic_v<type> && std::is_signed_v<type>;
+template<typename type>
+concept unsigned_arithmetic = std::is_arithmetic_v<type> && std::is_unsigned_v<type>;
+} // namespace math
diff --git a/src/core/math/constexpr.hh b/src/core/math/constexpr.hh
new file mode 100644
index 0000000..4158803
--- /dev/null
+++ b/src/core/math/constexpr.hh
@@ -0,0 +1,72 @@
+#pragma once
+
+#include "core/math/concepts.hh"
+
+namespace math
+{
+template<typename type, std::size_t size>
+constexpr std::size_t array_size(const type (&)[size]);
+} // namespace math
+
+namespace math
+{
+template<std::integral scalar>
+constexpr scalar log2(const scalar x);
+template<std::signed_integral scalar>
+constexpr scalar mod_signed(const scalar x, const scalar m);
+template<math::signed_arithmetic result_scalar, math::arithmetic scalar>
+constexpr result_scalar sign(const scalar x);
+} // namespace math
+
+namespace math
+{
+template<math::arithmetic scalar>
+constexpr scalar degrees(const scalar x);
+template<math::arithmetic scalar>
+constexpr scalar radians(const scalar x);
+} // namespace math
+
+template<typename type, std::size_t size>
+constexpr std::size_t math::array_size(const type (&)[size])
+{
+    return size;
+}
+
+template<std::integral scalar>
+constexpr scalar math::log2(const scalar x)
+{
+    if(x < static_cast<scalar>(2))
+        return static_cast<scalar>(0);
+    return math::log2<scalar>((x + static_cast<scalar>(1)) >> 1) + static_cast<scalar>(1);
+}
+
+template<std::signed_integral scalar>
+constexpr scalar math::mod_signed(const scalar x, const scalar m)
+{
+    auto result = static_cast<scalar>(x % m);
+    if(result < static_cast<scalar>(0))
+        return result + m;
+    return result;
+}
+
+template<math::signed_arithmetic result_scalar, math::arithmetic scalar>
+constexpr result_scalar math::sign(const scalar x)
+{
+    if(x < static_cast<scalar>(0))
+        return static_cast<result_scalar>(-1);
+    if(x > static_cast<scalar>(0))
+        return static_cast<result_scalar>(+1);
+    return static_cast<result_scalar>(0);
+}
+
+template<math::arithmetic scalar>
+constexpr scalar math::degrees(const scalar x)
+{
+    return static_cast<scalar>(static_cast<double>(x) * 180.0 / M_PI);
+}
+
+template<math::arithmetic scalar>
+constexpr scalar math::radians(const scalar x)
+{
+    return static_cast<scalar>(static_cast<double>(x) * M_PI / 180.0);
+}
diff --git a/src/core/math/crc64.cc b/src/core/math/crc64.cc
new file mode 100644
index 0000000..99a4b20
--- /dev/null
+++ b/src/core/math/crc64.cc
@@ -0,0 +1,76 @@
+#include "core/pch.hh"
+
+#include "core/math/crc64.hh"
+
+// The lookup table for CRC64 checksum; this lookup
+// table is generated using ECMA-182 compilant parameters:
+// - Polynomial: `0x42F0E1EBA9EA3693`
+// - Initial value: `0x0000000000000000`
+// - Final xor: `0x0000000000000000`
+// CRC Calculator: https://www.sunshine2k.de/coding/javascript/crc/crc_js.html
+constexpr static const std::uint64_t crc_table[256] = { 0x0000000000000000, 0x42F0E1EBA9EA3693, 0x85E1C3D753D46D26, 0xC711223CFA3E5BB5,
+    0x493366450E42ECDF, 0x0BC387AEA7A8DA4C, 0xCCD2A5925D9681F9, 0x8E224479F47CB76A, 0x9266CC8A1C85D9BE, 0xD0962D61B56FEF2D,
+    0x17870F5D4F51B498, 0x5577EEB6E6BB820B, 0xDB55AACF12C73561, 0x99A54B24BB2D03F2, 0x5EB4691841135847, 0x1C4488F3E8F96ED4,
+    0x663D78FF90E185EF, 0x24CD9914390BB37C, 0xE3DCBB28C335E8C9, 0xA12C5AC36ADFDE5A, 0x2F0E1EBA9EA36930, 0x6DFEFF5137495FA3,
+    0xAAEFDD6DCD770416, 0xE81F3C86649D3285, 0xF45BB4758C645C51, 0xB6AB559E258E6AC2, 0x71BA77A2DFB03177, 0x334A9649765A07E4,
+    0xBD68D2308226B08E, 0xFF9833DB2BCC861D, 0x388911E7D1F2DDA8, 0x7A79F00C7818EB3B, 0xCC7AF1FF21C30BDE, 0x8E8A101488293D4D,
+    0x499B3228721766F8, 0x0B6BD3C3DBFD506B, 0x854997BA2F81E701, 0xC7B97651866BD192, 0x00A8546D7C558A27, 0x4258B586D5BFBCB4,
+    0x5E1C3D753D46D260, 0x1CECDC9E94ACE4F3, 0xDBFDFEA26E92BF46, 0x990D1F49C77889D5, 0x172F5B3033043EBF, 0x55DFBADB9AEE082C,
+    0x92CE98E760D05399, 0xD03E790CC93A650A, 0xAA478900B1228E31, 0xE8B768EB18C8B8A2, 0x2FA64AD7E2F6E317, 0x6D56AB3C4B1CD584,
+    0xE374EF45BF6062EE, 0xA1840EAE168A547D, 0x66952C92ECB40FC8, 0x2465CD79455E395B, 0x3821458AADA7578F, 0x7AD1A461044D611C,
+    0xBDC0865DFE733AA9, 0xFF3067B657990C3A, 0x711223CFA3E5BB50, 0x33E2C2240A0F8DC3, 0xF4F3E018F031D676, 0xB60301F359DBE0E5,
+    0xDA050215EA6C212F, 0x98F5E3FE438617BC, 0x5FE4C1C2B9B84C09, 0x1D14202910527A9A, 0x93366450E42ECDF0, 0xD1C685BB4DC4FB63,
+    0x16D7A787B7FAA0D6, 0x5427466C1E109645, 0x4863CE9FF6E9F891, 0x0A932F745F03CE02, 0xCD820D48A53D95B7, 0x8F72ECA30CD7A324,
+    0x0150A8DAF8AB144E, 0x43A04931514122DD, 0x84B16B0DAB7F7968, 0xC6418AE602954FFB, 0xBC387AEA7A8DA4C0, 0xFEC89B01D3679253,
+    0x39D9B93D2959C9E6, 0x7B2958D680B3FF75, 0xF50B1CAF74CF481F, 0xB7FBFD44DD257E8C, 0x70EADF78271B2539, 0x321A3E938EF113AA,
+    0x2E5EB66066087D7E, 0x6CAE578BCFE24BED, 0xABBF75B735DC1058, 0xE94F945C9C3626CB, 0x676DD025684A91A1, 0x259D31CEC1A0A732,
+    0xE28C13F23B9EFC87, 0xA07CF2199274CA14, 0x167FF3EACBAF2AF1, 0x548F120162451C62, 0x939E303D987B47D7, 0xD16ED1D631917144,
+    0x5F4C95AFC5EDC62E, 0x1DBC74446C07F0BD, 0xDAAD56789639AB08, 0x985DB7933FD39D9B, 0x84193F60D72AF34F, 0xC6E9DE8B7EC0C5DC,
+    0x01F8FCB784FE9E69, 0x43081D5C2D14A8FA, 0xCD2A5925D9681F90, 0x8FDAB8CE70822903, 0x48CB9AF28ABC72B6, 0x0A3B7B1923564425,
+    0x70428B155B4EAF1E, 0x32B26AFEF2A4998D, 0xF5A348C2089AC238, 0xB753A929A170F4AB, 0x3971ED50550C43C1, 0x7B810CBBFCE67552,
+    0xBC902E8706D82EE7, 0xFE60CF6CAF321874, 0xE224479F47CB76A0, 0xA0D4A674EE214033, 0x67C58448141F1B86, 0x253565A3BDF52D15,
+    0xAB1721DA49899A7F, 0xE9E7C031E063ACEC, 0x2EF6E20D1A5DF759, 0x6C0603E6B3B7C1CA, 0xF6FAE5C07D3274CD, 0xB40A042BD4D8425E,
+    0x731B26172EE619EB, 0x31EBC7FC870C2F78, 0xBFC9838573709812, 0xFD39626EDA9AAE81, 0x3A28405220A4F534, 0x78D8A1B9894EC3A7,
+    0x649C294A61B7AD73, 0x266CC8A1C85D9BE0, 0xE17DEA9D3263C055, 0xA38D0B769B89F6C6, 0x2DAF4F0F6FF541AC, 0x6F5FAEE4C61F773F,
+    0xA84E8CD83C212C8A, 0xEABE6D3395CB1A19, 0x90C79D3FEDD3F122, 0xD2377CD44439C7B1, 0x15265EE8BE079C04, 0x57D6BF0317EDAA97,
+    0xD9F4FB7AE3911DFD, 0x9B041A914A7B2B6E, 0x5C1538ADB04570DB, 0x1EE5D94619AF4648, 0x02A151B5F156289C, 0x4051B05E58BC1E0F,
+    0x87409262A28245BA, 0xC5B073890B687329, 0x4B9237F0FF14C443, 0x0962D61B56FEF2D0, 0xCE73F427ACC0A965, 0x8C8315CC052A9FF6,
+    0x3A80143F5CF17F13, 0x7870F5D4F51B4980, 0xBF61D7E80F251235, 0xFD913603A6CF24A6, 0x73B3727A52B393CC, 0x31439391FB59A55F,
+    0xF652B1AD0167FEEA, 0xB4A25046A88DC879, 0xA8E6D8B54074A6AD, 0xEA16395EE99E903E, 0x2D071B6213A0CB8B, 0x6FF7FA89BA4AFD18,
+    0xE1D5BEF04E364A72, 0xA3255F1BE7DC7CE1, 0x64347D271DE22754, 0x26C49CCCB40811C7, 0x5CBD6CC0CC10FAFC, 0x1E4D8D2B65FACC6F,
+    0xD95CAF179FC497DA, 0x9BAC4EFC362EA149, 0x158E0A85C2521623, 0x577EEB6E6BB820B0, 0x906FC95291867B05, 0xD29F28B9386C4D96,
+    0xCEDBA04AD0952342, 0x8C2B41A1797F15D1, 0x4B3A639D83414E64, 0x09CA82762AAB78F7, 0x87E8C60FDED7CF9D, 0xC51827E4773DF90E,
+    0x020905D88D03A2BB, 0x40F9E43324E99428, 0x2CFFE7D5975E55E2, 0x6E0F063E3EB46371, 0xA91E2402C48A38C4, 0xEBEEC5E96D600E57,
+    0x65CC8190991CB93D, 0x273C607B30F68FAE, 0xE02D4247CAC8D41B, 0xA2DDA3AC6322E288, 0xBE992B5F8BDB8C5C, 0xFC69CAB42231BACF,
+    0x3B78E888D80FE17A, 0x7988096371E5D7E9, 0xF7AA4D1A85996083, 0xB55AACF12C735610, 0x724B8ECDD64D0DA5, 0x30BB6F267FA73B36,
+    0x4AC29F2A07BFD00D, 0x08327EC1AE55E69E, 0xCF235CFD546BBD2B, 0x8DD3BD16FD818BB8, 0x03F1F96F09FD3CD2, 0x41011884A0170A41,
+    0x86103AB85A2951F4, 0xC4E0DB53F3C36767, 0xD8A453A01B3A09B3, 0x9A54B24BB2D03F20, 0x5D45907748EE6495, 0x1FB5719CE1045206,
+    0x919735E51578E56C, 0xD367D40EBC92D3FF, 0x1476F63246AC884A, 0x568617D9EF46BED9, 0xE085162AB69D5E3C, 0xA275F7C11F7768AF,
+    0x6564D5FDE549331A, 0x279434164CA30589, 0xA9B6706FB8DFB2E3, 0xEB46918411358470, 0x2C57B3B8EB0BDFC5, 0x6EA7525342E1E956,
+    0x72E3DAA0AA188782, 0x30133B4B03F2B111, 0xF7021977F9CCEAA4, 0xB5F2F89C5026DC37, 0x3BD0BCE5A45A6B5D, 0x79205D0E0DB05DCE,
+    0xBE317F32F78E067B, 0xFCC19ED95E6430E8, 0x86B86ED5267CDBD3, 0xC4488F3E8F96ED40, 0x0359AD0275A8B6F5, 0x41A94CE9DC428066,
+    0xCF8B0890283E370C, 0x8D7BE97B81D4019F, 0x4A6ACB477BEA5A2A, 0x089A2AACD2006CB9, 0x14DEA25F3AF9026D, 0x562E43B4931334FE,
+    0x913F6188692D6F4B, 0xD3CF8063C0C759D8, 0x5DEDC41A34BBEEB2, 0x1F1D25F19D51D821, 0xD80C07CD676F8394, 0x9AFCE626CE85B507 };
+
+std::uint64_t math::crc64(const void* buffer, std::size_t size, std::uint64_t combine)
+{
+    auto data = reinterpret_cast<const std::uint8_t*>(buffer);
+    for(std::size_t i = 0; i < size; ++i)
+        combine = crc_table[((combine >> 56) ^ data[i]) & 0xFF] ^ (combine << 8);
+    return combine;
+}
+
+std::uint64_t math::crc64(const std::vector<std::byte>& buffer, std::uint64_t combine)
+{
+    return math::crc64(buffer.data(), buffer.size(), combine);
+}
+
+std::uint64_t math::crc64(const std::string& buffer, std::uint64_t combine)
+{
+    return math::crc64(buffer.data(), buffer.size(), combine);
+}
+
+std::uint64_t math::crc64(std::string_view buffer, std::uint64_t combine)
+{
+    return math::crc64(buffer.data(), buffer.size(), combine);
+}
diff --git a/src/core/math/crc64.hh b/src/core/math/crc64.hh
new file mode 100644
index 0000000..3ece0df
--- /dev/null
+++ b/src/core/math/crc64.hh
@@ -0,0 +1,9 @@
+#pragma once
+
+namespace math
+{
+std::uint64_t crc64(const void* buffer, std::size_t size, std::uint64_t combine = UINT64_C(0));
+std::uint64_t crc64(const std::vector<std::byte>& buffer, std::uint64_t combine = UINT64_C(0));
+std::uint64_t crc64(const std::string& buffer, std::uint64_t combine = UINT64_C(0));
+std::uint64_t crc64(std::string_view buffer, std::uint64_t combine = UINT64_C(0));
+} // namespace math
diff --git a/src/core/math/vectors.hh b/src/core/math/vectors.hh
new file mode 100644
index 0000000..bc11dd0
--- /dev/null
+++ b/src/core/math/vectors.hh
@@ -0,0 +1,43 @@
+#pragma once
+
+#include "core/math/concepts.hh"
+
+// core/vectors.hh - because NO ONE would POSSIBLY
+// need integer-based distance calculations in a
+// game about voxels. That would be INSANE! :D
+
+namespace math
+{
+template<math::arithmetic T>
+constexpr static inline const T length2(const glm::vec<2, T>& vector);
+template<math::arithmetic T>
+constexpr static inline const T length2(const glm::vec<3, T>& vector);
+template<math::arithmetic T>
+constexpr static inline const T distance2(const glm::vec<2, T>& vector_a, const glm::vec<2, T>& vector_b);
+template<math::arithmetic T>
+constexpr static inline const T distance2(const glm::vec<3, T>& vector_a, const glm::vec<3, T>& vector_b);
+} // namespace math
+
+template<math::arithmetic T>
+constexpr static inline const T math::length2(const glm::vec<2, T>& vector)
+{
+    return (vector.x * vector.x) + (vector.y * vector.y);
+}
+
+template<math::arithmetic T>
+constexpr static inline const T math::length2(const glm::vec<3, T>& vector)
+{
+    return (vector.x * vector.x) + (vector.y * vector.y) + (vector.z * vector.z);
+}
+
+template<math::arithmetic T>
+constexpr static inline const T math::distance2(const glm::vec<2, T>& vector_a, const glm::vec<2, T>& vector_b)
+{
+    return math::length2(vector_a - vector_b);
+}
+
+template<math::arithmetic T>
+constexpr static inline const T math::distance2(const glm::vec<3, T>& vector_a, const glm::vec<3, T>& vector_b)
+{
+    return math::length2(vector_a - vector_b);
+}
diff --git a/src/core/pch.hh b/src/core/pch.hh
new file mode 100644
index 0000000..17417a5
--- /dev/null
+++ b/src/core/pch.hh
@@ -0,0 +1,49 @@
+#pragma once
+
+#include <cinttypes>
+#include <cmath>
+#include <cstdarg>
+#include <cstddef>
+#include <cstdint>
+
+#include <algorithm>
+#include <chrono>
+#include <concepts>
+#include <filesystem>
+#include <format>
+#include <iostream>
+#include <limits>
+#include <mutex>
+#include <random>
+#include <sstream>
+#include <stdexcept>
+#include <thread>
+#include <type_traits>
+#include <typeindex>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+#include <BS_thread_pool.hpp>
+
+#include <emhash/hash_table8.hpp>
+
+#include <enet/enet.h>
+
+#include <glm/fwd.hpp>
+
+#include <glm/mat4x4.hpp>
+#include <glm/vec2.hpp>
+#include <glm/vec3.hpp>
+#include <glm/vec4.hpp>
+
+#include <glm/gtc/matrix_transform.hpp>
+#include <glm/gtc/quaternion.hpp>
+#include <glm/gtc/type_ptr.hpp>
+
+#include <physfs.h>
+
+#include <spdlog/spdlog.h>
+
+#include <stb_image.h>
+#include <stb_image_write.h>
diff --git a/src/core/resource/CMakeLists.txt b/src/core/resource/CMakeLists.txt
new file mode 100644
index 0000000..840b3c2
--- /dev/null
+++ b/src/core/resource/CMakeLists.txt
@@ -0,0 +1,5 @@
+target_sources(core PRIVATE
+    "${CMAKE_CURRENT_LIST_DIR}/image.cc"
+    "${CMAKE_CURRENT_LIST_DIR}/image.hh"
+    "${CMAKE_CURRENT_LIST_DIR}/resource.cc"
+    "${CMAKE_CURRENT_LIST_DIR}/resource.hh")
diff --git a/src/core/resource/image.cc b/src/core/resource/image.cc
new file mode 100644
index 0000000..8ab98db
--- /dev/null
+++ b/src/core/resource/image.cc
@@ -0,0 +1,81 @@
+#include "core/pch.hh"
+
+#include "core/resource/image.hh"
+
+#include "core/resource/resource.hh"
+
+#include "core/io/physfs.hh"
+
+static int stbi_physfs_read(void* context, char* data, int size)
+{
+    return static_cast<int>(PHYSFS_readBytes(reinterpret_cast<PHYSFS_File*>(context), data, size));
+}
+
+static void stbi_physfs_skip(void* context, int count)
+{
+    auto file = reinterpret_cast<PHYSFS_File*>(context);
+    PHYSFS_seek(file, PHYSFS_tell(file) + count);
+}
+
+static int stbi_physfs_eof(void* context)
+{
+    return PHYSFS_eof(reinterpret_cast<PHYSFS_File*>(context));
+}
+
+static const void* image_load_func(const char* name, std::uint32_t flags)
+{
+    assert(name);
+
+    stbi_io_callbacks callbacks;
+    callbacks.read = &stbi_physfs_read;
+    callbacks.skip = &stbi_physfs_skip;
+    callbacks.eof = &stbi_physfs_eof;
+
+    stbi_set_flip_vertically_on_load(bool(flags & IMAGE_LOAD_FLIP));
+
+    auto file = PHYSFS_openRead(name);
+
+    if(file == nullptr) {
+        spdlog::error("image: {}: {}", name, io::physfs_error());
+        return nullptr;
+    }
+
+    int desired_channels;
+
+    if(flags & IMAGE_LOAD_GRAY) {
+        desired_channels = STBI_grey;
+    }
+    else {
+        desired_channels = STBI_rgb_alpha;
+    }
+
+    int width, height, channels;
+    auto pixels = stbi_load_from_callbacks(&callbacks, file, &width, &height, &channels, desired_channels);
+
+    PHYSFS_close(file);
+
+    if(pixels == nullptr) {
+        spdlog::error("image: {}: {}", name, stbi_failure_reason());
+        return nullptr;
+    }
+
+    auto image = new Image;
+    image->pixels = pixels;
+    image->size = glm::ivec2(width, height);
+    return image;
+}
+
+static void image_free_func(const void* resource)
+{
+    assert(resource);
+
+    auto image = reinterpret_cast<const Image*>(resource);
+    stbi_image_free(image->pixels);
+
+    delete image;
+}
+
+void Image::register_resource(void)
+{
+    resource::register_loader<Image>(&image_load_func, &image_free_func);
+}
diff --git a/src/core/resource/image.hh b/src/core/resource/image.hh
new file mode 100644
index 0000000..575591f
--- /dev/null
+++ b/src/core/resource/image.hh
@@ -0,0 +1,11 @@
+#pragma once
+
+constexpr static unsigned int IMAGE_LOAD_GRAY = 0x0001U;
+constexpr static unsigned int IMAGE_LOAD_FLIP = 0x0002U;
+
+struct Image final {
+    static void register_resource(void);
+
+    stbi_uc* pixels;
+    glm::ivec2 size;
+};
diff --git a/src/core/resource/resource.cc b/src/core/resource/resource.cc
new file mode 100644
index 0000000..926dfc5
--- /dev/null
+++ b/src/core/resource/resource.cc
@@ -0,0 +1,126 @@
+#include "core/pch.hh"
+
+#include "core/resource/resource.hh"
+
+struct ResourceLoader final {
+    ResourceLoadFunc load_func;
+    ResourceFreeFunc free_func;
+    emhash8::HashMap<std::string, std::shared_ptr<const void>> resources;
+    std::vector<std::shared_ptr<const void>> cache;
+    std::string class_name;
+};
+
+static emhash8::HashMap<std::type_index, std::unique_ptr<ResourceLoader>> loaders;
+
+void resource::detail::register_loader(const std::type_info& type, ResourceLoadFunc load_func, ResourceFreeFunc free_func)
+{
+    assert(load_func);
+    assert(free_func);
+
+    auto type_index = std::type_index(type);
+    auto loader = std::make_unique<ResourceLoader>();
+    loader->class_name = type.name();
+    loader->load_func = load_func;
+    loader->free_func = free_func;
+
+    assert(!loaders.contains(type_index));
+
+    loaders.insert_or_assign(type_index, std::move(loader));
+}
+
+std::shared_ptr<const void> resource::detail::load_resource(const std::type_info& type, std::string_view name, std::uint32_t flags)
+{
+    auto name_str = std::string(name);
+    auto type_index = std::type_index(type);
+    auto loader = loaders.find(type_index);
+
+    if(loader == loaders.cend()) {
+        spdlog::error("resource: no loader registered for type [{}]", type.name());
+        return nullptr;
+    }
+
+    auto resource_it = loader->second->resources.find(name_str);
+
+    if(resource_it == loader->second->resources.cend()) {
+        auto resource_raw = loader->second->load_func(name_str.c_str(), flags);
+
+        if(resource_raw == nullptr) {
+            spdlog::error("resource: {} [{}]: load failed", loader->second->class_name, name);
+            return nullptr;
+        }
+
+        std::shared_ptr<const void> resource_ptr(resource_raw, [](const void* ptr) { /* empty */ });
+        auto loaded_it = loader->second->resources.insert_or_assign(name_str, std::move(resource_ptr));
+
+        if(flags & RESOURCE_CACHE) {
+            loader->second->cache.push_back(loaded_it.first->second);
+        }
+
+        return loaded_it.first->second;
+    }
+
+    return resource_it->second;
+}
+
+std::shared_ptr<const void> resource::detail::find_resource(const std::type_info& type, std::string_view name)
+{
+    auto name_str = std::string(name);
+    auto type_index = std::type_index(type);
+    auto loader = loaders.find(type_index);
+
+    if(loader == loaders.cend()) {
+        spdlog::error("resource: no loader registered for type [{}]", type.name());
+        return nullptr;
+    }
+
+    auto resource_it = loader->second->resources.find(name_str);
+
+    if(resource_it == loader->second->resources.cend()) {
+        spdlog::error("resource: {} [{}]: not found", loader->second->class_name, name);
+        return nullptr;
+    }
+
+    return resource_it->second;
+}
+
+void resource::hard_cleanup(void)
+{
+    for(auto& [type_index, loader] : loaders) {
+        loader->cache.clear();
+
+        for(auto& [name, resource_ptr] : loader->resources) {
+            if(resource_ptr.use_count() > 1) {
+                spdlog::warn("resource: zombie resource: {} [{}] [use_count={}]", name, loader->class_name, resource_ptr.use_count());
+            }
+            else {
+                spdlog::debug("resource: releasing {} [{}]", name, loader->class_name);
+            }
+
+            loader->free_func(resource_ptr.get());
+        }
+
+        loader->resources.clear();
+    }
+
+    loaders.clear();
+}
+
+void resource::soft_cleanup(void)
+{
+    for(auto& [type_index, loader] : loaders) {
+        auto resource_it = loader->resources.begin();
+
+        while(resource_it != loader->resources.end()) {
+            if(resource_it->second.use_count() <= 1) {
+                spdlog::debug("resource: releasing {} [{}]", resource_it->first, loader->class_name);
+
+                loader->free_func(resource_it->second.get());
+                resource_it = loader->resources.erase(resource_it);
+
+                continue;
+            }
+
+            resource_it = std::next(resource_it);
+        }
+    }
+}
diff --git a/src/core/resource/resource.hh b/src/core/resource/resource.hh
new file mode 100644
index 0000000..105c7ff
--- /dev/null
+++ b/src/core/resource/resource.hh
@@ -0,0 +1,53 @@
+#pragma once
+
+template<typename T>
+using resource_ptr = std::shared_ptr<const T>;
+
+constexpr std::uint32_t RESOURCE_CACHE = 0x00000001U; ///< Cache the resource after loading
+constexpr std::uint32_t RESOURCE_USER = 0xFFFFFF00U;  ///< User-defined flags for custom behavior
+
+using ResourceLoadFunc = const void* (*)(const char* name, std::uint32_t flags);
+using ResourceFreeFunc = void (*)(const void* resource);
+
+namespace resource::detail
+{
+void register_loader(const std::type_info& type, ResourceLoadFunc load_func, ResourceFreeFunc free_func);
+resource_ptr<void> load_resource(const std::type_info& type, std::string_view name, std::uint32_t flags);
+resource_ptr<void> find_resource(const std::type_info& type, std::string_view name);
+} // namespace resource::detail
+
+namespace resource
+{
+template<typename T>
+void register_loader(ResourceLoadFunc load_func, ResourceFreeFunc free_func);
+template<typename T>
+resource_ptr<T> load(std::string_view name, std::uint32_t flags = 0U);
+template<typename T>
+resource_ptr<T> find(std::string_view name);
+} // namespace resource
+
+namespace resource
+{
+void hard_cleanup(void);
+void soft_cleanup(void);
+} // namespace resource
+
+template<typename T>
+void resource::register_loader(ResourceLoadFunc load_func, ResourceFreeFunc free_func)
+{
+    resource::detail::register_loader(typeid(T), load_func, free_func);
+}
+
+template<typename T>
+resource_ptr<T> resource::load(std::string_view name, std::uint32_t flags)
+{
+    auto result = resource::detail::load_resource(typeid(T), name, flags);
+    return std::reinterpret_pointer_cast<const T>(result);
+}
+
+template<typename T>
+resource_ptr<T> resource::find(std::string_view name)
+{
+    auto result = resource::detail::find_resource(typeid(T), name);
+    return std::reinterpret_pointer_cast<const T>(result);
+}
diff --git a/src/core/threading.cc b/src/core/threading.cc
new file mode 100644
index 0000000..03c0e8e
--- /dev/null
+++ b/src/core/threading.cc
@@ -0,0 +1,128 @@
+#include "core/pch.hh"
+
+#include "core/threading.hh"
+
+#include "core/io/cmdline.hh"
+
+#include "core/math/constexpr.hh"
+
+constexpr static std::string_view DEFAULT_POOL_SIZE_ARG = "4";
+
+static BS::light_thread_pool* thread_pool;
+static std::deque<Task*> task_deque;
+
+static void task_process(Task* task)
+{
+    task->set_status(task_status::PROCESSING);
+    task->process();
+
+    if(task->get_status() == task_status::PROCESSING) {
+        // If the task status is still PROCESSING
+        // it can be deduced it hasn't been cancelled
+        task->set_status(task_status::COMPLETED);
+    }
+}
+
+task_status Task::get_status(void) const
+{
+    return m_status;
+}
+
+void Task::set_status(task_status status)
+{
+    m_status = status;
+}
+
+void threading::init(void)
+{
+    auto argument = io::cmdline::get("threads", DEFAULT_POOL_SIZE_ARG);
+    auto num_concurrent_threads = std::thread::hardware_concurrency();
+    unsigned int thread_pool_size;
+
+    if(num_concurrent_threads && 0 == argument.compare("max")) {
+        // Use the maximum available number of concurrent
+        // hardware threads provided by the implementation
+        thread_pool_size = num_concurrent_threads;
+    }
+    else {
+        if(num_concurrent_threads) {
+            auto result = std::from_chars(argument.data(), argument.data() + argument.size(), thread_pool_size);
+
+            if(result.ec == std::errc()) {
+                thread_pool_size = glm::clamp<unsigned int>(thread_pool_size, 1U, num_concurrent_threads);
+            }
+            else {
+                thread_pool_size = 4U;
+            }
+        }
+        else {
+            auto result = std::from_chars(argument.data(), argument.data() + argument.size(), thread_pool_size);
+
+            if(result.ec == std::errc()) {
+                thread_pool_size = glm::max<unsigned int>(thread_pool_size, 1U);
+            }
+            else {
+                thread_pool_size = 4U;
+            }
+        }
+    }
+
+    spdlog::info("threading: using {} threads for pooling tasks", thread_pool_size);
+
+    thread_pool = new BS::light_thread_pool(thread_pool_size);
+
+    task_deque.clear();
+}
+
+void threading::shutdown(void)
+{
+    for(auto task : task_deque) {
+        auto status = task->get_status();
+        if((status != task_status::CANCELLED) || (status != task_status::COMPLETED)) {
+            task->set_status(task_status::CANCELLED);
+        }
+    }
+
+    thread_pool->purge();
+    thread_pool->wait();
+
+    for(auto task : task_deque)
+        delete task;
+    task_deque.clear();
+
+    delete thread_pool;
+}
+
+void threading::update(void)
+{
+    auto task_iter = task_deque.cbegin();
+
+    while(task_iter != task_deque.cend()) {
+        auto task_ptr = *task_iter;
+        auto status = task_ptr->get_status();
+
+        if(status == task_status::CANCELLED) {
+            delete task_ptr;
+            task_iter = task_deque.erase(task_iter);
+            continue;
+        }
+
+        if(status == task_status::COMPLETED) {
+            task_ptr->finalize();
+            delete task_ptr;
+            task_iter = task_deque.erase(task_iter);
+            continue;
+        }
+
+        task_iter = std::next(task_iter);
+    }
+}
+
+void threading::detail::submit_new(Task* task)
+{
+    task->set_status(task_status::ENQUEUED);
+
+    static_cast<void>(thread_pool->submit_task(std::bind(&task_process, task)));
+
+    task_deque.push_back(task);
+}
diff --git a/src/core/threading.hh b/src/core/threading.hh
new file mode 100644
index 0000000..14f17f8
--- /dev/null
+++ b/src/core/threading.hh
@@ -0,0 +1,46 @@
+#pragma once
+
+enum class task_status : unsigned int {
+    ENQUEUED = 0x0000U,
+    PROCESSING = 0x0001U,
+    COMPLETED = 0x0002U,
+    CANCELLED = 0x0004U,
+};
+
+class Task {
+public:
+    virtual ~Task(void) = default;
+    virtual void process(void) = 0;
+    virtual void finalize(void) = 0;
+
+    task_status get_status(void) const;
+    void set_status(task_status status);
+
+protected:
+    std::atomic<task_status> m_status;
+    std::future<void> m_future;
+};
+
+namespace threading
+{
+void init(void);
+void shutdown(void);
+void update(void);
+} // namespace threading
+
+namespace threading::detail
+{
+void submit_new(Task* task);
+} // namespace threading::detail
+
+namespace threading
+{
+template<typename T, typename... AT>
+void submit(AT&&... args);
+} // namespace threading
+
+template<typename T, typename... AT>
+inline void threading::submit(AT&&... args)
+{
+    threading::detail::submit_new(new T(args...));
+}
diff --git a/src/core/utils/CMakeLists.txt b/src/core/utils/CMakeLists.txt
new file mode 100644
index 0000000..4f96261
--- /dev/null
+++ b/src/core/utils/CMakeLists.txt
@@ -0,0 +1,5 @@
+target_sources(core PRIVATE
+    "${CMAKE_CURRENT_LIST_DIR}/epoch.cc"
+    "${CMAKE_CURRENT_LIST_DIR}/epoch.hh"
+    "${CMAKE_CURRENT_LIST_DIR}/string.cc"
+    "${CMAKE_CURRENT_LIST_DIR}/string.hh")
diff --git a/src/core/utils/epoch.cc b/src/core/utils/epoch.cc
new file mode 100644
index 0000000..36bdb79
--- /dev/null
+++ b/src/core/utils/epoch.cc
@@ -0,0 +1,39 @@
+#include "core/pch.hh"
+
+#include "core/utils/epoch.hh"
+
+std::uint64_t utils::unix_seconds(void)
+{
+    const auto elapsed = std::chrono::system_clock::now().time_since_epoch();
+    return static_cast<std::uint64_t>(std::chrono::duration_cast<std::chrono::seconds>(elapsed).count());
+}
+
+std::uint64_t utils::unix_milliseconds(void)
+{
+    const auto elapsed = std::chrono::system_clock::now().time_since_epoch();
+    return static_cast<std::uint64_t>(std::chrono::duration_cast<std::chrono::milliseconds>(elapsed).count());
+}
+
+std::uint64_t utils::unix_microseconds(void)
+{
+    const auto elapsed = std::chrono::system_clock::now().time_since_epoch();
+    return static_cast<std::uint64_t>(std::chrono::duration_cast<std::chrono::microseconds>(elapsed).count());
+}
+
+std::int64_t utils::signed_unix_seconds(void)
+{
+    const auto elapsed = std::chrono::system_clock::now().time_since_epoch();
+    return static_cast<std::int64_t>(std::chrono::duration_cast<std::chrono::seconds>(elapsed).count());
+}
+
+std::int64_t utils::signed_unix_milliseconds(void)
+{
+    const auto elapsed = std::chrono::system_clock::now().time_since_epoch();
+    return static_cast<std::int64_t>(std::chrono::duration_cast<std::chrono::milliseconds>(elapsed).count());
+}
+
+std::int64_t utils::signed_unix_microseconds(void)
+{
+    const auto elapsed = std::chrono::system_clock::now().time_since_epoch();
+    return static_cast<std::int64_t>(std::chrono::duration_cast<std::chrono::microseconds>(elapsed).count());
+}
diff --git a/src/core/utils/epoch.hh b/src/core/utils/epoch.hh
new file mode 100644
index 0000000..4bf5460
--- /dev/null
+++ b/src/core/utils/epoch.hh
@@ -0,0 +1,15 @@
+#pragma once
+
+namespace utils
+{
+std::uint64_t unix_seconds(void);
+std::uint64_t unix_milliseconds(void);
+std::uint64_t unix_microseconds(void);
+} // namespace utils
+
+namespace utils
+{
+std::int64_t signed_unix_seconds(void);
+std::int64_t signed_unix_milliseconds(void);
+std::int64_t signed_unix_microseconds(void);
+} // namespace utils
diff --git a/src/core/utils/string.cc b/src/core/utils/string.cc
new file mode 100644
index 0000000..dd3d567
--- /dev/null
+++ b/src/core/utils/string.cc
@@ -0,0 +1,57 @@
+#include "core/pch.hh"
+
+#include "core/utils/string.hh"
+
+constexpr static const char* WHITESPACE_CHARS = " \t\r\n";
+
+bool utils::is_whitespace(const std::string& string)
+{
+    if(string.find_first_not_of(WHITESPACE_CHARS) == std::string::npos) {
+        return true;
+    }
+    else if((string.size() == 1) && string[0] == 0x00) {
+        return true;
+    }
+    else {
+        return string.empty();
+    }
+}
+
+std::string utils::join(const std::vector<std::string>& strings, const std::string& separator)
+{
+    std::ostringstream stream;
+    for(const std::string& str : strings)
+        stream << str << separator;
+    return stream.str();
+}
+
+std::vector<std::string> utils::split(const std::string& string, const std::string& separator)
+{
+    std::size_t pos = 0;
+    std::size_t prev = 0;
+    std::vector<std::string> result;
+
+    while((pos = string.find(separator, prev)) != std::string::npos) {
+        result.push_back(string.substr(prev, pos - prev));
+        prev = pos + separator.length();
+    }
+
+    if(prev <= string.length()) {
+        result.push_back(string.substr(prev, string.length() - prev));
+    }
+
+    return result;
+}
+
+std::string utils::trim_whitespace(const std::string& string)
+{
+    auto su = string.find_first_not_of(WHITESPACE_CHARS);
+    auto sv = string.find_last_not_of(WHITESPACE_CHARS);
+
+    if(su == std::string::npos) {
+        return std::string();
+    }
+    else {
+        return string.substr(su, sv - su + 1);
+    }
+}
diff --git a/src/core/utils/string.hh b/src/core/utils/string.hh
new file mode 100644
index 0000000..827c3ca
--- /dev/null
+++ b/src/core/utils/string.hh
@@ -0,0 +1,17 @@
+#pragma once
+
+namespace utils
+{
+bool is_whitespace(const std::string& string);
+} // namespace utils
+
+namespace utils
+{
+std::string join(const std::vector<std::string>& strings, const std::string& separator);
+std::vector<std::string> split(const std::string& string, const std::string& separator);
+} // namespace utils
+
+namespace utils
+{
+std::string trim_whitespace(const std::string& string);
+} // namespace utils
diff --git a/src/core/version.cc b/src/core/version.cc
new file mode 100644
index 0000000..f508aa0
--- /dev/null
+++ b/src/core/version.cc
@@ -0,0 +1,15 @@
+#include "core/pch.hh"
+
+#include "core/version.hh"
+
+// clang-format off
+const unsigned short version::major = 16;
+const unsigned short version::minor = 0;
+const unsigned short version::patch = 1;
+// clang-format on
+
+const std::string_view version::commit = "d304b608";
+const std::string_view version::branch = "master";
+const std::string_view version::triplet = "16.0.1";
+
+const std::string_view version::full = "16.0.1-d304b608";
diff --git a/src/core/version.cc.in b/src/core/version.cc.in
new file mode 100644
index 0000000..5424a73
--- /dev/null
+++ b/src/core/version.cc.in
@@ -0,0 +1,15 @@
+#include "core/pch.hh"
+
+#include "core/version.hh"
+
+// clang-format off
+const unsigned short version::major = ${PROJECT_VERSION_MAJOR};
+const unsigned short version::minor = ${PROJECT_VERSION_MINOR};
+const unsigned short version::patch = ${PROJECT_VERSION_PATCH};
+// clang-format on
+
+const std::string_view version::commit = "${GIT_COMMIT}";
+const std::string_view version::branch = "${GIT_BRANCH}";
+const std::string_view version::triplet = "${PROJECT_VERSION}";
+
+const std::string_view version::full = "${PROJECT_VERSION}-${GIT_COMMIT}";
diff --git a/src/core/version.hh b/src/core/version.hh
new file mode 100644
index 0000000..c033a3e
--- /dev/null
+++ b/src/core/version.hh
@@ -0,0 +1,20 @@
+#pragma once
+
+namespace version
+{
+extern const unsigned short major;
+extern const unsigned short minor;
+extern const unsigned short patch;
+} // namespace version
+
+namespace version
+{
+extern const std::string_view commit;
+extern const std::string_view branch;
+extern const std::string_view triplet;
+} // namespace version
+
+namespace version
+{
+extern const std::string_view full;
+} // namespace version