u/I-A-S- — reddlx

NOTE: All and any colorations/PRs are welcome, EXCEPT FOR AI GENERATED GARBAGE.

Hey folks,

Let me introduce Auxid: a C++20 platform/library aimed at high-performance applications (specifically game engines and systems software) built around Orthodox C++ and Data-Oriented Design (DOD).

I know the C++ ecosystem isn't short on utility libraries, but I built Auxid to bridge a specific gap: getting the predictable memory layouts and fast compile times of C-style systems programming, without losing the ergonomics of standard C++20 algorithms.

Mainstream C++ often relies on heavily templated, node-based STL containers that can thrash CPU caches or introduce hidden heap allocations. Auxid strips that back. Where the STL is already the right tool for the job (like std::filesystem), Auxid exposes it through thin, zero-overhead wrappers. For the rest, it provides DOD-friendly replacements.

Here’s a quick architectural overview of what’s inside:

Cache-Friendly Containers: Includes a sparse-dense hash map, strictly aligned vector types, and small-string-optimized (SSO) strings.
Plays Nice with <algorithm>: Auxid’s containers use iterators that satisfy C++20 iterator concepts (like contiguous iterators), meaning you can seamlessly pass them into std::sort, standard ranges, and other utilities.
Total Allocator Control: No surprise allocations in the hot path. Auxid integrates rpmalloc out of the box for extremely fast, thread-caching heap allocation, alongside custom arena allocators.
Lightweight Error Handling: Instead of exceptions, it relies on a union-based Result<T, E> and Option<T> that compile to tight representations, paired with Rust-style AU_TRY macros.
Explicit Control Flow: Auxid provides an opt-in CMake target (auxid_platform_standard) that strictly disables C++ exceptions (-fno-exceptions / /EHs-c-) to enforce predictable performance characteristics.

It's designed to be dropped directly into existing CMake projects via FetchContent:

FetchContent_Declare(
  auxid
  GIT_REPOSITORY https://github.com/I-A-S/Auxid.git
  GIT_TAG        main
)
FetchContent_MakeAvailable(auxid)

If you are interested in DOD, alternative standard libraries, or just want to critique the architecture, I’d really value this community's feedback.

Core Library: I-A-S/Auxid
Project Scaffold: I-A-S/Auxid-Project-Template

Licensed under Apache 2.0.

Eager to hear what you think not just about the project, but the principles of Orthodox C++ as a whole!

Hey folks,

If you're building a custom engine (well duh you're here so) and are tired of fighting the STL over memory layouts and hidden allocations. Checkout Auxid.

The core vision behind Auxid is to provide a platform for Orthodox C++ and Data-Oriented Design (DOD). Mainstream modern C++ has a lot of great features, but in game dev, we usually end up paying the price for heavy template metaprogramming, slow builds, and node-based standard containers that thrash CPU caches.

Auxid strips that back. It keeps the language close to fast, predictable, systems-style C++ while providing a lean, DOD-oriented template layer built heavily around explicit heap and arena allocation.

Here are the core features relevant to engine development:

Cache-Friendly Containers: Includes a sparse-dense hash map, small-string-optimized (SSO) strings, and strictly aligned vectors.
Total Allocator Control: Integrated rpmalloc for fast, thread-caching heap allocation, alongside custom arena allocators. Zero surprise allocations in the hot path (no <iostream>, no <vector>).
Lightweight, Exception-Free Error Handling: Auxid provides Rust-style union-based Result<T, E> and Option<T> types, paired with AU_TRY macros. You can link the auxid_platform_standard CMake target to enforce -fno-exceptions and keep your control flow explicit.
Standard-Algorithm Friendly: Unlike some custom engine libraries that reinvent the wheel, Auxid's containers use iterators that satisfy C++20 concepts. You can still use std::sort, ranges, and standard algorithms with no trouble! Where the STL already does things right (like std::filesystem), Auxid exposes it through thin, zero-overhead wrappers.

It's designed to drop trivially into existing CMake projects via FetchContent.

If you want to poke around the code or use it for your next renderer/engine project, you can check it out here:

Core Library: I-A-S/Auxid
Project Scaffold: I-A-S/Auxid-Project-Template (Production-oriented starting point)

It’s completely open-source under the Apache 2.0 license. I'd love to hear your thoughts, feedback, or answer any questions about the architecture

https://preview.redd.it/zbgr0jt9sxyg1.png?width=512&format=png&auto=webp&s=33f33550b66769a3add5609b08be9ce534f785f2