fosu 0.2.0__tar.gz

fosu-0.2.0/.clang-format

@@ -0,0 +1,3 @@
+BasedOnStyle: Chromium
+AllowShortLambdasOnASingleLine: Empty
+ColumnLimit: 90

fosu-0.2.0/.git-blame-ignore-revs

@@ -0,0 +1,2 @@
+# Apply the repository's clang-format style (#32).
+785a565f667a082ad8df18d8b5cb0ec0baf3d407

fosu-0.2.0/.github/workflows/format.yml

@@ -0,0 +1,24 @@
+name: Code quality
+
+on:
+  pull_request:
+  push:
+    branches: [master]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  format:
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          persist-credentials: false
+      - uses: actions/setup-python@v6
+        with:
+          python-version: '3.12'
+      - run: python -m pip install pre-commit==4.6.0
+      - name: Check formatting and Python types
+        run: pre-commit run --all-files --show-diff-on-failure

fosu-0.2.0/.github/workflows/native.yml

@@ -0,0 +1,120 @@
+name: Native parser checks
+
+on:
+  pull_request:
+  push:
+    branches: [master]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  native:
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          persist-credentials: false
+      - run: cmake -S . -B build/native -G Ninja -DCMAKE_CXX_COMPILER=g++ -DCMAKE_C_COMPILER=gcc
+      - run: cmake --build build/native --target check bench-build references -j"$(nproc)"
+      - run: python3 tests/test_build.py build/native
+      - name: Exercise benchmark and corpus tools
+        run: |
+          python3 -m unittest discover -s bench/comparison -p 'test_*.py'
+          build/native/generate_corpus build/smoke-corpus
+          build/native/library_compare build/smoke-corpus 2 build/native/library_native.so build/native/library_native.so > build/library.csv
+          python3 bench/summarize.py build/library.csv
+          build/native/validate_corpus build/smoke-corpus build/native/numeric_oracle.so
+
+  native-configurations:
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          persist-credentials: false
+      - name: Check scalar and debug builds
+        run: |
+          cmake -S . -B build/scalar -G Ninja -DFOSU_ISA=scalar -DCMAKE_CXX_COMPILER=g++
+          cmake --build build/scalar --target check -j"$(nproc)"
+          cmake -S . -B build/debug -G Ninja -DCMAKE_BUILD_TYPE=Debug -DCMAKE_CXX_COMPILER=g++
+          cmake --build build/debug --target test-binaries -j"$(nproc)"
+          ctest --test-dir build/debug -L parser --output-on-failure
+
+  native-emulation:
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          persist-credentials: false
+      - name: Check dispatch without AVX
+        run: |
+          sudo apt-get update -qq
+          sudo apt-get install -y qemu-user g++-aarch64-linux-gnu
+          cmake -S . -B build/native -G Ninja -DCMAKE_CXX_COMPILER=g++ -DCMAKE_C_COMPILER=gcc
+          cmake --build build/native --target test_dispatch -j"$(nproc)"
+          qemu-x86_64 -cpu Nehalem build/native/test_dispatch auto
+          qemu-x86_64 -cpu Nehalem build/native/test_dispatch avx2
+      - name: Check Linux AArch64 dispatch and parsing
+        run: |
+          cmake -S . -B build/arm64 -G Ninja \
+            -DCMAKE_SYSTEM_NAME=Linux -DCMAKE_SYSTEM_PROCESSOR=aarch64 \
+            -DCMAKE_C_COMPILER=aarch64-linux-gnu-gcc \
+            -DCMAKE_CXX_COMPILER=aarch64-linux-gnu-g++ \
+            '-DCMAKE_CROSSCOMPILING_EMULATOR=qemu-aarch64;-L;/usr/aarch64-linux-gnu'
+          cmake --build build/arm64 --target test-binaries -j"$(nproc)"
+          ctest --test-dir build/arm64 --output-on-failure -R '^(numeric|sections|hitobject_fields|storage|hardening|binary_hardening|dispatch_.*)$'
+
+  native-sanitizers:
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          persist-credentials: false
+      - name: Sanitizers and fuzzing
+        run: |
+          cmake -S . -B build/sanitize -G Ninja -DFOSU_SANITIZE=ON -DCMAKE_CXX_COMPILER=clang++
+          cmake --build build/sanitize --target check fuzz-smoke -j"$(nproc)"
+
+  native-macos:
+    runs-on: macos-26
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          persist-credentials: false
+      - run: cmake -S . -B build/native -G Ninja
+      - run: cmake --build build/native --target check bench-build references -j3
+      - run: python3 tests/test_build.py build/native
+      - run: cmake -S . -B build/sanitize -G Ninja -DFOSU_SANITIZE=ON
+      - run: cmake --build build/sanitize --target check -j3
+
+  native-windows:
+    runs-on: windows-2025
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          persist-credentials: false
+      - run: cmake -S . -B build/native -G "Visual Studio 18 2026" -A x64
+      - run: cmake --build build/native --config Release --target check
+      - run: python tests/test_build.py build/native
+
+  official-acceptance:
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          persist-credentials: false
+      - uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: 8.0.x
+      - uses: actions/setup-python@v6
+        with:
+          python-version: '3.12'
+      - run: python -m pip install build
+      - run: python -m build --sdist --outdir dist
+      - run: python -m pip install dist/*.tar.gz
+      - run: sh tests/reference/official/build.sh
+      - run: python tests/test_official.py
+      - run: FOSU_BACKEND=scalar python tests/test_official.py
+      - run: python tests/test_official_values.py --corpus tests/fixtures/official --report /tmp/official-values.json
+      - run: FOSU_BACKEND=scalar python tests/test_official_values.py --corpus tests/fixtures/official --report /tmp/official-values-scalar.json

fosu-0.2.0/.github/workflows/python-wheels.yml

@@ -0,0 +1,137 @@
+name: Python wheels
+
+on:
+  pull_request:
+  push:
+    branches: [master]
+  release:
+    types: [published]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  wheels:
+    name: Wheel / ${{ matrix.platform }}
+    runs-on: ${{ matrix.runner }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - runner: ubuntu-24.04
+            platform: linux-x86_64
+          - runner: ubuntu-24.04-arm
+            platform: linux-aarch64
+          - runner: macos-26
+            platform: macos-arm64
+          - runner: macos-26-intel
+            platform: macos-x86_64
+          - runner: windows-2025
+            platform: windows-x86_64
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          persist-credentials: false
+      - uses: pypa/cibuildwheel@v4.2.1
+        env:
+          CIBW_ARCHS: native
+      - uses: actions/upload-artifact@v4
+        with:
+          name: fosu-wheel-${{ matrix.platform }}
+          path: wheelhouse/*.whl
+
+  installed:
+    name: Installed / ${{ matrix.platform }} / Python ${{ matrix.python }}
+    needs: wheels
+    runs-on: ${{ matrix.runner }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - runner: ubuntu-24.04
+            platform: linux-x86_64
+            python: '3.14'
+          - runner: ubuntu-24.04-arm
+            platform: linux-aarch64
+            python: '3.14'
+          - runner: macos-26
+            platform: macos-arm64
+            python: '3.14'
+          - runner: macos-26-intel
+            platform: macos-x86_64
+            python: '3.14'
+          - runner: windows-2025
+            platform: windows-x86_64
+            python: '3.14'
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          persist-credentials: false
+      - uses: actions/setup-python@v6
+        with:
+          python-version: ${{ matrix.python }}
+      - uses: actions/download-artifact@v4
+        with:
+          name: fosu-wheel-${{ matrix.platform }}
+          path: wheelhouse
+      - run: python -m pip install pytest mypy==2.3.1
+      - run: python -m pip install --no-index --find-links wheelhouse fosu
+      - run: python -m pytest tests/test_python.py
+      - run: python -m pytest tests/test_python.py
+        env:
+          FOSU_BACKEND: scalar
+      - run: python tests/test_binary_hardening.py
+
+  source-install:
+    name: Source install / Unix Makefiles
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          persist-credentials: false
+      - uses: actions/setup-python@v6
+        with:
+          python-version: '3.12'
+      - run: CMAKE_GENERATOR="Unix Makefiles" python -m pip install '.[test]'
+      - run: python -m pytest tests/test_python.py
+
+  sdist:
+    name: Source distribution
+    if: github.event_name == 'release'
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          persist-credentials: false
+      - uses: actions/setup-python@v6
+        with:
+          python-version: '3.14'
+      - run: python -m pip install build
+      - run: python -m build --sdist
+      - uses: actions/upload-artifact@v4
+        with:
+          name: fosu-sdist
+          path: dist/*.tar.gz
+
+  publish:
+    name: Publish release artifacts
+    if: github.event_name == 'release'
+    needs: [wheels, sdist]
+    runs-on: ubuntu-24.04
+    environment:
+      name: pypi
+      url: https://pypi.org/p/fosu
+    permissions:
+      contents: write
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          pattern: fosu-*
+          path: dist
+          merge-multiple: true
+      - run: gh release upload "${{ github.event.release.tag_name }}" dist/* --clobber --repo "$GITHUB_REPOSITORY"
+        env:
+          GH_TOKEN: ${{ github.token }}
+      - uses: pypa/gh-action-pypi-publish@release/v1

fosu-0.2.0/.gitignore

@@ -0,0 +1,12 @@
+.vscode/
+build/
+__pycache__/
+dist/
+*.egg-info/
+python/fosu/*.so
+python/fosu/*.dylib
+.pytest_cache/
+.mypy_cache/
+tests/reference/official/obj/
+tests/reference/official/bin/
+*.osu

fosu-0.2.0/.pre-commit-config.yaml

@@ -0,0 +1,24 @@
+repos:
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.16.6
+    hooks:
+      - id: ruff-check
+        args: [--config=pyproject.toml]
+        types_or: [python, pyi]
+      - id: ruff-format
+        args: [--config=pyproject.toml]
+        types_or: [python, pyi]
+  - repo: https://github.com/pre-commit/mirrors-clang-format
+    rev: v22.1.8
+    hooks:
+      - id: clang-format
+        types_or: [c, c++]
+        exclude: ^src/fosu/engine/third_party/fast_float\.h$
+  - repo: https://github.com/pre-commit/mirrors-mypy
+    rev: v2.3.1
+    hooks:
+      - id: mypy
+        args: [--config-file=pyproject.toml]
+        pass_filenames: false
+        types: [file]
+        files: ^(python/|tests/typing/|pyproject\.toml$|\.pre-commit-config\.yaml$)

fosu-0.2.0/AGENTS.md

@@ -0,0 +1,60 @@
+# Working on FOSU
+
+FOSU is in active, pre-release development with no production consumers.
+Interfaces may break. Optimize for useful code changes, not release-level polish.
+
+## Design and scope
+
+- Prefer readable, domain-accurate code, explicit ownership, and simple inputs
+  and results. Favor returning parsed values over mutable output parameters
+  where practical. Near-zero-cost abstractions should earn their complexity.
+- Change interfaces directly and update affected callers. Do not preserve aliases,
+  old formats, or speculative extension points unless explicitly requested.
+- Before editing, define the question and briefly trace the affected implementation,
+  callers, tests, and build boundaries. Do not turn focused work into a repo audit.
+- Preserve unrelated user changes. Do not add optional refinements while preparing
+  a passing change for merge; mention worthwhile follow-ups separately.
+
+## Verification proportional to the change
+
+- During iteration, build the affected target and run focused tests.
+- For internal parsing refactors, start with focused tests and the small all-mode
+  compatibility sample. Use broader official-parser/full-corpus checks for
+  meaningful acceptance, normalization, or representation changes once settled.
+- Keep correctness tests, strict Python typing, and memory-safety checks. Arena,
+  lifetime, bounds, and SIMD-load changes warrant relevant sanitizer checks.
+- Test the relevant platform first. Reserve cross-platform and installed-package
+  checks for settled candidates whose changed boundaries warrant them, or releases.
+- Docs-only changes need a content/link review, not builds, wheel installs,
+  compatibility sweeps, or performance measurements.
+- Reuse still-valid results. Re-run affected checks after fixes and report skipped
+  checks honestly; a sample is not proof of full compatibility.
+
+## Performance experiments
+
+- Screen one hypothesis cheaply on the relevant CPU with the small representative
+  all-mode performance corpus. Keep pathological cases in correctness tests.
+- Reject clear losers early. Use reversed-order runs, confirmation samples, the
+  second machine, and combinations only for promising candidates.
+- Compare identical API boundaries, outputs, corpora, build settings, and hosts.
+  Separate native parsing from eager Python conversion. Build before timing and
+  avoid competing builds, tests, or benchmarks on the measurement host.
+- Do not chase tiny uncertain wins indefinitely, especially if they add complexity.
+  Report uncertainty; cleaner code can be worth more than a marginal speedup.
+- Preserve competitor benchmarks. Rerun and publish comparisons at meaningful
+  milestones or when requested, not after every internal optimization.
+- Keep experimental binaries and raw reports in ignored build directories.
+  Rejected experiments need a concise finding, not permanent tooling or documents.
+
+## Documentation and tooling budget
+
+- Maintain a short README, working usage examples, and important contracts and
+  limitations. Update docs only when needed to avoid misleading users or broken
+  instructions; do not synchronize implementation narratives after every refactor.
+- Do not refresh public timing tables, expand API field inventories, or create
+  architecture/history documents as routine completion work. Clearly label stale
+  measurements; do not present them as current.
+- Put experiment history and migration details in PR descriptions, not maintained
+  docs. Prefer deleting redundant prose to repeatedly updating it.
+- Reuse existing tooling. Add automation only for demonstrated recurring friction;
+  prefer one small entry point over a framework or overlapping scripts.

fosu-0.2.0/CMakeLists.txt

@@ -0,0 +1,270 @@
+cmake_minimum_required(VERSION 3.26)
+# Native release builds retain assertions; tests also explicitly enable them.
+# Python extension targets define NDEBUG independently.
+if(NOT CMAKE_HOST_WIN32)
+  set(CMAKE_CXX_FLAGS_RELEASE "-O3" CACHE STRING "Release C++ flags")
+  set(CMAKE_C_FLAGS_RELEASE "-O2" CACHE STRING "Release C flags")
+  set(CMAKE_CXX_FLAGS_DEBUG "-O0 -g" CACHE STRING "Debug C++ flags")
+endif()
+
+project(fosu VERSION 0.2.0 LANGUAGES C CXX)
+include(CTest)
+include(GNUInstallDirs)
+
+if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
+  set(CMAKE_BUILD_TYPE Release CACHE STRING "Build type" FORCE)
+endif()
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
+set(FOSU_ISA auto CACHE STRING "Native targets: auto, scalar, avx2, neon")
+set_property(CACHE FOSU_ISA PROPERTY STRINGS auto scalar avx2 neon)
+option(FOSU_SANITIZE "Enable address, undefined and float-cast sanitizers" OFF)
+option(FOSU_ARENA_TELEMETRY "Instrument arena use in the profiling driver" OFF)
+set(_python OFF)
+if(SKBUILD)
+  set(_python ON)
+endif()
+option(FOSU_BUILD_PYTHON "Build the CPython stable-ABI extension" ${_python})
+set(_bundled OFF)
+if(CMAKE_SYSTEM_NAME STREQUAL "Linux" AND NOT FOSU_SANITIZE AND NOT SKBUILD)
+  set(_bundled ON)
+endif()
+if(DEFINED ENV{FOSU_BUNDLE_RUNTIME})
+  set(_bundled "$ENV{FOSU_BUNDLE_RUNTIME}")
+elseif(DEFINED ENV{CIBUILDWHEEL} AND "$ENV{CIBUILDWHEEL}" STREQUAL "1")
+  set(_bundled ON)
+endif()
+option(FOSU_BUNDLE_RUNTIME "Bundle the Linux C++ runtime" ${_bundled})
+set(_processor "${CMAKE_SYSTEM_PROCESSOR}")
+if(APPLE AND CMAKE_OSX_ARCHITECTURES)
+  set(_processor "${CMAKE_OSX_ARCHITECTURES}")
+endif()
+set(_x86 OFF)
+if(_processor MATCHES "^(x86_64|AMD64|amd64)$")
+  set(_x86 ON)
+endif()
+set(_arm64 OFF)
+if(_processor MATCHES "^(aarch64|arm64|ARM64)$")
+  set(_arm64 ON)
+endif()
+# Header-only tools select instructions at compile time; compiled products dispatch.
+set(_header_isa "${FOSU_ISA}")
+if(FOSU_ISA STREQUAL "auto")
+  if(_x86)
+    set(_header_isa avx2)
+  elseif(_arm64)
+    set(_header_isa neon)
+  else()
+    set(_header_isa scalar)
+  endif()
+endif()
+if(NOT FOSU_ISA MATCHES "^(auto|scalar|avx2|neon)$")
+  message(FATAL_ERROR "FOSU_ISA must be auto, scalar, avx2 or neon")
+endif()
+if(FOSU_ISA STREQUAL "avx2" AND NOT _x86)
+  message(FATAL_ERROR "AVX2 requires an x86-64 target; use a cross-compilation toolchain")
+endif()
+if(FOSU_ISA STREQUAL "neon" AND NOT _arm64)
+  message(FATAL_ERROR "NEON requires an AArch64 target")
+endif()
+if(NOT CMAKE_SYSTEM_NAME MATCHES "^(Linux|Darwin|Windows)$")
+  message(FATAL_ERROR "fosu currently supports Linux, macOS and Windows")
+endif()
+
+add_library(fosu_headers INTERFACE)
+add_library(fosu::headers ALIAS fosu_headers)
+set_target_properties(fosu_headers PROPERTIES EXPORT_NAME headers)
+target_include_directories(fosu_headers INTERFACE $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/src> $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>)
+target_compile_features(fosu_headers INTERFACE cxx_std_20)
+target_sources(fosu_headers INTERFACE FILE_SET HEADERS BASE_DIRS src FILES
+  src/fosu/arena.h
+  src/fosu/beatmap.h
+  src/fosu/beatmap_header.h
+  src/fosu/compiler.h
+  src/fosu/enums.h
+  src/fosu/io.h
+  src/fosu/legacy_rules.h
+  src/fosu/mods.h
+  src/fosu/slider_geometry.h
+  src/fosu/slider_path.h
+  src/fosu/slider_event.h
+  src/fosu/slider_events.h
+  src/fosu/stacking.h
+  src/fosu/slider_timing.h
+  src/fosu/os.h
+  src/fosu/parse_options.h
+  src/fosu/parser.h
+  src/fosu/result.h
+  src/fosu/runtime.h
+  src/fosu/engine/hit_objects/common_fields.h
+  src/fosu/engine/hit_objects/object_types.h
+  src/fosu/engine/hit_objects/samples.h
+  src/fosu/engine/hit_objects/slider.h
+  src/fosu/engine/parse_document.h
+  src/fosu/engine/parsing/field_values.h
+  src/fosu/engine/parsing/key_value.h
+  src/fosu/engine/parsing/lines.h
+  src/fosu/engine/parsing/numbers.h
+  src/fosu/engine/parsing/sample_sets.h
+  src/fosu/engine/parsing/section_names.h
+  src/fosu/engine/parsing/string_lookup.h
+  src/fosu/engine/parsing_engine.h
+  src/fosu/engine/primitives/byte_scan.h
+  src/fosu/engine/primitives/digit_groups.h
+  src/fosu/engine/primitives/packed_digits.h
+  src/fosu/engine/primitives/vector_ops.h
+  src/fosu/engine/sections/colours.h
+  src/fosu/engine/sections/difficulty.h
+  src/fosu/engine/sections/editor.h
+  src/fosu/engine/sections/events.h
+  src/fosu/engine/sections/general.h
+  src/fosu/engine/sections/hit_objects.h
+  src/fosu/engine/sections/metadata.h
+  src/fosu/engine/sections/timing_points.h
+  src/fosu/engine/third_party/fast_float.h
+  src/fosu/engine/timing_points/beat_length.h
+  src/fosu/engine/timing_points/point.h
+)
+
+function(fosu_profile target)
+  if(NOT MSVC)
+    target_compile_definitions(${target} PRIVATE $<$<CONFIG:Debug>:_GLIBCXX_DEBUG>)
+  endif()
+  if(FOSU_SANITIZE)
+    if(MSVC)
+      message(FATAL_ERROR "FOSU_SANITIZE requires Clang or GCC")
+    endif()
+    target_compile_options(${target} PRIVATE -O1 -g -fsanitize=address,undefined,float-cast-overflow -fno-sanitize-recover=all)
+    target_link_options(${target} PRIVATE -fsanitize=address,undefined,float-cast-overflow)
+  endif()
+endfunction()
+
+# Product policy stays here; the header-only target imposes no tuning flags.
+include(cmake/Hardening.cmake)
+function(fosu_configure target isa product)
+  target_link_libraries(${target} PRIVATE fosu_headers)
+  if(MSVC)
+    target_compile_options(${target} PRIVATE /W4)
+  else()
+    target_compile_options(${target} PRIVATE -Wall -Wextra)
+  endif()
+  if(isa STREQUAL "scalar")
+    target_compile_definitions(${target} PRIVATE FOSU_DISABLE_SIMD)
+  elseif(isa STREQUAL "avx2")
+    target_compile_definitions(${target} PRIVATE FOSU_COMPILE_AVX2)
+  endif()
+  if(_x86 AND isa STREQUAL "scalar" AND NOT MSVC)
+    target_compile_options(${target} PRIVATE -march=x86-64)
+  endif()
+  if(product STREQUAL "python")
+    if(MSVC)
+      target_compile_options(${target} PRIVATE /O2)
+    else()
+      target_compile_options(${target} PRIVATE -O3 -g0)
+    endif()
+    target_compile_definitions(${target} PRIVATE NDEBUG)
+    if(isa STREQUAL "avx2")
+      if(MSVC)
+        target_compile_options(${target} PRIVATE /arch:AVX2)
+      else()
+        target_compile_options(${target} PRIVATE -mavx2 -mbmi -mbmi2)
+      endif()
+    endif()
+  elseif(isa STREQUAL "avx2")
+    if(MSVC)
+      target_compile_options(${target} PRIVATE /arch:AVX2)
+    else()
+      target_compile_options(${target} PRIVATE -march=x86-64-v3)
+    endif()
+  endif()
+  if(WIN32 AND product STREQUAL "native")
+    target_compile_options(${target} PRIVATE $<IF:$<CXX_COMPILER_ID:MSVC>,/UNDEBUG,-UNDEBUG>)
+  endif()
+  if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
+    if(isa STREQUAL "avx2" OR product STREQUAL "python")
+      target_compile_options(${target} PRIVATE -fno-plt)
+    endif()
+  endif()
+  fosu_harden(${target})
+  fosu_profile(${target})
+endfunction()
+function(fosu_runtime target)
+  if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
+    if(FOSU_BUNDLE_RUNTIME)
+      target_link_options(${target} PRIVATE -static-libstdc++ -static-libgcc)
+    endif()
+    target_link_options(${target} PRIVATE -Wl,--exclude-libs,ALL)
+  endif()
+endfunction()
+function(fosu_executable target source)
+  add_executable(${target} EXCLUDE_FROM_ALL ${source})
+  fosu_configure(${target} "${_header_isa}" native)
+endfunction()
+
+# The core owns Parser lifetime and storage. ISA libraries execute the shared parser.
+function(fosu_dispatch target product)
+  fosu_configure(${target} scalar "${product}")
+  target_sources(${target} PRIVATE src/fosu/engine/runtime/loader.cc)
+  target_link_libraries(${target} PRIVATE ${CMAKE_DL_LIBS})
+  target_compile_definitions(${target} PRIVATE
+    FOSU_DEFAULT_BACKEND="${FOSU_ISA}"
+    FOSU_ENGINE_SUFFIX="${CMAKE_SHARED_LIBRARY_SUFFIX}"
+    FOSU_MANAGED_ARENA_CLEANUP)
+  set_target_properties(${target} PROPERTIES
+    CXX_VISIBILITY_PRESET hidden VISIBILITY_INLINES_HIDDEN ON)
+  set(variant "")
+  if(_x86 AND NOT FOSU_ISA STREQUAL "scalar")
+    set(variant avx2)
+    target_compile_definitions(${target} PRIVATE FOSU_HAS_AVX2)
+  elseif(_arm64 AND NOT FOSU_ISA STREQUAL "scalar")
+    set(variant neon)
+    target_compile_definitions(${target} PRIVATE FOSU_HAS_NEON)
+  endif()
+  if(variant)
+    set(engine fosu_${product}_${variant})
+    if(NOT TARGET ${engine})
+      add_library(${engine} SHARED src/fosu/engine/runtime/entry.cc)
+      fosu_configure(${engine} "${variant}" "${product}")
+      fosu_runtime(${engine})
+      set_target_properties(${engine} PROPERTIES
+        OUTPUT_NAME fosu_engine_${variant}
+        CXX_VISIBILITY_PRESET hidden VISIBILITY_INLINES_HIDDEN ON)
+      if(product STREQUAL "python")
+        set_target_properties(${engine} PROPERTIES
+          LIBRARY_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/python-engine")
+        install(TARGETS ${engine} LIBRARY DESTINATION fosu RUNTIME DESTINATION fosu)
+      else()
+        install(TARGETS ${engine}
+          LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+          RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
+      endif()
+    endif()
+    add_dependencies(${target} ${engine})
+  endif()
+endfunction()
+
+if(NOT SKBUILD)
+  add_library(fosu SHARED src/fosu/runtime.cc)
+  add_library(fosu::fosu ALIAS fosu)
+  target_link_libraries(fosu PUBLIC fosu_headers)
+  target_compile_definitions(fosu PRIVATE FOSU_BUILDING_RUNTIME)
+  fosu_dispatch(fosu native)
+  fosu_runtime(fosu)
+  set_target_properties(fosu PROPERTIES CXX_VISIBILITY_PRESET hidden)
+  target_include_directories(fosu PUBLIC $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/src> $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>)
+  install(TARGETS fosu fosu_headers EXPORT fosuTargets
+    FILE_SET HEADERS DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+  install(FILES src/fosu/engine/third_party/fast_float.md DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/fosu/engine/third_party)
+  install(EXPORT fosuTargets NAMESPACE fosu:: DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/fosu)
+  include(CMakePackageConfigHelpers)
+  configure_package_config_file(cmake/fosuConfig.cmake.in ${CMAKE_CURRENT_BINARY_DIR}/fosuConfig.cmake INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/fosu)
+  write_basic_package_version_file(${CMAKE_CURRENT_BINARY_DIR}/fosuConfigVersion.cmake COMPATIBILITY SameMajorVersion)
+  install(FILES ${CMAKE_CURRENT_BINARY_DIR}/fosuConfig.cmake ${CMAKE_CURRENT_BINARY_DIR}/fosuConfigVersion.cmake DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/fosu)
+  include(cmake/Development.cmake)
+endif()
+if(FOSU_BUILD_PYTHON)
+  include(cmake/Python.cmake)
+endif()