STX — C++23 Systems Toolbelt

Disclaimer: This project is intended for personal use and experimentation. Users are free to fork or modify it, but all usage is at their own risk. The author provides no guarantees regarding functionality, security, or safety.

Version: 0.2.1

A header-only C++23 library for low-level systems programming, binary analysis, and runtime instrumentation. Includes compile-time string literals, time utilities, and integer ranges.

Include <lbyte/stx.hpp> for all modules or individual headers.

Bit manipulation and endian conversion utilities.

User-defined literals for strong types and units.

Supports forward/backward, custom step, enums, strong types.

Sentinel-based, constexpr, works with range and standard containers; models std::ranges::view / input_range, so it composes with std::views adaptors like views::zip. Nothing in C++23/26; proposed for C++29 (views::cycle).

Header-only:

add_subdirectory(extern/stx)
target_link_libraries(<target> PRIVATE lbyte::stx)

With Modules:

set(LBYTE_STX_USE_MODULES ON CACHE BOOL "" FORCE)
add_subdirectory(extern/stx)
target_link_libraries(<target> PRIVATE lbyte::stx)

FetchContent:

include(FetchContent)
FetchContent_Declare(
    stx
    GIT_REPOSITORY https://github.com/zethcxx/stx.git
    GIT_TAG        v0.2.1
)
FetchContent_MakeAvailable(stx)
target_link_libraries(<target> PRIVATE lbyte::stx)

Fetch from git: Create a package script at packages/l/lbyte.stx/xmake.lua:

package("lbyte.stx")
    set_kind("library", {headeronly = true})
    set_homepage("https://github.com/zethcxx/stx")
    set_description("C++23 Systems Toolbelt")

    add_urls("https://github.com/zethcxx/stx.git")
    add_versions("main", "main")
    add_versions("v0.1.0", "v0.1.0")
    add_versions("v0.2.0", "v0.2.0")
    add_versions("v0.2.1", "v0.2.1")

    add_configs("use_modules",  { description = "Build C++ modules", default = false, type = "boolean" })

    on_load(function (package)
        package:add("includedirs", "include")
        if package:config("use_modules") then
            package:add("cxxmodules", "modules/stx/*.cppm")
        end
    end)

    on_install( function( package )
        local configs = {}
        local includedir = package:installdir("include")

        if package:config( "use_modules" ) then
            configs.use_modules = true
        end

        import("package.tools.xmake").install( package, configs, { includedirs = includedir })
    end)

    on_test(function (package)
        assert(package:check_cxxsnippets({test = [[
            #include <lbyte/stx/core.hpp>
            using namespace lbyte;

            int main(){ return stx::u32{}; }
        ]]}, { configs = { languages = "cxx23" } }))
    end)
package_end()

Then in your project's xmake.lua:

add_requires("lbyte.stx")

target("myapp")
    set_languages("cxx23")
    add_packages("lbyte.stx")

Local copy (git clone / submodule):

add_subdirs("stx")

target("myapp")
    set_languages("cxx23")
    add_deps("stx")

No global state, no vtable, no hidden allocations, no registration. If you don't include a header, it doesn't exist. If you include it, the cost is predictable:

Offsets, addresses, and function signatures use distinct types — not raw integers. Impossible to accidentally pass an RVA where an offset is expected.

• mem::read always copies — no aliasing footguns
• mem::read_raw explicitly opts into direct dereference (requires alignment)
• Stream positioning requires an explicit direction (beg, cur, end)

All ct:: and range components are constexpr. Use them in static_assert, template args, or as NTTPs.

Low-level tooling, binary analysis, runtime patching, reverse engineering.