Fix deprecation warnings not silenced.

* vendor-fetch lists available libraries

from `github.com/c3lang/vendor` when no library is specified.

* add release notes

.clang-format

@@ -0,0 +1,15 @@
+IndentWidth: 4
+UseCRLF: false
+IndentCaseLabels: true
+UseTab: ForIndentation
+TabWidth: 4
+BreakBeforeBraces: Allman
+AllowShortBlocksOnASingleLine: Empty
+AllowShortIfStatementsOnASingleLine: WithoutElse
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeCaseColon: false
+SpaceBeforeParens: ControlStatementsExceptControlMacros
+SpacesInCStyleCastParentheses: false
+SpacesInConditionalStatement: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false

.clang-tidy

@@ -1,21 +1,7 @@
 ---
 # Configure clang-tidy for this project.
 
-IndentWidth: 4
-UseCRLF: false
-IndentCaseLabels: true
-UseTab: UT_ForIndentation
-TabWidth: 4
-BreakBeforeBraces: Allman
-AllowShortBlocksOnASingleLine: SBS_Empty
-AllowShortIfStatementsOnASingleLine: SIS_WithoutElse
-SpaceBeforeAssignmentOperators: true
-SpaceBeforeCaseColon: false
-SpaceBeforeParens: SBPO_ControlStatementsExceptControlMacros
-SpacesInCStyleCastParentheses: false
-SpacesInConditionalStatement: false
-SpacesInParentheses: false
-SpacesInSquareBrackets: false
+
 
 # Disabled:
 #  -google-readability-namespace-comments the *_CLIENT_NS is a macro, and
@@ -40,17 +26,19 @@ Checks: >
 
 # Turn all the warnings from the checks above into errors.
 WarningsAsErrors: "*"
-
 CheckOptions:
-  - { key: readability-function-cognitive-complexity.Threshold,    value: 100 }
-  - { key: readability-identifier-naming.StructCase,             value: CamelCase  }
-  - { key: readability-identifier-naming.FunctionCase,           value: lower_case  }
-  - { key: readability-identifier-naming.VariableCase,           value: lower_case }
-  - { key: readability-identifier-naming.MacroDefinitionCase,    value: UPPER_CASE }
-  - { key: readability-identifier-naming.EnumConstantCase,         value: UPPER_CASE }
-  - { key: readability-identifier-naming.ConstexprVariableCase,    value: CamelCase }
-  - { key: readability-identifier-naming.ConstexprVariablePrefix,  value: k         }
-  - { key: readability-identifier-naming.GlobalConstantCase,       value: CamelCase }
-  - { key: readability-identifier-naming.GlobalConstantPrefix,     value: k         }
-  - { key: readability-identifier-naming.StaticConstantCase,       value: CamelCase }
-  - { key: readability-identifier-naming.StaticConstantPrefix,     value: k         }
+  - { key: readability-function-cognitive-complexity.Threshold,        value: 100 }
+  - { key: readability-identifier-naming.StructCase,                   value: CamelCase  }
+  - { key: readability-identifier-naming.FunctionCase,                 value: lower_case  }
+  - { key: readability-identifier-naming.VariableCase,                 value: lower_case }
+  - { key: readability-identifier-naming.MacroDefinitionCase,          value: UPPER_CASE }
+  - { key: readability-identifier-naming.EnumConstantCase,             value: UPPER_CASE }
+  - { key: readability-identifier-naming.ConstexprVariableCase,        value: CamelCase }
+  - { key: readability-identifier-naming.ConstexprVariablePrefix,      value: k         }
+  - { key: readability-identifier-naming.GlobalConstantCase,           value: CamelCase }
+  - { key: readability-identifier-naming.GlobalConstantPrefix,         value: k         }
+  - { key: readability-identifier-naming.StaticConstantCase,           value: CamelCase }
+  - { key: readability-identifier-naming.StaticConstantPrefix,         value: k         }
+  - { key: readability-identifier-naming.MinimumParameterNameLength,   value: 0 }
+
+MinimumParameterNameLength: 0

.editorconfig

@@ -0,0 +1,25 @@
+# EditorConfig is awesome: https://editorconfig.org
+
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+
+[CMakeLists.txt]
+indent_style = space
+indent_size = 4
+
+[*.{c,cc,h}]
+indent_style = tab
+
+[*.{c3}]
+indent_style = tab
+
+[*.{json,toml,yml,gyp}]
+indent_style = space
+indent_size = 2
+
+[*.{py,pyi}]
+indent_style = tab
+

.gitattributes

@@ -1,4 +1,2 @@
 $ cat .gitattributes
 * text=auto
-*.c3 linguist-language=C
-*.c3t linguist-language=C

.github/FUNDING.yml

@@ -0,0 +1,14 @@
+# These are supported funding model platforms
+
+github: [c3lang]
+patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: c3lang
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+otechie: # Replace with a single Otechie username
+lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry
+polar: # Replace with a single Polar username
+custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

.github/workflows/main.yml

@@ -2,202 +2,621 @@ name: CI
 
 on:
   push:
-    branches: [ master, dev, ci_testing ]
+    branches: [ master, dev, ci_testing, experiments ]
   pull_request:
-    branches: [ master ]
+    branches: [ master, dev ]
+  workflow_dispatch:
+
+env:
+  LLVM_RELEASE_VERSION: 21.x
+  LLVM_RELEASE_VERSION_LINUX_MUSL: 20
+  LLVM_RELEASE_VERSION_OPENBSD: 20
+  LLVM_RELEASE_VERSION_NETBSD: 19
+  LLVM_DEV_VERSION: 22
+  # CACHE_INVALIDATION_SEED: '%Y-%m-%d' # Daily
+  CACHE_INVALIDATION_SEED: '%G-%V-1'   # Weekly
 
 jobs:
 
   build-msvc:
     runs-on: windows-latest
+    timeout-minutes: 30
     strategy:
-      # Don't abort runners if a single one fails
       fail-fast: false
       matrix:
         build_type: [ Release, Debug ]
-
     defaults:
       run:
         shell: cmd
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v6
+      - uses: actions/cache@v5
+        with:
+          path: build/_deps
+          key: ${{ runner.os }}-llvm-${{ env.LLVM_RELEASE_VERSION }}-${{ matrix.build_type }}-${{ hashFiles('CMakeLists.txt', '.github/workflows/main.yml') }}
 
-      - name: CMake
+      # set up the environment for Ninja
+      - uses: ilammy/msvc-dev-cmd@v1
+        with:
+          arch: x64
+
+      - name: CMake Build
         run: |
-          cmake -B build -G "Visual Studio 17 2022" -A x64 -DCMAKE_BUILD_TYPE=${{ matrix.build_type }}
+          cmake -B build -G Ninja -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} -DC3_FETCH_LLVM=ON
           cmake --build build --config ${{ matrix.build_type }}
 
-      - name: Build testproject
-        run: |
-          cd resources/testproject
-          ..\..\build\${{ matrix.build_type }}\c3c.exe --debug-log run hello_world_win32
+      # We remove the GNU link tool so C3C picks up the MSVC link.exe
+      - name: Remove GNU Link
+        shell: bash
+        run: rm -f /usr/bin/link
 
-      - name: run compiler tests
-        run: |
-          cd test
-          python3.exe src/tester.py ..\build\${{ matrix.build_type }}\c3c.exe test_suite/
+      - name: Run Unified Tests
+        shell: bash
+        run: ./scripts/tools/ci_tests.sh "./build/c3c.exe"
+
+      - name: Cache MSVC SDK
+        id: cache-msvc-sdk
+        uses: actions/cache@v5
+        with:
+          path: msvc_sdk
+          key: msvc-sdk-${{ runner.os }}-${{ hashFiles('msvc_build_libraries.py') }}
+
+      - if: steps.cache-msvc-sdk.outputs.cache-hit != 'true'
+        run: py msvc_build_libraries.py --accept-license
+
+      - name: Bundle (Windows)
+        shell: bash
+        run: ./scripts/tools/package_build.sh "./build/c3c.exe" "c3-windows-${{ matrix.build_type }}" "zip"
+
+      - uses: actions/upload-artifact@v6
+        with:
+          name: c3-windows-${{ matrix.build_type }}
+          path: c3-windows-${{ matrix.build_type }}.zip
 
   build-msys2-mingw:
     runs-on: windows-latest
+    timeout-minutes: 30
     strategy:
-      # Don't abort runners if a single one fails
       fail-fast: false
       matrix:
-        build_type: [Release, Debug]
-
+        build_type: [Debug]
     defaults:
       run:
         shell: msys2 {0}
     steps:
-      - uses: actions/checkout@v3
-
+      - uses: actions/checkout@v6
       - uses: msys2/setup-msys2@v2
         with:
           msystem: MINGW64
-          update: true
-          install: git binutils mingw-w64-x86_64-ninja mingw-w64-x86_64-cmake mingw-w64-x86_64-toolchain mingw-w64-x86_64-python
-      - shell: msys2 {0}
+          update: false
+          cache: true
+          install: git binutils mingw-w64-x86_64-clang mingw-w64-x86_64-ninja mingw-w64-x86_64-cmake mingw-w64-x86_64-toolchain mingw-w64-x86_64-python mingw-w64-x86_64-llvm mingw-w64-x86_64-llvm-libs
+
+      - name: Install LLD
         run: |
-            pacman --noconfirm -U https://mirror.msys2.org/mingw/mingw64/mingw-w64-x86_64-llvm-13.0.1-2-any.pkg.tar.zst
-            pacman --noconfirm -U https://mirror.msys2.org/mingw/mingw64/mingw-w64-x86_64-lld-13.0.1-2-any.pkg.tar.zst
-      - name: CMake
+          echo "Server = https://mirror.msys2.org/mingw/mingw64" > /etc/pacman.d/mirrorlist.mingw64
+          for i in 1 2; do \
+            pacman -Sy --noconfirm --needed \
+              mingw-w64-x86_64-llvm \
+              mingw-w64-x86_64-llvm-libs \
+              mingw-w64-x86_64-lld \
+              mingw-w64-x86_64-clang && break || sleep 5; \
+          done
+
+      - name: CMake Build
         run: |
-          cmake -B build -G Ninja -DCMAKE_BUILD_TYPE=${{ matrix.build_type }}
+          cmake -B build -G Ninja -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} -DCMAKE_LINKER=lld -DC3_LINK_DYNAMIC=OFF -DLLVM_DIR=/mingw64/lib/cmake/llvm -DC3_LLD_DIR=/mingw64/lib/
           cmake --build build
-
-      - name: Build testproject
-        run: |
-          cd resources/testproject
-          ../../build/c3c run --debug-log
-
-      - name: run compiler tests
-        run: |
-          cd test
-          python3 src/tester.py ../build/c3c.exe test_suite/
-
+      - name: Run Unified Tests
+        run: ./scripts/tools/ci_tests.sh "./build/c3c"
 
   build-msys2-clang:
     runs-on: windows-latest
-    if: ${{ false }}
+    timeout-minutes: 30
     strategy:
-      # Don't abort runners if a single one fails
       fail-fast: false
       matrix:
-        build_type: [Release, Debug]
-
+        build_type: [Debug]
     defaults:
       run:
         shell: msys2 {0}
     steps:
-      - uses: actions/checkout@v3
-
+      - uses: actions/checkout@v6
       - uses: msys2/setup-msys2@v2
         with:
           msystem: CLANG64
           update: false
+          cache: true
           install: git binutils mingw-w64-clang-x86_64-cmake mingw-w64-clang-x86_64-toolchain mingw-w64-clang-x86_64-python
-
-      - name: CMake
+      - name: CMake Build
         run: |
           cmake -B build -G "MinGW Makefiles" -DCMAKE_BUILD_TYPE=${{ matrix.build_type }}
           cmake --build build
-      - name: Build testproject
-        run: |
-          cd resources/testproject
-          ../../build/c3c run --debug-log
-
-      - name: run compiler tests
-        run: |
-          cd test
-          python3 src/tester.py ../build/c3c.exe test_suite/
+      - name: Run Unified Tests
+        run: ./scripts/tools/ci_tests.sh "./build/c3c"
 
   build-linux:
     runs-on: ubuntu-latest
     strategy:
-      # Don't abort runners if a single one fails
       fail-fast: false
       matrix:
         build_type: [Release, Debug]
-        llvm_version: [12, 13, 14, 15]
-
     steps:
-      - uses: actions/checkout@v3
-      - name: Install common deps
+      - uses: actions/checkout@v6
+      - name: Get current date context
+        id: date
+        run: echo "date=$(date +'${{ env.CACHE_INVALIDATION_SEED }}')" >> $GITHUB_OUTPUT
+      - name: Cache APT archives
+        uses: actions/cache@v5
+        with:
+          path: apt-cache
+          key: apt-cache-${{ runner.os }}-${{ steps.date.outputs.date }}
+      - run: |
+          mkdir -p apt-cache/partial
+          for i in 1 2 3; do sudo apt-get update && break || sleep 2; done
+          for i in 1 2 3; do sudo apt-get install -y -o dir::cache::archives="$(pwd)/apt-cache" --fix-missing zlib1g zlib1g-dev python3 ninja-build curl libcurl4-openssl-dev opensbi qemu-system-misc u-boot-qemu gcc-riscv64-unknown-elf && break || sleep 2; done
+          sudo chown -R $USER:$USER apt-cache
+      - name: CMake Build
         run: |
-          sudo apt-get install zlib1g zlib1g-dev python3 ninja-build
+          cmake -B build -G Ninja -DCMAKE_BUILD_TYPE=${{matrix.build_type}} -DC3_FETCH_LLVM=ON
+          cmake --build build
+      - name: Run Unified Tests
+        run: ./scripts/tools/ci_tests.sh "./build/c3c"
 
-      - name: Install Clang ${{ matrix.llvm_version }}
+      - name: Embedded/QEMU Tests
         run: |
-          wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -
-          if [[ "${{matrix.llvm_version}}" < 15 ]]; then
-            sudo add-apt-repository "deb http://apt.llvm.org/focal/ llvm-toolchain-focal-${{matrix.llvm_version}} main"
-          else
-            sudo add-apt-repository "deb http://apt.llvm.org/focal/ llvm-toolchain-focal main"
-          fi
-          sudo apt-get update
-          sudo apt-get install -y clang-${{matrix.llvm_version}} llvm-${{matrix.llvm_version}} llvm-${{matrix.llvm_version}}-dev lld-${{matrix.llvm_version}} liblld-${{matrix.llvm_version}}-dev
+          # Added `opensbi qemu-system-misc u-boot-qemu gcc-riscv64-unknown-elf` to the apt-get install command above
+          cd resources/examples/embedded/riscv-qemu
+          make C3C_PATH=../../../../build/ run
 
-          if [[ "${{matrix.llvm_version}}" > 12 ]]; then
-            sudo apt-get install -y libmlir-${{matrix.llvm_version}} libmlir-${{matrix.llvm_version}}-dev mlir-${{matrix.llvm_version}}-tools
-          fi
-
-      - name: CMake
+      - name: Bundle & Upload (Linux)
         run: |
-          cmake -B build -G Ninja -DCMAKE_C_COMPILER=clang-${{matrix.llvm_version}} -DCMAKE_CXX_COMPILER=clang++-${{matrix.llvm_version}} -DC3_LLVM_VERSION=${{matrix.llvm_version}} -DCMAKE_BUILD_TYPE=${{ matrix.build_type }}
+          bash ./scripts/tools/package_build.sh "./build/c3c" "c3-linux-${{matrix.build_type}}" "tar"
+      - uses: actions/upload-artifact@v6
+        with:
+          name: c3-linux-${{matrix.build_type}}
+          path: c3-linux-${{matrix.build_type}}.tar.gz
+
+  build-linux-alpine:
+    runs-on: ubuntu-latest
+    container:
+      image: alpine:3.23
+    strategy:
+      fail-fast: false
+      matrix:
+        build_type: [Release, Debug]
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Get current date context
+        id: date
+        run: echo "date=$(date +'${{ env.CACHE_INVALIDATION_SEED }}')" >> $GITHUB_OUTPUT
+
+      #https://wiki.alpinelinux.org/wiki/Local_APK_cache
+      - name: Prepare real apk cache directory + symlink
+        run: |
+          mkdir -p /var/cache/apk
+          ln -sf /var/cache/apk /etc/apk/cache
+
+      - name: Cache APK downloaded packages (daily)
+        uses: actions/cache@v5
+        with:
+          path: /var/cache/apk
+          key: apk-pkgs-${{ runner.os }}-alpine-3.23-${{ steps.date.outputs.date }}
+          restore-keys: |
+            apk-pkgs-${{ runner.os }}-alpine-3.23-
+
+      - name: Install dependencies
+        run: |
+          V=${{env.LLVM_RELEASE_VERSION_LINUX_MUSL}}
+          for i in 1 2 3; do apk update && break || sleep 2; done
+          for i in 1 2 3; do \
+            apk add \
+              build-base bash git cmake ninja python3 linux-headers \
+              tar zstd \
+              zlib-dev curl-dev libffi-dev \
+              llvm${V}-dev \
+              llvm${V}-static \
+              llvm${V}-gtest \
+              clang${V}-dev \
+              clang${V}-static \
+              lld${V}-dev \
+              lld${V}-libs && break || sleep 2; \
+          done
+
+      - name: CMake Build
+        run: |
+          cmake -B build -G Ninja \
+            -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} \
+            -DC3_FETCH_LLVM=OFF \
+            -DLLVM_ENABLE_LIBXML2=OFF \
+            -DC3_LINK_DYNAMIC=ON
           cmake --build build
 
-      - name: Build testproject
-        run: |
-          cd resources/testproject
-          ../../build/c3c run --debug-log
-
-      - name: Build testproject direct linker
-        run: |
-          cd resources/testproject
-          ../../build/c3c run --debug-log --forcelinker
-
-      - name: run compiler tests
-        run: |
-          cd test
-          if [[ "${{matrix.llvm_version}}" < 15 ]]; then
-            python3 src/tester.py ../build/c3c test_suite/
-          else
-            python3 src/tester.py ../build/c3c test_suite2/
-          fi
+      - name: Run Unified Tests
+        run: ./scripts/tools/ci_tests.sh "./build/c3c"
+      - name: Bundle & Upload (Alpine)
+        run: bash ./scripts/tools/package_build.sh "./build/c3c" "c3-linux-musl-${{ matrix.build_type }}" "tar"
+      - uses: actions/upload-artifact@v6
+        with:
+          name: c3-linux-musl-${{ matrix.build_type }}
+          path: c3-linux-musl-${{ matrix.build_type }}.tar.gz
 
   build-mac:
     runs-on: macos-latest
     strategy:
-      # Don't abort runners if a single one fails
       fail-fast: false
       matrix:
         build_type: [Release, Debug]
-        llvm_version: [12, 13, 14]
     steps:
-      - uses: actions/checkout@v3
-      - name: Download LLVM
+      - uses: actions/checkout@v6
+      - name: CMake Build
         run: |
-          brew install llvm@${{ matrix.llvm_version }} botan ninja
-          echo "/usr/local/opt/llvm@${{ matrix.llvm_version }}/bin" >> $GITHUB_PATH
-          TMP_PATH=$(xcrun --show-sdk-path)/user/include
-          echo "CPATH=$TMP_PATH" >> $GITHUB_ENV
+          cmake -B build -G Ninja -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} -DC3_FETCH_LLVM=ON
+          cmake --build build
+      - name: Run Unified Tests
+        run: ./scripts/tools/ci_tests.sh "./build/c3c"
 
-      - name: CMake
+      - name: Build Lib (Mac)
         run: |
-          cmake -B build -G Ninja -DC3_LLVM_VERSION=${{matrix.llvm_version}} -DCMAKE_BUILD_TYPE=${{ matrix.build_type }}
+          cd resources/testproject
+          ../../build/c3c build hello_world_lib -vv --trust=full
+
+      - name: Bundle & Upload (Mac)
+        run: bash ./scripts/tools/package_build.sh "./build/c3c" "c3-macos-${{matrix.build_type}}" "zip"
+      - uses: actions/upload-artifact@v6
+        with:
+          name: c3-macos-${{matrix.build_type}}
+          path: c3-macos-${{matrix.build_type}}.zip
+
+  build-openbsd:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        build_type: [Debug]
+        version: ['7.8']
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Build, Test and Package in OpenBSD
+        uses: cross-platform-actions/action@master
+        with:
+          operating_system: openbsd
+          version: ${{ matrix.version }}
+          cpu_count: 4
+          memory: 6G
+          run: |
+            # Install dependencies
+            for i in 1 2 3; do
+              sudo pkg_add ninja cmake llvm%${{ env.LLVM_RELEASE_VERSION_OPENBSD }} bash && break || sleep 5
+            done
+
+            export MALLOC_OPTIONS=j
+
+            # Setup RAM Disk
+            sudo mkdir -p /mnt/ram
+            sudo mount_mfs -s $((2 * 1024 * 1024 * 2)) swap /mnt/ram
+            sudo chown -R $(id -u):$(id -g) /mnt/ram
+            export TMPDIR=/mnt/ram
+
+            # Copy source to RAM disk and switch to it
+            cp -rp . /mnt/ram/
+            cd /mnt/ram
+
+            # Build
+            cmake -B build -G Ninja -DCMAKE_BUILD_TYPE=${{ matrix.build_type }}
+            cmake --build build
+
+            # Run Unified Tests
+            chmod +x scripts/tools/ci_tests.sh
+            ulimit -d $(ulimit -Hd) || true
+            ./scripts/tools/ci_tests.sh "./build/c3c"
+
+            # Package
+            chmod +x scripts/tools/package_build.sh
+            ./scripts/tools/package_build.sh "./build/c3c" "c3-openbsd-${{matrix.build_type}}" "tar"
+
+            # Move results back to workspace for GitHub rsync/upload
+            mkdir -p "$GITHUB_WORKSPACE"/build
+            cp build/c3c "$GITHUB_WORKSPACE"/build/
+            cp *.tar.gz "$GITHUB_WORKSPACE"/
+
+      - uses: actions/upload-artifact@v6
+        with:
+          name: c3-openbsd-${{matrix.build_type}}
+          path: c3-openbsd-${{matrix.build_type}}.tar.gz
+
+  build-netbsd:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        build_type: [Debug]
+        version: ['10.1']
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Build, Test and Package in NetBSD
+        uses: cross-platform-actions/action@master
+        with:
+          operating_system: netbsd
+          version: ${{ matrix.version }}
+          cpu_count: 4
+          memory: 6G
+          run: |
+            # Install dependencies
+            export PATH="/usr/pkg/sbin:/usr/pkg/bin:$PATH"
+            export PKG_PATH="https://ftp.netbsd.org/pub/pkgsrc/packages/NetBSD/$(uname -m)/$(uname -r)/All/"
+
+            # Ensure pkgin is available and updated
+            sudo /usr/sbin/pkg_add -U pkgin || true
+
+            for i in 1 2 3; do
+              sudo pkgin -y update && \
+              sudo pkgin -y install cmake gcc14 ninja-build bash \
+                'llvm>=${{ env.LLVM_RELEASE_VERSION_NETBSD }}' \
+                'clang>=${{ env.LLVM_RELEASE_VERSION_NETBSD }}' \
+                'lld>=${{ env.LLVM_RELEASE_VERSION_NETBSD }}' && break || sleep 5
+            done
+
+            export CC=clang
+            export CXX=clang++
+
+            # Setup RAM Disk
+            sudo mkdir -p /mnt/ram
+            sudo mount_tmpfs -s 2G tmpfs /mnt/ram
+            sudo chown -R $(id -u):$(id -g) /mnt/ram
+            export TMPDIR=/mnt/ram
+
+            # Copy source to RAM disk and switch to it
+            cp -rp . /mnt/ram/
+            cd /mnt/ram
+
+            # Build
+            cmake -B build -G Ninja -DCMAKE_BUILD_TYPE=${{ matrix.build_type }}
+            cmake --build build
+
+            # Run Unified Tests
+            chmod +x scripts/tools/ci_tests.sh
+            ./scripts/tools/ci_tests.sh "./build/c3c"
+
+            # Package
+            chmod +x scripts/tools/package_build.sh
+            ./scripts/tools/package_build.sh "./build/c3c" "c3-netbsd-${{matrix.build_type}}" "tar"
+
+            # Move results back to workspace for GitHub rsync/upload
+            mkdir -p "$GITHUB_WORKSPACE"/build
+            cp build/c3c "$GITHUB_WORKSPACE"/build/
+            cp *.tar.gz "$GITHUB_WORKSPACE"/
+
+      - uses: actions/upload-artifact@v6
+        with:
+          name: c3-netbsd-${{matrix.build_type}}
+          path: c3-netbsd-${{matrix.build_type}}.tar.gz
+
+  build-with-docker:
+    name: LLVM ${{ matrix.llvm_version }} Compatibility
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        llvm_version: [17, 18, 19, 20]
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Build and cache Docker image
+        uses: docker/build-push-action@v6
+        with:
+          context: ./docker
+          build-args: |
+            LLVM_VERSION=${{ matrix.llvm_version }}
+            UBUNTU_VERSION=22.04
+            CMAKE_VERSION=3.20.0
+          tags: c3c-builder:latest
+          outputs: type=docker,dest=/tmp/c3c-builder.tar
+          cache-from: type=gha,scope=build-with-docker-${{ matrix.llvm_version }}
+          cache-to: type=gha,mode=max,scope=build-with-docker-${{ matrix.llvm_version }}
+        env:
+          DOCKER_BUILD_SUMMARY: false
+
+      - name: Load Docker image
+        run: docker load -i /tmp/c3c-builder.tar
+
+      - name: Build C3 in Docker
+        run: |
+          rm -rf build bin
+          mkdir -p build bin
+          chmod -R 777 build bin
+          docker run --rm \
+            -v "$(pwd):/home/c3c/source" \
+            -w /home/c3c/source \
+            c3c-builder:latest \
+            bash -c "git config --global --add safe.directory /home/c3c/source && \
+            cmake -S . -B build \
+                    -G Ninja \
+                    -DCMAKE_BUILD_TYPE=Debug \
+                    -DCMAKE_C_COMPILER=clang-${{ matrix.llvm_version }} \
+                    -DCMAKE_CXX_COMPILER=clang++-${{ matrix.llvm_version }} \
+                    -DCMAKE_LINKER=lld-${{ matrix.llvm_version }} \
+                    -DCMAKE_OBJCOPY=llvm-objcopy-${{ matrix.llvm_version }} \
+                    -DCMAKE_STRIP=llvm-strip-${{ matrix.llvm_version }} \
+                    -DCMAKE_DLLTOOL=llvm-dlltool-${{ matrix.llvm_version }} \
+                    -DC3_LLVM_VERSION=auto && \
+            cmake --build build && \
+            cp -r build/c3c build/lib bin"
+
+      - name: Run Unified Tests
+        run: |
+          docker run --rm \
+            -u 0 \
+            -v "$(pwd):/home/c3c/source" \
+            -w /home/c3c/source \
+            c3c-builder \
+            bash -c "./scripts/tools/ci_tests.sh ./bin/c3c"
+
+  build-nix:
+    runs-on: ubuntu-22.04
+    strategy:
+      fail-fast: false
+      matrix:
+        build_type: [ Debug ]
+        nixpkgs: [ Lock, Latest ]
+    steps:
+    - uses: actions/checkout@v6
+    - uses: cachix/install-nix-action@v31
+      with:
+        github_access_token: ${{ secrets.GITHUB_TOKEN }}
+    - name: Update flake
+      if: matrix.nixpkgs == 'Latest'
+      run: nix flake update
+    - name: CMake build and run Unified Tests
+      run: |
+        CHECK_NAME=".#c3c-checks"
+        if [[ ${{ matrix.build_type }} = "Debug" ]]; then CHECK_NAME=".#c3c-debug-checks"; fi
+        nix build -L "$CHECK_NAME"
+
+  build-android:
+    strategy:
+      fail-fast: false
+      matrix:
+        build_type: [ Release, Debug ]
+        architecture: [ aarch64, x86_64 ]
+        include:
+          - architecture: aarch64
+            runner: ubuntu-24.04-arm
+          - architecture: x86_64
+            runner: ubuntu-24.04
+    runs-on: ${{matrix.runner}}
+    container:
+      image: termux/termux-docker:${{matrix.architecture}}
+      volumes:
+        - /tmp/node20:/__e/node20
+        - /tmp/node24:/__e/node24
+    env:
+      TERMUX_MAIN_PACKAGE_FORMAT: debian
+      ANDROID_ROOT: /system
+      ANDROID_DATA: /data
+      PREFIX: /data/data/com.termux/files/usr
+      HOME: /data/data/com.termux/files/home
+      PATH: /data/data/com.termux/files/usr/bin
+      TMPDIR: /data/data/com.termux/files/usr/tmp
+      LANG: en_US.UTF-8
+      TZ: UTC
+    steps:
+      - name: prepare termux
+        run: |
+          ln -sf ${PREFIX}/etc/termux/mirrors/default ${PREFIX}/etc/termux/chosen_mirrors
+          for i in 1 2; do /entrypoint.sh pkg update && break || sleep 5; done
+          /entrypoint.sh bash -c "yes | pkg upgrade -y"
+          chmod -R o+x ${PREFIX}/bin
+          for i in 1 2; do /entrypoint.sh pkg install -y nodejs-lts tar git && break || sleep 5; done
+          # Symlink Termux node to where GHA expects it
+          mkdir -p /__e/node20/bin /__e/node24/bin || true
+          ln -sf ${PREFIX}/bin/node /__e/node20/bin/node || true
+          ln -sf ${PREFIX}/bin/node /__e/node24/bin/node || true
+
+      - name: Get current date context
+        id: date
+        run: echo "date=$(date +'${{ env.CACHE_INVALIDATION_SEED }}')" >> $GITHUB_OUTPUT
+
+      - name: Cache Termux packages
+        uses: actions/cache@v5
+        with:
+          path: /data/data/com.termux/cache/apt/archives/
+          key: termux-cache-${{ matrix.architecture }}-${{ steps.date.outputs.date }}
+
+      - uses: actions/checkout@v6
+
+      - name: fix permissions after checkout
+        run: chown -R 1000:1000 .
+
+      - name: setup
+        run: |
+          for i in 1 2; do \
+            /entrypoint.sh pkg install -y llvm binutils libgc build-essential cmake git libedit zlib clang make mlir llvm-tools libpolly python libllvm-static && break || sleep 10; \
+          done
+
+      - name: build
+        run: |
+          cmake -Bbuild -DCMAKE_BUILD_TYPE=${{matrix.build_type}}
           cmake --build build
 
-      - name: Build testproject
-        run: |
-          cd resources/testproject
-          ../../build/c3c run --debug-log
+      - name: Run Unified Tests
+        if: matrix.build_type == 'Debug'
+        run: ./scripts/tools/ci_tests.sh "./build/c3c" "android"
 
-      - name: Build testproject direct linker
+      - name: bundle_output
         run: |
-          cd resources/testproject
-          ../../build/c3c run --debug-log --forcelinker
+          chmod +x ./scripts/tools/package_build.sh
+          ./scripts/tools/package_build.sh "./build/c3c" "c3-android-${{matrix.architecture}}-${{matrix.build_type}}" "tar"
 
-      - name: run compiler tests
+      - name: upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: c3-android-${{matrix.architecture}}-${{matrix.build_type}}
+          path: c3-android-${{matrix.architecture}}-${{matrix.build_type}}.tar.gz
+
+  release:
+    runs-on: ubuntu-22.04
+    needs: [build-msvc, build-linux, build-mac, build-linux-alpine, build-openbsd, build-netbsd, build-android]
+    if: github.ref == 'refs/heads/master'
+    env:
+      GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+    steps:
+      - uses: actions/checkout@v6
+      - uses: actions/download-artifact@v4
+
+      - name: Prepare Assets
         run: |
-          cd test
-          python3 src/tester.py ../build/c3c test_suite/
+          # --- Release Assets ---
+          mv c3-windows-Release/c3-windows-Release.zip c3-windows.zip
+          mv c3-macos-Release/c3-macos-Release.zip c3-macos.zip
+
+          mv c3-linux-Release/c3-linux-Release.tar.gz c3-linux.tar.gz
+          mv c3-linux-musl-Release/c3-linux-musl-Release.tar.gz c3-linux-musl.tar.gz
+          mv c3-openbsd-Release/c3-openbsd-Release.tar.gz c3-openbsd.tar.gz || true
+          mv c3-netbsd-Release/c3-netbsd-Release.tar.gz c3-netbsd.tar.gz || true
+          mv c3-android-aarch64-Release/c3-android-aarch64-Release.tar.gz c3-android-aarch64.tar.gz
+          mv c3-android-x86_64-Release/c3-android-x86_64-Release.tar.gz c3-android-x86_64.tar.gz
+
+          # --- Debug Assets ---
+          mv c3-windows-Debug/c3-windows-Debug.zip c3-windows-debug.zip
+          mv c3-macos-Debug/c3-macos-Debug.zip c3-macos-debug.zip
+
+          mv c3-linux-Debug/c3-linux-Debug.tar.gz c3-linux-debug.tar.gz
+          mv c3-linux-musl-Debug/c3-linux-musl-Debug.tar.gz c3-linux-musl-debug.tar.gz
+          mv c3-openbsd-Debug/c3-openbsd-Debug.tar.gz c3-openbsd-debug.tar.gz || true
+          mv c3-netbsd-Debug/c3-netbsd-Debug.tar.gz c3-netbsd-debug.tar.gz || true
+          mv c3-android-aarch64-Debug/c3-android-aarch64-Debug.tar.gz c3-android-aarch64-debug.tar.gz
+          mv c3-android-x86_64-Debug/c3-android-x86_64-Debug.tar.gz c3-android-x86_64-debug.tar.gz
+
+      - run: gh release delete latest-prerelease-tag --cleanup-tag -y || true
+      - run: echo "RELEASE_NAME=latest-prerelease-$(date +'%Y%m%d-%H%M')" >> $GITHUB_ENV
+
+      - uses: softprops/action-gh-release@v2
+        with:
+          tag_name: latest-prerelease-tag
+          name: ${{ env.RELEASE_NAME }}
+          prerelease: true
+          files: |
+            c3-windows.zip
+            c3-macos.zip
+            c3-linux.tar.gz
+            c3-linux-musl.tar.gz
+            c3-openbsd.tar.gz
+            c3-netbsd.tar.gz
+            c3-android-aarch64.tar.gz
+            c3-android-x86_64.tar.gz
+            # --- Debug Artifacts ---
+            c3-windows-debug.zip
+            c3-macos-debug.zip
+            c3-linux-debug.tar.gz
+            c3-linux-musl-debug.tar.gz
+            c3-openbsd-debug.tar.gz
+            c3-netbsd-debug.tar.gz
+            c3-android-aarch64-debug.tar.gz
+            c3-android-x86_64-debug.tar.gz

.gitignore

@@ -1,5 +1,7 @@
 # Prerequisites
 *.d
+testrun
+benchmarkrun
 
 # Object files
 *.o
@@ -7,6 +9,8 @@
 *.obj
 *.elf
 *.ll
+*.wasm
+*.s
 
 # Linker output
 *.ilk
@@ -19,6 +23,7 @@
 
 # Libraries
 *.lib
+*.tlb
 *.a
 *.la
 *.lo
@@ -67,3 +72,35 @@ out/
 
 /cmake-build-debug/
 /cmake-build-release/
+
+CMakeFiles/cmake.check_cache
+CMakeCache.txt
+
+# etags(Emacs), ctags, gtags
+TAGS
+GPATH
+GRTAGS
+GTAGS
+tags
+
+# Clangd LSP files
+/.cache/
+/compile_commands.json
+
+# Nix
+result
+/.envrc
+/.direnv/
+
+# macOS
+.DS_Store
+
+# tests
+/test/tmp/*
+testrun
+test_suite_runner
+
+# patches, originals and rejects
+*.patch
+*.rej
+*.orig

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "tilde-backend"]
+	path = tilde-backend
+	url = https://github.com/c3lang/tilde-backend

CMakeLists.txt

@@ -1,26 +1,120 @@
-cmake_minimum_required(VERSION 3.15)
-project(c3c)
+cmake_minimum_required(VERSION 3.20)
+
+set(C3_LLVM_MIN_VERSION 17)
+set(C3_LLVM_MAX_VERSION 22)
+set(C3_LLVM_DEFAULT_VERSION 21)
+
+if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_CURRENT_BINARY_DIR)
+    message(FATAL_ERROR "In-tree build detected, please build in a separate directory")
+endif()
+
+# Grab the version
+file(READ "src/version.h" ver)
+if (NOT ${ver} MATCHES "COMPILER_VERSION \"([0-9]+.[0-9]+.[0-9]+)\"")
+    message(FATAL_ERROR "Compiler version could not be parsed from version.h")
+endif()
+
+# Set the project and version
+project(c3c VERSION ${CMAKE_MATCH_1} LANGUAGES C CXX)
+message("Configuring C3C ${CMAKE_PROJECT_VERSION} for ${CMAKE_SYSTEM_NAME}")
+
+# Helper functions
+function(c3_print_variables)
+    set(msg "")
+    foreach(var ${ARGN})
+        if(msg)
+            string(APPEND msg " ; ")
+        endif()
+        string(APPEND msg "${c3_print_prefix}${var}=\"${${var}}\"")
+    endforeach()
+    message(STATUS "${msg}")
+endfunction()
+
+# Avoid warning for FetchContent
+if (CMAKE_VERSION VERSION_GREATER_EQUAL "3.24.0")
+    cmake_policy(SET CMP0135 NEW)
+endif()
+
+if (NOT DEFINED CMAKE_INSTALL_LIBDIR)
+    if (WIN32)
+        set(CMAKE_INSTALL_LIBDIR "c:\\c3c\\lib")
+        set(CMAKE_INSTALL_BINDIR "c:\\c3c")
+    else ()
+        set(CMAKE_INSTALL_LIBDIR "/usr/local/lib/c3")
+        set(CMAKE_INSTALL_BINDIR "/usr/local/bin/c3c")
+    endif()
+endif ()
+
+# Enable fetching (for Windows)
 include(FetchContent)
 include(FeatureSummary)
 
 set(CMAKE_FIND_PACKAGE_SORT_ORDER NATURAL)
 set(CMAKE_FIND_PACKAGE_SORT_DIRECTION DEC)
+
+# We use C11 and C++17
 set(CMAKE_C_STANDARD 11)
 set(CMAKE_CXX_STANDARD 17)
 
-set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3")
-set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -gdwarf-3 -O3")
-set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -gdwarf-3")
-#set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O1 -fsanitize=undefined")
-#set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -O1 -fsanitize=undefined")
-#set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -gdwarf-3 -O3 -fsanitize=undefined")
-#set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -gdwarf-3 -fsanitize=undefined")
-#set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=undefined")
+if(MSVC)
+    message(STATUS "MSVC version ${MSVC_VERSION}")
+    add_compile_options(/utf-8)
 
-option(C3_USE_TB "Enable TB" OFF)
-set(C3_LLVM_VERSION "auto" CACHE STRING "Use LLVM version [default: auto]")
-option(C3_USE_MIMALLOC "Use built-in mimalloc" OFF)
-set(C3_MIMALLOC_TAG "v1.7.3" CACHE STRING "Used version of mimalloc")
+    if(C3_WITH_LLVM)
+        FetchContent_GetProperties(LLVM_Windows)
+        if(NOT LLVM_Windows_URL MATCHES "msvcrt")
+            set(MSVC_CRT_SUFFIX "")
+            message(STATUS "Detected STATIC LLVM (libcmt)")
+        else()
+            set(MSVC_CRT_SUFFIX "DLL")
+            message(STATUS "Detected DYNAMIC LLVM (msvcrt)")
+        endif()
+    endif()
+
+    # Force the Runtime to Release (/MT or /MD) even in Debug
+    # This is required to match our RelWithDebInfo LLVM builds
+    set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded${MSVC_CRT_SUFFIX}")
+    set_property(GLOBAL PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded${MSVC_CRT_SUFFIX}")
+
+    add_compile_definitions(_ITERATOR_DEBUG_LEVEL=0)
+
+    # Suppresses the LNK4098 mismatch warning in Debug builds
+    set(CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG} /NODEFAULTLIB:libcmtd /NODEFAULTLIB:msvcrtd")
+else()
+    add_compile_options(-gdwarf-3 -fno-exceptions)
+
+    #add_compile_options(-fsanitize=address,undefined)
+    #add_link_options(-fsanitize=address,undefined)
+endif()
+
+# Options
+set(C3_LINK_DYNAMIC         OFF                         CACHE BOOL   "Link dynamically with LLVM/LLD libs")
+set(C3_WITH_LLVM            ON                          CACHE BOOL   "Build with LLVM")
+set(C3_LLVM_VERSION         "auto"                      CACHE STRING "Use LLVM version [default: auto]")
+set(C3_USE_MIMALLOC         OFF                         CACHE BOOL   "Use built-in mimalloc")
+set(C3_MIMALLOC_TAG         "v1.7.3"                    CACHE STRING "Used version of mimalloc")
+set(C3_USE_TB               OFF                         CACHE BOOL   "Use TB")
+set(C3_LLD_DIR              ""                          CACHE STRING "Use custom LLD directory")
+set(C3_LLD_INCLUDE_DIR      ""                          CACHE STRING "Use custom LLD include directory")
+set(C3_ENABLE_CLANGD_LSP    OFF                         CACHE BOOL   "Enable/Disable output of compile commands during generation")
+set(C3_FETCH_LLVM           OFF                         CACHE BOOL   "Automatically download LLVM artifacts")
+set(C3_LLVM_TAG             "llvm_21.x"                 CACHE STRING "Tag/Branch to download LLVM from")
+set(LLVM_CRT_LIBRARY_DIR    ""                          CACHE STRING "Use custom llvm's compiler-rt directory")
+set(TCC_LIB_PATH            "/usr/lib/tcc/libtcc1.a"    CACHE STRING "Use custom libtcc1.a path")
+
+set(C3_OPTIONS
+        C3_LINK_DYNAMIC
+        C3_WITH_LLVM
+        C3_FETCH_LLVM
+        C3_LLVM_TAG
+        C3_LLVM_VERSION
+        C3_USE_MIMALLOC
+        C3_MIMALLOC_TAG
+        C3_USE_TB
+        C3_LLD_DIR
+        C3_ENABLE_CLANGD_LSP
+        LLVM_CRT_LIBRARY_DIR
+)
 
 set(C3_USE_MIMALLOC OFF)
 if(C3_USE_MIMALLOC)
@@ -29,174 +123,303 @@ if(C3_USE_MIMALLOC)
     option(MI_PADDING OFF)
     option(MI_DEBUG_FULL OFF)
     FetchContent_Declare(
-    mimalloc
-    GIT_REPOSITORY https://github.com/microsoft/mimalloc.git
-    GIT_TAG ${C3_MIMALLOC_TAG}
+            mimalloc
+            GIT_REPOSITORY https://github.com/microsoft/mimalloc.git
+            GIT_TAG ${C3_MIMALLOC_TAG}
     )
     FetchContent_MakeAvailable(mimalloc)
 endif()
 
-if (NOT C3_LLVM_VERSION STREQUAL "auto")
-    if (${C3_LLVM_VERSION} VERSION_LESS 12 OR ${C3_LLVM_VERSION} VERSION_GREATER 15)
-        message(FATAL_ERROR "LLVM ${C3_LLVM_VERSION} is not supported!")
+find_package(Git QUIET)
+if(C3_USE_TB AND GIT_FOUND AND EXISTS "${CMAKE_SOURCE_DIR}/.git")
+    # Update submodules as needed
+    option(GIT_SUBMODULE "Check submodules during build" ON)
+    if(GIT_SUBMODULE)
+        message(STATUS "Submodule update")
+        execute_process(COMMAND ${GIT_EXECUTABLE} submodule update --init --recursive
+                WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+                RESULT_VARIABLE GIT_SUBMOD_RESULT)
+        if(NOT GIT_SUBMOD_RESULT EQUAL "0")
+            message(FATAL_ERROR "git submodule update --init --recursive failed with ${GIT_SUBMOD_RESULT}, please checkout submodules")
+        endif()
     endif()
 endif()
 
-if(CMAKE_C_COMPILER_ID STREQUAL "MSVC")
-    if (C3_LLVM_VERSION STREQUAL "auto")
-        set(C3_LLVM_VERSION "14")
-    endif()
-    FetchContent_Declare(
-            LLVM_Windows
-            URL https://github.com/c3lang/win-llvm/releases/download/llvm-vs22/llvm-14.0.1-windows-amd64-msvc17-libcmt.7z
+# Clangd LSP support
+if(C3_ENABLE_CLANGD_LSP)
+    set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+    execute_process(
+            COMMAND ${CMAKE_COMMAND} -E create_symlink
+            ${CMAKE_BINARY_DIR}/compile_commands.json
+            ${CMAKE_SOURCE_DIR}/compile_commands.json
     )
-    FetchContent_Declare(
-            LLVM_Windows_debug
-            URL https://github.com/c3lang/win-llvm/releases/download/llvm-vs22/llvm-14.0.1-windows-amd64-msvc17-libcmt-dbg.7z
-    )
-    if(CMAKE_BUILD_TYPE STREQUAL "Debug")
-        message("Loading Windows LLVM debug libraries, this may take a while...")
-        FetchContent_MakeAvailable(LLVM_Windows_debug)
-        set(CMAKE_SYSTEM_PREFIX_PATH ${llvm_windows_debug_SOURCE_DIR} ${CMAKE_SYSTEM_PREFIX_PATH})
-    else()
-        message("Loading Windows LLVM libraries, this may take a while...")
-        FetchContent_MakeAvailable(LLVM_Windows)
-        set(CMAKE_SYSTEM_PREFIX_PATH ${llvm_windows_SOURCE_DIR} ${CMAKE_SYSTEM_PREFIX_PATH})
-    endif()
-    find_package(LLVM REQUIRED CONFIG)
-    find_package(LLD REQUIRED CONFIG)
-else()
-    if (NOT C3_LLVM_VERSION STREQUAL "auto")
-        find_package(LLVM ${C3_LLVM_VERSION} REQUIRED CONFIG)
-    else()
-        find_package(LLVM REQUIRED CONFIG)
-    endif()
-endif()
+endif(C3_ENABLE_CLANGD_LSP)
 
-message(STATUS "Found LLVM ${LLVM_PACKAGE_VERSION}")
-message(STATUS "Using LLVMConfig.cmake in: ${LLVM_DIR}")
-message(STATUS "Libraries located in: ${LLVM_LIBRARY_DIRS}")
-include_directories(${LLVM_INCLUDE_DIRS})
-add_definitions(${LLVM_DEFINITIONS})
+if(C3_WITH_LLVM)
+    if(C3_FETCH_LLVM)
+        # 1. Determine local platform ID
+        if (WIN32)
+            set(C3_LLVM_PLATFORM "windows-amd64")
+        elseif (APPLE)
+            if (CMAKE_SYSTEM_PROCESSOR STREQUAL "arm64" OR CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL "arm64")
+                set(C3_LLVM_PLATFORM "darwin-aarch64")
+            else()
+                set(C3_LLVM_PLATFORM "darwin-amd64")
+            endif()
+        else() # Linux
+            if (CMAKE_SYSTEM_PROCESSOR STREQUAL "aarch64" OR CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL "aarch64")
+                set(C3_LLVM_PLATFORM "linux-aarch64")
+            elseif (CMAKE_SYSTEM_PROCESSOR STREQUAL "riscv64" OR CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL "riscv64")
+                set(C3_LLVM_PLATFORM "linux-riscv64")
+            else()
+                set(C3_LLVM_PLATFORM "linux-amd64")
+            endif()
+        endif()
 
-set(LLVM_LINK_COMPONENTS
-        AllTargetsAsmParsers
-        AllTargetsCodeGens
-        AllTargetsDescs
-        AllTargetsDisassemblers
-        AllTargetsInfos
-        Analysis
-        AsmPrinter
-        BitReader
-        Core
-        DebugInfoPDB
-        InstCombine
-        IrReader
-        LibDriver
-        Linker
-        LTO
-        MC
-        MCDisassembler
-        native
-        nativecodegen
-        Object
-        Option
-        ScalarOpts
-        Support
-        Target
-        TransformUtils
-        WindowsManifest
-)
+        # 2. Determine if we want Debug or Release
+        set(C3_LLVM_SUFFIX "")
+        set(C3_LLVM_TYPE "Release")
+        if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+            set(C3_LLVM_SUFFIX "-dbg")
+            set(C3_LLVM_TYPE "Debug")
+        endif()
 
-if (${LLVM_PACKAGE_VERSION} VERSION_GREATER 14.1)
-    set(LLVM_LINK_COMPONENTS ${LLVM_LINK_COMPONENTS} WindowsDriver)
-endif()
+        # 3. Construct URL
+        set(C3_LLVM_ARTIFACT_NAME "llvm-${C3_LLVM_PLATFORM}${C3_LLVM_SUFFIX}")
+        #set(C3_LLVM_URL "https://github.com/c3lang/c3-llvm/releases/download/${C3_LLVM_TAG}/${C3_LLVM_ARTIFACT_NAME}.tar.gz")
+        #set(C3_LLVM_URL "https://github.com//ManuLinares/llvm-custom-builds/releases/download/${C3_LLVM_TAG}/${C3_LLVM_ARTIFACT_NAME}.tar.gz")
 
-llvm_map_components_to_libnames(llvm_libs ${LLVM_LINK_COMPONENTS})
+        # We could also just set "latest" here to always fetch the latest release
+        set(C3_LLVM_URL "https://github.com/c3lang/llvm-for-c3/releases/latest/download/${C3_LLVM_ARTIFACT_NAME}.tar.gz")
 
-file(COPY ${CMAKE_SOURCE_DIR}/lib DESTINATION ${CMAKE_BINARY_DIR})
+        message(STATUS "Fetching ${C3_LLVM_TYPE} LLVM artifact for ${C3_LLVM_PLATFORM}...")
+        message(STATUS "URL: ${C3_LLVM_URL}")
 
-
-# These don't seem to be reliable on windows.
-message(STATUS "using find_library")
-if(C3_USE_TB)
-    find_library(TB_LIB NAMES tildebackend.a tildebackend.lib PATHS ${CMAKE_SOURCE_DIR}/tb/)
-endif()
-find_library(LLD_COFF NAMES lldCOFF.lib lldCOFF.a liblldCOFF.a PATHS ${LLVM_LIBRARY_DIRS})
-find_library(LLD_COMMON NAMES lldCommon.lib lldCommon.a liblldCommon.a PATHS ${LLVM_LIBRARY_DIRS})
-find_library(LLD_ELF NAMES lldELF.lib lldELF.a liblldELF.a PATHS ${LLVM_LIBRARY_DIRS})
-if (${LLVM_PACKAGE_VERSION} VERSION_LESS 14)
-    find_library(LLD_MACHO NAMES lldMachO2.lib lldMachO2.a liblldMachO2.a PATHS ${LLVM_LIBRARY_DIRS})
-else ()
-    find_library(LLD_MACHO NAMES lldMachO.lib lldMachO.a liblldMachO.a PATHS ${LLVM_LIBRARY_DIRS})
-endif ()
-find_library(LLD_MINGW NAMES lldMinGW.lib lldMinGW.a liblldMinGW.a PATHS ${LLVM_LIBRARY_DIRS})
-find_library(LLD_WASM NAMES lldWasm.lib lldWasm.a liblldWasm.a PATHS ${LLVM_LIBRARY_DIRS})
-
-if (${LLVM_PACKAGE_VERSION} VERSION_LESS 14)
-    find_library(LLD_CORE NAMES lldCore.lib lldCore.a liblldCore.a PATHS ${LLVM_LIBRARY_DIRS})
-    find_library(LLD_DRIVER NAMES lldDriver.lib lldDriver.a liblldDriver.a PATHS ${LLVM_LIBRARY_DIRS})
-    find_library(LLD_READER_WRITER NAMES lldReaderWriter.lib lldReaderWriter.a liblldReaderWriter.a PATHS ${LLVM_LIBRARY_DIRS})
-    find_library(LLD_YAML NAMES lldYAML.lib lldYAML.a liblldYAML.a PATHS ${LLVM_LIBRARY_DIRS})
-endif ()
-
-set(lld_libs
-        ${LLD_COFF}
-        ${LLD_COMMON}
-        ${LLD_WASM}
-        ${LLD_MINGW}
-        ${LLD_ELF}
-        ${LLD_DRIVER}
-        ${LLD_READER_WRITER}
-        ${LLD_MACHO}
-        ${LLD_YAML}
-        ${LLD_CORE}
+        FetchContent_Declare(
+                LLVM_Artifact
+                URL ${C3_LLVM_URL}
         )
-if (APPLE)
-    set(lld_libs ${lld_libs} xar)
-endif ()
+        FetchContent_MakeAvailable(LLVM_Artifact)
 
-message(STATUS "linking to llvm libs ${lld_libs}")
-message(STATUS "Found lld libs ${lld_libs}")
+        # 4. Point CMake to the fetched location
+        set(llvm_dir ${llvm_artifact_SOURCE_DIR})
+        set(CMAKE_PREFIX_PATH ${llvm_dir} ${CMAKE_PREFIX_PATH})
+        set(LLVM_DIR "${llvm_dir}/lib/cmake/llvm")
+        set(LLD_DIR "${llvm_dir}/lib/cmake/lld")
 
-add_library(c3c_wrappers STATIC wrapper/src/wrapper.cpp)
+        # TEST: For Windows, we might need to add the bin dir to prefix path for find_package to work well
+        if (WIN32)
+            set(CMAKE_SYSTEM_PREFIX_PATH ${llvm_dir} ${CMAKE_SYSTEM_PREFIX_PATH})
+        endif()
+
+        find_package(LLVM REQUIRED CONFIG NO_DEFAULT_PATH)
+        find_package(LLD REQUIRED CONFIG NO_DEFAULT_PATH)
+    else()
+        if(CMAKE_C_COMPILER_ID STREQUAL "MSVC")
+            # Legacy MSVC path if someone explicitly disabled fetching but is on MSVC
+            find_package(LLVM REQUIRED CONFIG)
+            find_package(LLD REQUIRED CONFIG)
+        else()
+            # Default system search
+            file (GLOB LLVM_CMAKE_PATHS "/usr/lib/llvm/*/lib/cmake/llvm/")
+            list (APPEND CMAKE_PREFIX_PATH ${LLVM_CMAKE_PATHS} "/usr/lib/")
+
+            if (NOT C3_LLVM_VERSION STREQUAL "auto")
+                find_package(LLVM ${C3_LLVM_VERSION} REQUIRED CONFIG)
+            else()
+                find_package(LLVM REQUIRED CONFIG)
+            endif()
+        endif()
+    endif()
+
+    if (NOT C3_FETCH_LLVM AND EXISTS /opt/homebrew/lib)
+        list(APPEND LLVM_LIBRARY_DIRS /opt/homebrew/lib)
+    endif()
+
+    if (EXISTS /usr/lib)
+        # Some systems (such as Alpine Linux) seem to put some of the relevant
+        # LLVM files in /usr/lib, but this doesn't seem to be included in the
+        # value of LLVM_LIBRARY_DIRS.
+        list(APPEND LLVM_LIBRARY_DIRS /usr/lib)
+    endif()
+
+    list(REMOVE_DUPLICATES LLVM_LIBRARY_DIRS)
+
+    message(STATUS "Found LLVM ${LLVM_PACKAGE_VERSION}")
+    message(STATUS "Using LLVMConfig.cmake in: ${LLVM_DIR}")
+    message(STATUS "LLVM libraries located in: ${LLVM_LIBRARY_DIRS}")
+
+    if (${LLVM_PACKAGE_VERSION} VERSION_LESS C3_LLVM_MIN_VERSION OR
+        ${LLVM_PACKAGE_VERSION} VERSION_GREATER C3_LLVM_MAX_VERSION)
+        message(FATAL_ERROR "LLVM ${LLVM_PACKAGE_VERSION} is not supported! LLVM version between ${C3_LLVM_MIN_VERSION} and ${C3_LLVM_MAX_VERSION} is required.")
+    endif()
+
+    if(LLVM_ENABLE_RTTI)
+        message(STATUS "LLVM was built with RTTI")
+    else()
+        message(STATUS "LLVM was not built with RTTI")
+    endif()
+
+    string(REPLACE "." ";" VERSION_LIST ${LLVM_PACKAGE_VERSION})
+    list(GET VERSION_LIST 0 LLVM_MAJOR_VERSION)
+
+    include_directories(${LLVM_INCLUDE_DIRS})
+    link_directories(${LLVM_LIBRARY_DIRS})
+    add_definitions(${LLVM_DEFINITIONS})
+
+    if(NOT C3_LINK_DYNAMIC)
+        set(LLVM_LINK_COMPONENTS
+                AllTargetsAsmParsers
+                AllTargetsCodeGens
+                AllTargetsDescs
+                AllTargetsDisassemblers
+                AllTargetsInfos
+                Analysis
+                AsmPrinter
+                BitReader
+                Core
+                DebugInfoPDB
+                InstCombine
+                IrReader
+                LibDriver
+                Linker
+                LTO
+                MC
+                MCDisassembler
+                native
+                nativecodegen
+                Object
+                Option
+                ScalarOpts
+                Support
+                Target
+                TransformUtils
+                WindowsManifest
+                WindowsDriver
+        )
+
+        llvm_map_components_to_libnames(llvm_libs ${LLVM_LINK_COMPONENTS})
+
+        if(NOT ${C3_LLD_DIR} EQUAL "" AND EXISTS ${C3_LLD_DIR})
+            list(APPEND LLVM_LIBRARY_DIRS ${C3_LLD_DIR})
+            list(REMOVE_DUPLICATES LLVM_LIBRARY_DIRS)
+        endif()
+
+        message(STATUS "Looking for static lld libraries in ${LLVM_LIBRARY_DIRS}")
+
+        # These don't seem to be reliable on windows.
+        find_library(LLD_COFF NAMES lldCOFF.a liblldCOFF.a liblldCOFF.dylib lldCOFF.lib liblldCOFF.dll.a PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH REQUIRED)
+        find_library(LLD_COMMON NAMES lldCommon.a liblldCommon.a liblldCommon.dylib lldCommon.lib liblldCommon.dll.a PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH REQUIRED)
+        find_library(LLD_ELF NAMES lldELF.a liblldELF.a liblldELF.dylib lldELF.lib liblldELF.dll.a PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH REQUIRED)
+        if (NOT ${CMAKE_SYSTEM_NAME} STREQUAL "OpenBSD")
+            find_library(LLD_MACHO NAMES lldMachO.a liblldMachO.a liblldMachO.dylib lldMachO.lib liblldMachO.dll.a PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH REQUIRED)
+        else()
+            set(LLD_MACHO "")
+        endif()
+        find_library(LLD_MINGW NAMES lldMinGW.a liblldMinGW.a liblldMinGW.dylib lldMinGW.lib liblldMinGW.dll.a PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH REQUIRED)
+        find_library(LLD_WASM NAMES lldWasm.a liblldWasm.a liblldWasm.dylib lldWasm.lib liblldWasm.dll.a PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH REQUIRED)
+    else()
+        message(STATUS "Looking for shared lld libraries in ${LLVM_LIBRARY_DIRS}")
+
+        #find_library(LLVM NAMES libLLVM.so PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH REQUIRED)
+        if(UNIX AND NOT WIN32)
+            find_library(LLVM NAMES libLLVM.so PATHS ${LLVM_LIBRARY_DIRS} REQUIRED)
+        else()
+            find_library(LLVM NAMES libLLVM.a LLVM.lib PATHS ${LLVM_LIBRARY_DIRS} REQUIRED)
+        endif()
+        set(llvm_libs ${LLVM})
+
+        # These don't seem to be reliable on windows.
+        find_library(LLD_COFF NAMES liblldCOFF.so PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH REQUIRED)
+        find_library(LLD_COMMON NAMES liblldCommon.so PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH REQUIRED)
+        find_library(LLD_ELF NAMES liblldELF.so PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH REQUIRED)
+        if (NOT ${CMAKE_SYSTEM_NAME} STREQUAL "OpenBSD")
+            find_library(LLD_MACHO NAMES liblldMachO.so PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH REQUIRED)
+        else()
+            set(LLD_MACHO "")
+        endif()
+        find_library(LLD_MINGW NAMES liblldMinGW.so PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH REQUIRED)
+        find_library(LLD_WASM NAMES liblldWasm.so PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH REQUIRED)
+    endif()
+
+    # find_library(LLD_LOONG NAMES libLLVMLoongArchCodeGen.lib libLLVMLoongArchAsmParser.lib libLLVMLoongArchCodeGen.a libLLVMLoongArchAsmParser.a PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
+    set(lld_libs
+            ${LLD_COFF}
+            ${LLD_WASM}
+            ${LLD_MINGW}
+            ${LLD_ELF}
+            ${LLD_MACHO}
+            ${LLD_COMMON}
+    )
+
+    if (APPLE)
+        set(lld_libs ${lld_libs} xar)
+        if (llvm_dir)
+            file(GLOB_RECURSE RT_ASAN_DYNAMIC "${llvm_dir}/*libclang_rt.asan_osx_dynamic.dylib")
+            file(GLOB_RECURSE RT_TSAN_DYNAMIC "${llvm_dir}/*libclang_rt.tsan_osx_dynamic.dylib")
+        endif()
+
+        if (NOT RT_ASAN_DYNAMIC OR NOT RT_TSAN_DYNAMIC)
+            # Fallback to searching in LLVM_LIBRARY_DIRS (for non-fetched LLVM)
+            find_file(RT_ASAN_DYNAMIC_PATH NAMES libclang_rt.asan_osx_dynamic.dylib PATHS ${LLVM_LIBRARY_DIRS} PATH_SUFFIXES "clang/${LLVM_MAJOR_VERSION}/lib/darwin" "clang/${LLVM_PACKAGE_VERSION}/lib/darwin")
+            find_file(RT_TSAN_DYNAMIC_PATH NAMES libclang_rt.tsan_osx_dynamic.dylib PATHS ${LLVM_LIBRARY_DIRS} PATH_SUFFIXES "clang/${LLVM_MAJOR_VERSION}/lib/darwin" "clang/${LLVM_PACKAGE_VERSION}/lib/darwin")
+            if (RT_ASAN_DYNAMIC_PATH)
+                set(RT_ASAN_DYNAMIC ${RT_ASAN_DYNAMIC_PATH})
+            endif()
+            if (RT_TSAN_DYNAMIC_PATH)
+                set(RT_TSAN_DYNAMIC ${RT_TSAN_DYNAMIC_PATH})
+            endif()
+        endif()
+
+        if (RT_ASAN_DYNAMIC)
+            list(GET RT_ASAN_DYNAMIC 0 RT_ASAN_DYNAMIC)
+        endif()
+        if (RT_TSAN_DYNAMIC)
+            list(GET RT_TSAN_DYNAMIC 0 RT_TSAN_DYNAMIC)
+        endif()
+
+        if (RT_ASAN_DYNAMIC AND RT_TSAN_DYNAMIC)
+            set(sanitizer_runtime_libraries
+                    ${RT_ASAN_DYNAMIC}
+                    ${RT_TSAN_DYNAMIC}
+            )
+        endif()
+    endif()
+
+    message(STATUS "Linking to llvm libs ${llvm_libs}")
+    message(STATUS "Linking to lld libs ${lld_libs}")
+endif()
+
+add_library(miniz STATIC dependencies/miniz/miniz.c)
 
 add_executable(c3c
         src/build/builder.c
         src/build/build_options.c
         src/build/project_creation.c
+        src/build/project_manipulation.c
+        src/build/libraries.c
         src/compiler/ast.c
         src/compiler/bigint.c
-        src/compiler/c_abi_internal.h
         src/compiler/codegen_general.c
         src/compiler/compiler.c
         src/compiler/compiler.h
+        src/compiler/subprocess.c
+        src/compiler/subprocess.h
         src/compiler/context.c
         src/compiler/copying.c
         src/compiler/diagnostics.c
-        src/compiler/dwarf.h
-        src/compiler/enums.h
         src/compiler/float.c
         src/compiler/headers.c
+        src/compiler/json_output.c
         src/compiler/lexer.c
-        src/compiler/libraries.c
         src/compiler/linker.c
-        src/compiler/llvm_codegen.c
-        src/compiler/llvm_codegen_c_abi_aarch64.c
-        src/compiler/llvm_codegen_c_abi.c
-        src/compiler/llvm_codegen_c_abi_riscv.c
-        src/compiler/llvm_codegen_c_abi_wasm.c
-        src/compiler/llvm_codegen_c_abi_win64.c
-        src/compiler/llvm_codegen_c_abi_x64.c
-        src/compiler/llvm_codegen_c_abi_x86.c
-        src/compiler/llvm_codegen_debug_info.c
-        src/compiler/llvm_codegen_expr.c
-        src/compiler/llvm_codegen_function.c
-        src/compiler/llvm_codegen_instr.c
-        src/compiler/llvm_codegen_module.c
-        src/compiler/llvm_codegen_stmt.c
-        src/compiler/llvm_codegen_type.c
-        src/compiler/llvm_codegen_value.c
+        src/compiler/abi/c_abi_aarch64.c
+        src/compiler/abi/c_abi.c
+        src/compiler/abi/c_abi_riscv.c
+        src/compiler/abi/c_abi_wasm.c
+        src/compiler/abi/c_abi_win64.c
+        src/compiler/abi/c_abi_x64.c
+        src/compiler/abi/c_abi_x86.c
         src/compiler/module.c
         src/compiler/number.c
         src/compiler/parse_expr.c
@@ -209,6 +432,9 @@ add_executable(c3c
         src/compiler/sema_expr.c
         src/compiler/sema_internal.h
         src/compiler/sema_name_resolution.c
+        src/compiler/sema_errors.c
+        src/compiler/sema_builtins.c
+        src/compiler/sema_initializers.c
         src/compiler/semantic_analyser.c
         src/compiler/sema_passes.c
         src/compiler/sema_stmts.c
@@ -216,11 +442,7 @@ add_executable(c3c
         src/compiler/source_file.c
         src/compiler/symtab.c
         src/compiler/target.c
-        src/compiler/tb_codegen.c
-        src/compiler/tilde_codegen.c
-        src/compiler/tilde_codegen_instr.c
-        src/compiler/tilde_codegen_value.c
-        src/compiler/tilde_codegen_storeload.c
+        src/compiler/sema_asm.c
         src/compiler_tests/benchmark.c
         src/compiler_tests/tests.c
         src/compiler/tokens.c
@@ -237,67 +459,289 @@ add_executable(c3c
         src/utils/vmem.c
         src/utils/vmem.h
         src/utils/whereami.c
+        src/utils/cpus.c
+        src/utils/unzipper.c
+        src/utils/msi.c
+        src/compiler/c_codegen.c
         src/compiler/decltable.c
+        src/compiler/methodtable.c
         src/compiler/mac_support.c
-        src/compiler/tilde_codegen_storeload.c
-        src/compiler/llvm_codegen_storeload.c
-        src/compiler/tilde_codegen_expr.c
-        src/compiler/tilde_codegen_stmt.c
-        src/compiler/tilde_codegen_type.c
-        src/compiler/windows_support.c)
+        src/utils/fetch_msvc.c
+        src/compiler/windows_support.c
+        src/compiler/codegen_asm.c
+        src/compiler/asm_target.c
+        src/compiler/expr.c
+        src/utils/time.c
+        src/utils/http.c
+        src/compiler/sema_liveness.c
+        src/build/common_build.c
+        src/compiler/sema_const.c
+        ${CMAKE_BINARY_DIR}/git_hash.h
+)
 
-if(NOT CMAKE_C_COMPILER_ID STREQUAL "MSVC")
-    message(STATUS "using gcc/clang warning switches")
-    target_compile_options(c3c PRIVATE -Wall -Werror -Wno-unknown-pragmas -Wno-unused-result
-             -Wno-unused-function -Wno-unused-variable -Wno-unused-parameter)
+if(GIT_FOUND AND EXISTS "${CMAKE_SOURCE_DIR}/.git")
+    # We are inside of a git repository so rebuilding the hash every time something changes.
+    add_custom_command(
+            OUTPUT ${CMAKE_BINARY_DIR}/git_hash.h
+            COMMAND ${CMAKE_COMMAND} -P "${CMAKE_CURRENT_LIST_DIR}/git_hash.cmake"
+            DEPENDS "${CMAKE_CURRENT_LIST_DIR}/.git")
+else()
+    # We are NOT inside of a git repository. Building the has only once.
+    add_custom_command(
+            OUTPUT ${CMAKE_BINARY_DIR}/git_hash.h
+            COMMAND ${CMAKE_COMMAND} -P "${CMAKE_CURRENT_LIST_DIR}/git_hash.cmake")
+endif()
+
+if(C3_WITH_LLVM)
+    target_sources(c3c PRIVATE
+            src/compiler/llvm_codegen.c
+            src/compiler/llvm_codegen_debug_info.c
+            src/compiler/llvm_codegen_expr.c
+            src/compiler/llvm_codegen_function.c
+            src/compiler/llvm_codegen_instr.c
+            src/compiler/llvm_codegen_module.c
+            src/compiler/llvm_codegen_stmt.c
+            src/compiler/llvm_codegen_type.c
+            src/compiler/llvm_codegen_value.c
+            src/compiler/llvm_codegen_storeload.c
+            src/compiler/llvm_codegen_builtins.c)
+
+    target_compile_definitions(c3c PUBLIC LLVM_AVAILABLE=1)
+    add_library(c3c_wrappers STATIC wrapper/src/wrapper.cpp)
+    if (MSVC)
+        # Use the same detected CRT for the wrapper
+        set_target_properties(c3c_wrappers PROPERTIES MSVC_RUNTIME_LIBRARY "MultiThreaded${MSVC_CRT_SUFFIX}")
+        set_target_properties(miniz PROPERTIES MSVC_RUNTIME_LIBRARY "MultiThreaded${MSVC_CRT_SUFFIX}")
+
+        target_compile_options(c3c PRIVATE
+                "$<$<CONFIG:Debug>:/EHa>"
+                "$<$<CONFIG:Release>:/EHsc>")
+    endif()
+
+    if(C3_LLD_INCLUDE_DIR)
+        target_include_directories(c3c_wrappers PRIVATE ${C3_LLD_INCLUDE_DIR})
+    endif()
+else()
+    target_sources(c3c PRIVATE src/utils/hostinfo.c)
+    target_compile_definitions(c3c PUBLIC LLVM_AVAILABLE=0)
+    target_link_libraries(c3c m)
 endif()
 
 target_include_directories(c3c PRIVATE
-        "${CMAKE_SOURCE_DIR}/src/")
+        "${CMAKE_SOURCE_DIR}/src/"
+        "${CMAKE_BINARY_DIR}")
 
-target_include_directories(c3c PRIVATE
-        "${CMAKE_SOURCE_DIR}/tb/")
+target_include_directories(miniz PUBLIC
+        "${CMAKE_SOURCE_DIR}/dependencies/miniz/")
 
-target_include_directories(c3c_wrappers PRIVATE
-        "${CMAKE_SOURCE_DIR}/wrapper/src/")
+if (C3_USE_TB)
+    file(GLOB tilde-sources
+            tilde-backend/src/tb/*.c
+            tilde-backend/src/tb/codegen/*.c
+            tilde-backend/src/tb/bigint/*.c
+            tilde-backend/src/tb/objects/*.c
+            tilde-backend/src/tb/system/*.c
+            tilde-backend/src/tb/debug/cv/*.c
+            tilde-backend/src/tb/opt/*.c
+            tilde-backend/src/tb/x64/*.c
+            tilde-backend/src/tb/wasm/*.c
+            tilde-backend/src/tb/aarch64/*.c
+    )
+    target_sources(c3c PRIVATE
+            src/compiler/tilde_codegen.c
+            src/compiler/tilde_codegen_instr.c
+            src/compiler/tilde_codegen_value.c
+            src/compiler/tilde_codegen_storeload.c
+            src/compiler/tilde_codegen_expr.c
+            src/compiler/tilde_codegen_stmt.c
+            src/compiler/tilde_codegen_type.c
+            src/compiler/tilde_codegen_abi.c
+            src/compiler/tilde_codegen_storeload.c)
 
+    target_compile_definitions(c3c PUBLIC TB_AVAILABLE=1)
+    target_link_libraries(c3c tilde-backend)
+    add_library(tilde-backend STATIC ${tilde-sources})
+    target_include_directories(tilde-backend PRIVATE
+            "${CMAKE_SOURCE_DIR}/tilde-backend/src/" "${CMAKE_SOURCE_DIR}/tilde-backend/include")
 
+    target_include_directories(c3c PRIVATE
+            "${CMAKE_SOURCE_DIR}/tilde-backend/include/")
 
-target_link_libraries(c3c_wrappers ${llvm_libs} ${lld_libs})
-target_link_libraries(c3c ${llvm_libs} c3c_wrappers ${lld_libs})
-if(C3_USE_TB)
-    target_link_libraries(c3c c3c_wrappers ${TB_LIB})
-    target_compile_definitions(c3c PUBLIC TB_BACKEND=1)
 else()
-    target_compile_definitions(c3c PUBLIC TB_BACKEND=0)
+
+    target_compile_definitions(c3c PUBLIC TB_AVAILABLE=0)
+
+endif()
+
+if(C3_WITH_LLVM)
+    target_link_libraries(c3c miniz c3c_wrappers)
+
+    target_include_directories(c3c PRIVATE
+            "${CMAKE_SOURCE_DIR}/wrapper/include/")
+
+    target_include_directories(c3c_wrappers PRIVATE
+            "${CMAKE_SOURCE_DIR}/wrapper/include/")
+
+    target_link_libraries(c3c_wrappers PUBLIC ${lld_libs} ${llvm_libs})
+
+else()
+
+    target_link_libraries(c3c miniz ${lld_libs} ${llvm_libs})
+
 endif()
 
 if(C3_USE_MIMALLOC)
     target_link_libraries(c3c mimalloc-static)
 endif()
 
-if(CMAKE_C_COMPILER_ID STREQUAL "MSVC")
-    message("Adding MSVC options")
-    target_compile_options(c3c PRIVATE /wd4068 /wd4090 /WX /Wv:18)
-    target_compile_options(c3c_wrappers PUBLIC /wd4624 /wd4267 /wd4244 /WX /Wv:18)
-    if(CMAKE_BUILD_TYPE STREQUAL "Debug")
-        target_compile_options(c3c PUBLIC /MTd)
-        target_compile_options(c3c_wrappers PUBLIC /MTd)
-    else()
-        target_compile_options(c3c PUBLIC /MT)
-        target_compile_options(c3c_wrappers PUBLIC /MT)
-    endif()
-
+if (WIN32)
+    target_link_libraries(c3c Winhttp.lib)
 endif()
 
-if (WIN32)
-    if (CMAKE_C_COMPILER_ID STREQUAL "Clang" OR CMAKE_C_COMPILE_ID STREQUAL "GNU")
-        target_link_options(c3c PRIVATE -pthread)
-        target_compile_definitions(c3c PRIVATE USE_PTHREAD=1)
-        target_compile_options(c3c PRIVATE -mlong-double-64)
+if(MINGW)
+    message("Increase stack for msys")
+    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--stack,8388608")
+endif ()
+
+if (NOT WIN32)
+    # For dlopen support
+    if (CMAKE_DL_LIBS)
+        target_link_libraries(c3c ${CMAKE_DL_LIBS})
+    endif()
+endif()
+
+
+if(MSVC)
+    target_compile_options(c3c PRIVATE
+        /wd4068
+        /wd4090
+        /WX
+        /Wv:18
+    )
+
+    if(C3_WITH_LLVM)
+        target_compile_options(c3c_wrappers PUBLIC
+            /wd4624
+            /wd4267
+            /wd4244
+            /WX
+            /Wv:18
+        )
+        if(NOT LLVM_ENABLE_RTTI)
+            target_compile_options(c3c_wrappers PUBLIC /GR-)
+        endif()
+        target_link_options(c3c_wrappers PUBLIC /ignore:4099)
+    endif()
+
+    if(C3_WITH_LLVM)
+        # The the sanitizer libs are in the folder "lib/clang/21/lib/windows/" but use the find anyway
+        file(GLOB_RECURSE FOUND_ASAN_LIB "${llvm_dir}/*clang_rt.asan_dynamic-x86_64.lib")
+        if(FOUND_ASAN_LIB)
+            list(GET FOUND_ASAN_LIB 0 _asan_path)
+            get_filename_component(_asan_dir "${_asan_path}" DIRECTORY)
+            set(sanitizer_runtime_libraries
+                    ${_asan_dir}/clang_rt.asan_dynamic-x86_64.lib
+                    ${_asan_dir}/clang_rt.asan_dynamic-x86_64.dll
+                    ${_asan_dir}/clang_rt.asan_dynamic_runtime_thunk-x86_64.lib)
+            message(STATUS "Found Sanitizer binaries at: ${_asan_dir}")
+        else()
+            message(WARNING "Could not find sanitizer runtime libraries in ${llvm_dir}")
+        endif()
+    endif()
+
+else()
+    if (C3_WITH_LLVM AND NOT LLVM_ENABLE_RTTI)
+        target_compile_options(c3c_wrappers PRIVATE -fno-rtti)
+    endif()
+    target_compile_options(c3c PRIVATE
+        -pthread
+        -Wall
+        -Werror
+        -Wno-unknown-pragmas
+        -Wno-unused-result
+        -Wno-unused-function
+        -Wno-unused-variable
+        -Wno-unused-parameter
+        -Wno-char-subscripts
+    )
+    target_link_options(c3c PRIVATE -pthread)
+endif()
+
+if(CMAKE_C_COMPILER_ID STREQUAL "TinyCC")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wl,--no-eh-frame-hdr -z noexecstack")
+
+    # Link the static tcc runtime archive if it exists
+    if(EXISTS "${TCC_LIB_PATH}")
+        target_link_libraries(c3c "${TCC_LIB_PATH}")
+    else()
+        message(FATAL_ERROR "TCC runtime not found at ${TCC_LIB_PATH}; Ensure the path is correct.")
     endif()
 endif()
 
 install(TARGETS c3c DESTINATION bin)
+install(DIRECTORY lib/ DESTINATION lib/c3)
+
+# Man page install (OSX/Linux only)
+if (NOT WIN32)
+    install(FILES c3c.1 DESTINATION "share/man/man1")
+endif()
+
+# Copy stdlib
+if (NOT ${CMAKE_BINARY_DIR} EQUAL ${CMAKE_SOURCE_DIR})
+    file(REMOVE_RECURSE ${CMAKE_BINARY_DIR}/lib)
+    file(COPY ${CMAKE_SOURCE_DIR}/lib DESTINATION ${CMAKE_BINARY_DIR})
+endif()
+
+if (C3_WITH_LLVM AND DEFINED sanitizer_runtime_libraries)
+    add_custom_command(TARGET c3c POST_BUILD
+            COMMAND "${CMAKE_COMMAND}" -E rm -rf -- $<TARGET_FILE_DIR:c3c>/c3c_rt
+            COMMAND "${CMAKE_COMMAND}" -E make_directory $<TARGET_FILE_DIR:c3c>/c3c_rt
+            COMMAND "${CMAKE_COMMAND}" -E copy ${sanitizer_runtime_libraries} $<TARGET_FILE_DIR:c3c>/c3c_rt
+            VERBATIM
+            COMMENT "Copying sanitizer runtime libraries to output directory")
+
+    if (APPLE)
+        # Change LC_ID_DYLIB to be rpath-based instead of having an absolute path
+        # We set DYLD_LIBRARY_PATH so the tools (which might be dynamic) can find libLLVM.dylib in the artifact
+        string(REPLACE ";" ":" _dyld_path "${LLVM_LIBRARY_DIRS}")
+        add_custom_command(TARGET c3c POST_BUILD
+                COMMAND ${CMAKE_COMMAND} -E env "DYLD_LIBRARY_PATH=${_dyld_path}:$ENV{DYLD_LIBRARY_PATH}" find $<TARGET_FILE_DIR:c3c>/c3c_rt -type f -name "*.dylib" -execdir ${LLVM_TOOLS_BINARY_DIR}/llvm-install-name-tool -id @rpath/{} {} $<SEMICOLON>
+                VERBATIM)
+    endif()
+
+    install(DIRECTORY $<TARGET_FILE_DIR:c3c>/c3c_rt/ DESTINATION bin/c3c_rt)
+endif()
 
 feature_summary(WHAT ALL)
+
+message(STATUS "Building ${CMAKE_PROJECT_NAME} with the following configuration:")
+
+set(c3_print_prefix "  ")
+
+foreach(option IN LISTS C3_OPTIONS)
+    if (DEFINED ${option})
+        c3_print_variables(${option})
+    endif()
+endforeach()
+
+foreach(flag_var
+        CMAKE_BUILD_TYPE
+        CMAKE_C_COMPILER
+        CMAKE_CXX_COMPILER
+        CMAKE_LINKER
+        CMAKE_OBJCOPY
+        CMAKE_STRIP
+        CMAKE_DLLTOOL)
+    c3_print_variables(${flag_var})
+endforeach()
+
+message(STATUS "Build flags:")
+foreach(flag_var
+        CMAKE_C_FLAGS CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE
+        CMAKE_C_FLAGS_MINSIZEREL CMAKE_C_FLAGS_RELWITHDEBINFO
+        CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE
+        CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO)
+    c3_print_variables(${flag_var})
+endforeach()
+
+message(STATUS "Output to: \"${CMAKE_BINARY_DIR}\"")

CMakePresets.json

@@ -0,0 +1,57 @@
+{
+    "version": 3,
+    "configurePresets": [
+        {
+            "name": "windows-base",
+            "hidden": true,
+            "architecture": {
+                "value": "x64"
+            },
+            "toolset": {
+                "value": "host=x64"
+            }
+        },
+        {
+            "name": "windows-vs-2022-release",
+            "generator": "Visual Studio 17 2022",
+            "displayName": "Windows x64 Visual Studio 17 2022",
+            "inherits": "windows-base",
+            "binaryDir": "build",
+            "cacheVariables": {
+                "CMAKE_CONFIGURATION_TYPES": "Release;RelWithDebInfo",
+                "CMAKE_BUILD_TYPE": "Release"
+            }
+        },
+        {
+            "name": "windows-vs-2022-debug",
+            "generator": "Visual Studio 17 2022",
+            "displayName": "Windows x64 Visual Studio 17 2022 (Debug)",
+            "inherits": "windows-base",
+            "binaryDir": "build-debug",
+            "cacheVariables": {
+                "CMAKE_CONFIGURATION_TYPES": "Debug",
+                "CMAKE_BUILD_TYPE": "Debug"
+            }
+        }
+    ],
+    "buildPresets": [
+        {
+            "name": "windows-vs-2022-debug",
+            "displayName": "Debug",
+            "configurePreset": "windows-vs-2022-debug",
+            "configuration": "Debug"
+        },
+        {
+            "name": "windows-vs-2022-release",
+            "displayName": "Release",
+            "configurePreset": "windows-vs-2022-release",
+            "configuration": "Release"
+        },
+        {
+            "name": "windows-vs-2022-release-with-debug-info",
+            "displayName": "RelWithDebInfo",
+            "configurePreset": "windows-vs-2022-release",
+            "configuration": "RelWithDebInfo"
+        }
+    ]
+}

CODESTYLE.md

@@ -74,7 +74,7 @@ No space inside parenthesis:
 
 ### Tab vs spaces
 
-Recommendation: tabs, 4 spaces wide. No CRLF in the source.
+Use tabs for indentation, no CRLF in the source.
 
 ### If, braces and new lines
 
@@ -116,7 +116,8 @@ more tests as you go along.
 ### Don't bring in dependencies
 
 External libraries has maintainability issues. Try to depend on as few libraries
-as possible. Currently c3c only depends on LLVM and libc.
+as possible. Currently, c3c only depends on LLVM and libc with an optional 
+dependency on libcurl.
 
 Do use rewrites of subsets of other libraries to bring in functionality, but avoid
 copying in libraries that needs to be updated separately.
@@ -146,4 +147,114 @@ Iterating over the elements are done using `VECEACH`.
 ### Scratch buffer for strings.
 
 There is a scratch buffer for strings in the `global_context` prefer using that
-one with related functions when working on temporary strings.
+one with related functions when working on temporary strings.
+
+# C3 Standard library style guide.
+
+When contributing to the standard library please try your best to adhere to the
+following style requirements to ensure a consistent style in the stdlib and to
+facilitate accepting PRs more quickly.
+
+### Braces are placed on the next line
+
+**NO:**
+```c
+fn void foo(String bar) {
+  @pool() {
+    ...
+  };
+} 
+```
+
+**YES:**
+```c
+fn void foo(String bar)
+{
+  @pool() 
+  {
+    ...
+  };
+}
+```
+
+### Indentation with tabs
+
+Use tab for indentation, not spaces, no CRLF in the sources 
+
+### Type names
+
+Use `PascalCase` not `Ada_Case` for type names.
+
+**YES:**
+```c
+enum MyEnum
+{
+  ABC,
+  DEF
+}  
+```
+
+**NO:**
+```c
+enum My_Enum
+{
+  ABC,
+  DEF
+}  
+```
+
+### Type names when binding to OS libraries
+
+When doing bindings (for instance, adding declarations referring to Win32 APIs),
+try to retain the original name when possible. If it isn't possible use (consistently)
+one of two options:
+
+1. Prefix: `HANDLE` -> `Win32_HANDLE`
+2. Change the first letter to upper case: `mode_t` -> `Mode_t`
+
+### Variables, function, methods and globals
+
+Use `snake_case`, not `camelCase`.
+
+**YES:**
+```c
+int some_global = 1;
+
+fn void open_file(String special_file)
+{
+  ...
+}
+```
+
+**NO:**
+```c
+int someGlobal = 1;
+
+fn void openFile(String specialFile)
+{
+  ...
+}
+```
+
+### Variables, function, methods and globals when binding to OS libraries
+
+When doing bindings (for instance, adding declarations referring to Win32 APIs),
+try to retain the original name when possible. If it isn't possible use (consistently)
+one of two options:
+
+1. Prefix: `win32_GetWindowLongPtrW`. However, this is usually only recommended if it is builtin.
+2. Change first character to lower case: `GetWindowLongPtrW` -> `getWindowLongPtrW`
+
+### Use `self` as the first method argument
+
+Unless there is a strong reason not to, use `self` for the first parameter in a method.
+
+### The allocator argument
+
+Prefer always calling the allocator parameter `allocator`, and make it the first regular
+argument.
+
+## Add tests to your changes
+
+If you add or fix things, then there should always be tests in `test/unit/stdlib` to verify
+the functionality.

CODE_OF_CONDUCT.md

@@ -59,7 +59,7 @@ further defined and clarified by project maintainers.
 ## Enforcement
 
 Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported by contacting the project team at . All
+reported by contacting the project team at info@c3-lang.org. All
 complaints will be reviewed and investigated and will result in a response that
 is deemed necessary and appropriate to the circumstances. The project team is
 obligated to maintain confidentiality with regard to the reporter of an incident.

CONTRIBUTING.md

@@ -0,0 +1,70 @@
+# How to contribute to C3
+
+The C3 project consists of
+
+1. The C3 language itself.
+2. The C3 compiler, called c3c.
+3. The C3 standard library
+4. Various tools, such as the editor plugins
+
+## 1. How to contribute to the C3 language
+
+The C3 language is essentially the language specification. You can contribute to the language by:
+
+1. Filing enhancement requests for changes to the language.
+2. Offering feedback on existing features, on Discord or by filing issues.
+3. Help working on the language specification.
+4. Help working on the grammar.
+
+## 2. How to contribute to the C3 compiler
+
+The C3 compiler consists for the compiler itself + test suites for testing the compiler. 
+You can contribute by:
+
+1. File bugs (by far the most important thing).
+2. Suggest improved diagnostics / error messages.
+3. Refactoring existing code (needs deep understanding of the compiler).
+4. Add support for more architectures.
+5. Add support for more backends.
+
+## 3. How to contribute to the standard library
+
+The standard library is the library itself + test suites for testing the standard library.
+You can contribute by:
+
+1. Filing bugs on the standard library.
+2. Write additional unit tests.
+3. Suggest new functionality by filing an issue.
+4. Work on stdlib additions.
+5. Fix bugs in the stdlib
+6. Maintain a section of the standard library
+
+### How to work on small stdlib additions
+
+If there is just a matter of adding a function or two to an existing module, a pull request
+is sufficient. However, please make sure that:
+
+1. It follows the guidelines for the code to ensure a uniform experience (naming standard, indentation, braces etc).
+2. Add a line in the release notes about the change.
+3. Make sure it has unit tests.
+
+### How to work on non-trivial additions to the stdlib
+
+Regardless whether an addition is approved for inclusion or not, it needs to incubate:
+
+1. First implement it standalone, showing that it’s working well and has a solid design. This has the advantage of people being able to contribute or even create competing implementations
+2. Once it is considered finished it can be proposed for inclusion.
+
+This will greatly help improving the quality of additions.
+
+Note that any new addition needs a full set of unit tests before being included into the standard library.
+
+### Maintain a part of the standard library
+
+A single maintainer is insufficient for a standard library, instead we need one or more maintainer
+for each module. The maintainer(s) will review pull requests and actively work on making the module
+pristine with the highest possible quality.
+
+## 4. How to contribute to various tools
+
+In general, file a pull request. Depending on who maintains it, rules may differ.

LICENSE

@@ -1,165 +1,20 @@
-                   GNU LESSER GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
+Copyright (c) 2022-2025 Christoffer Lernö and contributors
 
- Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
 
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
 
-  This version of the GNU Lesser General Public License incorporates
-the terms and conditions of version 3 of the GNU General Public
-License, supplemented by the additional permissions listed below.
-
-  0. Additional Definitions.
-
-  As used herein, "this License" refers to version 3 of the GNU Lesser
-General Public License, and the "GNU GPL" refers to version 3 of the GNU
-General Public License.
-
-  "The Library" refers to a covered work governed by this License,
-other than an Application or a Combined Work as defined below.
-
-  An "Application" is any work that makes use of an interface provided
-by the Library, but which is not otherwise based on the Library.
-Defining a subclass of a class defined by the Library is deemed a mode
-of using an interface provided by the Library.
-
-  A "Combined Work" is a work produced by combining or linking an
-Application with the Library.  The particular version of the Library
-with which the Combined Work was made is also called the "Linked
-Version".
-
-  The "Minimal Corresponding Source" for a Combined Work means the
-Corresponding Source for the Combined Work, excluding any source code
-for portions of the Combined Work that, considered in isolation, are
-based on the Application, and not on the Linked Version.
-
-  The "Corresponding Application Code" for a Combined Work means the
-object code and/or source code for the Application, including any data
-and utility programs needed for reproducing the Combined Work from the
-Application, but excluding the System Libraries of the Combined Work.
-
-  1. Exception to Section 3 of the GNU GPL.
-
-  You may convey a covered work under sections 3 and 4 of this License
-without being bound by section 3 of the GNU GPL.
-
-  2. Conveying Modified Versions.
-
-  If you modify a copy of the Library, and, in your modifications, a
-facility refers to a function or data to be supplied by an Application
-that uses the facility (other than as an argument passed when the
-facility is invoked), then you may convey a copy of the modified
-version:
-
-   a) under this License, provided that you make a good faith effort to
-   ensure that, in the event an Application does not supply the
-   function or data, the facility still operates, and performs
-   whatever part of its purpose remains meaningful, or
-
-   b) under the GNU GPL, with none of the additional permissions of
-   this License applicable to that copy.
-
-  3. Object Code Incorporating Material from Library Header Files.
-
-  The object code form of an Application may incorporate material from
-a header file that is part of the Library.  You may convey such object
-code under terms of your choice, provided that, if the incorporated
-material is not limited to numerical parameters, data structure
-layouts and accessors, or small macros, inline functions and templates
-(ten or fewer lines in length), you do both of the following:
-
-   a) Give prominent notice with each copy of the object code that the
-   Library is used in it and that the Library and its use are
-   covered by this License.
-
-   b) Accompany the object code with a copy of the GNU GPL and this license
-   document.
-
-  4. Combined Works.
-
-  You may convey a Combined Work under terms of your choice that,
-taken together, effectively do not restrict modification of the
-portions of the Library contained in the Combined Work and reverse
-engineering for debugging such modifications, if you also do each of
-the following:
-
-   a) Give prominent notice with each copy of the Combined Work that
-   the Library is used in it and that the Library and its use are
-   covered by this License.
-
-   b) Accompany the Combined Work with a copy of the GNU GPL and this license
-   document.
-
-   c) For a Combined Work that displays copyright notices during
-   execution, include the copyright notice for the Library among
-   these notices, as well as a reference directing the user to the
-   copies of the GNU GPL and this license document.
-
-   d) Do one of the following:
-
-       0) Convey the Minimal Corresponding Source under the terms of this
-       License, and the Corresponding Application Code in a form
-       suitable for, and under terms that permit, the user to
-       recombine or relink the Application with a modified version of
-       the Linked Version to produce a modified Combined Work, in the
-       manner specified by section 6 of the GNU GPL for conveying
-       Corresponding Source.
-
-       1) Use a suitable shared library mechanism for linking with the
-       Library.  A suitable mechanism is one that (a) uses at run time
-       a copy of the Library already present on the user's computer
-       system, and (b) will operate properly with a modified version
-       of the Library that is interface-compatible with the Linked
-       Version.
-
-   e) Provide Installation Information, but only if you would otherwise
-   be required to provide such information under section 6 of the
-   GNU GPL, and only to the extent that such information is
-   necessary to install and execute a modified version of the
-   Combined Work produced by recombining or relinking the
-   Application with a modified version of the Linked Version. (If
-   you use option 4d0, the Installation Information must accompany
-   the Minimal Corresponding Source and Corresponding Application
-   Code. If you use option 4d1, you must provide the Installation
-   Information in the manner specified by section 6 of the GNU GPL
-   for conveying Corresponding Source.)
-
-  5. Combined Libraries.
-
-  You may place library facilities that are a work based on the
-Library side by side in a single library together with other library
-facilities that are not Applications and are not covered by this
-License, and convey such a combined library under terms of your
-choice, if you do both of the following:
-
-   a) Accompany the combined library with a copy of the same work based
-   on the Library, uncombined with any other library facilities,
-   conveyed under the terms of this License.
-
-   b) Give prominent notice with the combined library that part of it
-   is a work based on the Library, and explaining where to find the
-   accompanying uncombined form of the same work.
-
-  6. Revised Versions of the GNU Lesser General Public License.
-
-  The Free Software Foundation may publish revised and/or new versions
-of the GNU Lesser General Public License from time to time. Such new
-versions will be similar in spirit to the present version, but may
-differ in detail to address new problems or concerns.
-
-  Each version is given a distinguishing version number. If the
-Library as you received it specifies that a certain numbered version
-of the GNU Lesser General Public License "or any later version"
-applies to it, you have the option of following the terms and
-conditions either of that published version or of any later version
-published by the Free Software Foundation. If the Library as you
-received it does not specify a version number of the GNU Lesser
-General Public License, you may choose any version of the GNU Lesser
-General Public License ever published by the Free Software Foundation.
-
-  If the Library as you received it specifies that a proxy can decide
-whether future versions of the GNU Lesser General Public License shall
-apply, that proxy's public statement of acceptance of any version is
-permanent authorization for you to choose that version for the
-Library.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

LICENSE_SRC

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

LICENSE_STDLIB

@@ -1,20 +0,0 @@
-Copyright (c) 2022 Christoffer Lernö and contributors
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.md

@@ -1,14 +1,26 @@
 # C3 Language
 
-C3 is a C-like language striving to be an evolution of C, rather than a 
-completely new language. As an alternative in the C/C++ niche it
-aims to be fast and close to the metal.
+C3 is a programming language that builds on the syntax and semantics of the C language,
+with the goal of evolving it while still retaining familiarity for C programmers. 
+
+It's an evolution, not a revolution: the C-like 
+for programmers who like C.
+
+Precompiled binaries for the following operating systems are available:
+ 
+- Windows x64 [download](https://github.com/c3lang/c3c/releases/download/latest-prerelease-tag/c3-windows.zip), [install instructions](#installing-on-windows-with-precompiled-binaries).
+- Debian x64 [download](https://github.com/c3lang/c3c/releases/download/latest-prerelease-tag/c3-linux.tar.gz), [install instructions](#installing-on-debian-with-precompiled-binaries).
+- Ubuntu x86 [download](https://github.com/c3lang/c3c/releases/download/latest-prerelease-tag/c3-ubuntu-20.tar.gz), [install instructions](#installing-on-ubuntu-with-precompiled-binaries).
+- MacOS Arm64 [download](https://github.com/c3lang/c3c/releases/download/latest-prerelease-tag/c3-macos.zip), [install instructions](#installing-on-macos-with-precompiled-binaries).
+- OpenBSD x64 [download](https://github.com/c3lang/c3c/releases/download/latest-prerelease-tag/c3-openbsd.tar.gz), [install instructions](#installing-on-openbsd-with-precompiled-binaries).
 
 The manual for C3 can be found at [www.c3-lang.org](http://www.c3-lang.org).
 
 ![vkQuake](https://github.com/c3lang/c3c/blob/master/resources/images/vkQuake.png?raw=true)
 
-Thanks to full ABI compatibility with C, it's possible to mix C and C3 in the same project with no effort. As a demonstration, vkQuake was compiled with a small portion of the code converted to C3 and compiled with the c3c compiler. (The fork can be found at https://github.com/c3lang/vkQuake)
+Thanks to full ABI compatibility with C, it's possible to mix C and C3 in the same project with no effort. As a demonstration, vkQuake was compiled with a small portion of the code converted to C3 and compiled with the c3c compiler. (The aging fork can be found at https://github.com/c3lang/vkQuake)
+
+A non-curated list of user written projects and other resources can be found [here](https://github.com/c3lang/c3-showcase).
 
 ### Design Principles
 - Procedural "get things done"-type of language.
@@ -24,16 +36,16 @@ whole new language.
 
 ### Example code
 
-The following code shows [generic modules](http://www.c3-lang.org/generics/) (more examples can be found at http://www.c3-lang.org/examples/). 
+The following code shows [generics](https://c3-lang.org/generic-programming/generics/) (more examples can be found at https://c3-lang.org/language-overview/examples/). 
 
-```c++
+```c3
 module stack <Type>;
 // Above: the parameterized type is applied to the entire module.
 
 struct Stack
 {
-    usize capacity;
-    usize size;
+    usz capacity;
+    usz size;
     Type* elems;
 }
 
@@ -46,7 +58,8 @@ fn void Stack.push(Stack* this, Type element)
     if (this.capacity == this.size)
     {
         this.capacity *= 2;
-        this.elems = mem::realloc(this.elems, Type.sizeof * this.capacity);
+        if (this.capacity < 16) this.capacity = 16;
+        this.elems = realloc(this.elems, Type.sizeof * this.capacity);
     }
     this.elems[this.size++] = element;
 }
@@ -65,25 +78,25 @@ fn bool Stack.empty(Stack* this)
 
 Testing it out:
 
-```cpp
+```c3
 import stack;
 
 // Define our new types, the first will implicitly create 
 // a complete copy of the entire Stack module with "Type" set to "int"
-define IntStack = Stack<int>;
+alias IntStack = Stack {int};
 // The second creates another copy with "Type" set to "double"
-define DoubleStack = Stack<double>;
+alias DoubleStack = Stack {double};
 
-// If we had added "define IntStack2 = Stack<int>"
+// If we had added "alias IntStack2 = Stack {int}"
 // no additional copy would have been made (since we already
-// have an parameterization of Stack<int>) so it would
+// have an parameterization of Stack {int} so it would
 // be same as declaring IntStack2 an alias of IntStack
 
 // Importing an external C function is straightforward
 // here is an example of importing libc's printf:
 extern fn int printf(char* format, ...);
 
-fn void test()
+fn void main()
 {
     IntStack stack;
     // Note that C3 uses zero initialization by default
@@ -103,17 +116,18 @@ fn void test()
     dstack.push(2.3);
     dstack.push(3.141);
     dstack.push(1.1235);
-    // Prints pop: 1.1235
+    // Prints pop: 1.123500
     printf("pop: %f\n", dstack.pop());
 }
 ```
 
-### In what ways do C3 differ from C?
+### In what ways does C3 differ from C?
 
 - No mandatory header files
 - New semantic macro system
 - Module based name spacing
-- Subarrays (slices)
+- Slices
+- Operator overloading
 - Compile time reflection
 - Enhanced compile time execution
 - Generics based on generic modules
@@ -122,130 +136,263 @@ fn void test()
 - Value methods
 - Associated enum data
 - No preprocessor
-- Less undefined behaviour and runtime checks in "safe" mode
+- Less undefined behaviour and added runtime checks in "safe" mode
 - Limited operator overloading to enable userland dynamic arrays
 - Optional pre and post conditions
 
 ### Current status
 
-The current version of the compiler is alpha release 0.2.
+The current stable version of the compiler is **version 0.7.10**.
 
-It's possible to try out the current C3 compiler in the browser: https://ide.judge0.com/ – this is courtesy of the
-developer of Judge0. 
-
-Design work on C3 complete aside from fleshing out details, such as
-inline asm. As the standard library work progresses, changes and improvements
-to the language will happen continuously.
+The upcoming 0.7.x releases will focus on expanding the standard library,
+fixing bugs and improving compile time analysis. 
 Follow the issues [here](https://github.com/c3lang/c3c/issues).
 
 If you have suggestions on how to improve the language, either [file an issue](https://github.com/c3lang/c3c/issues) 
 or discuss C3 on its dedicated Discord: [https://discord.gg/qN76R87](https://discord.gg/qN76R87).
 
-The compiler is currently verified to compile on Linux, Windows and MacOS.
+The compiler is currently verified to compile on Linux, OpenBSD, Windows and MacOS.
 
+**Support matrix**
 
+| Platform                 | Native C3 compiler available? | Target supported        | Stack trace | Threads  | Sockets  | Inline asm |
+|--------------------------|-------------------------------|-------------------------|-------------|----------|----------|------------|
+| Win32 x64                | Yes                           | Yes + cross compilation | Yes         | Yes      | Yes      | Yes*       |
+| Win32 Aarch64            | Untested                      | Untested                | Untested    | Untested | Untested | Yes*       |
+| MacOS x64                | Yes                           | Yes + cross compilation | Yes         | Yes      | Yes      | Yes*       |
+| MacOS Aarch64            | Yes                           | Yes + cross compilation | Yes         | Yes      | Yes      | Yes*       |
+| iOS Aarch64              | No                            | Untested                | Untested    | Yes      | Yes      | Yes*       |
+| Android Aarch64          | No                            | Untested                | Untested    | Untested | Untested | Yes*       |
+| Android x64              | No                            | Untested                | Untested    | Untested | Untested | Yes*       |
+| Linux x86                | Yes                           | Yes                     | Yes         | Yes      | Yes      | Yes*       |
+| Linux x64                | Yes                           | Yes                     | Yes         | Yes      | Yes      | Yes*       |
+| Linux Aarch64            | Yes                           | Yes                     | Yes         | Yes      | Yes      | Yes*       |
+| Linux Riscv32            | Yes                           | Yes                     | Yes         | Yes      | Yes      | Untested   |
+| Linux Riscv64            | Yes                           | Yes                     | Yes         | Yes      | Yes      | Untested   |
+| ELF freestanding x86     | No                            | Untested                | No          | No       | No       | Yes*       |
+| ELF freestanding x64     | No                            | Untested                | No          | No       | No       | Yes*       |
+| ELF freestanding Aarch64 | No                            | Untested                | No          | No       | No       | Yes*       |
+| ELF freestanding Riscv64 | No                            | Untested                | No          | No       | No       | Untested   |
+| ELF freestanding Riscv32 | No                            | Untested                | No          | No       | No       | Untested   |
+| ELF freestanding Xtensa* | No                            | Untested                | No          | No       | No       | Untested   |
+| FreeBSD x86              | Untested                      | Untested                | No          | Yes      | Untested | Yes*       |
+| FreeBSD x64              | Untested                      | Untested                | No          | Yes      | Untested | Yes*       |
+| NetBSD x86               | Untested                      | Untested                | No          | Yes      | Untested | Yes*       |
+| NetBSD x64               | Untested                      | Untested                | No          | Yes      | Untested | Yes*       |
+| OpenBSD x86              | Untested                      | Untested                | No          | Yes      | Untested | Yes*       |
+| OpenBSD x64              | Yes*                          | Yes                     | Yes*        | Yes      | Untested | Yes*       |
+| MCU x86                  | No                            | Untested                | No          | No       | No       | Yes*       |
+| Wasm32                   | No                            | Yes                     | No          | No       | No       | No         |
+| Wasm64                   | No                            | Untested                | No          | No       | No       | No         |
+
+*\* Inline asm is still a work in progress*<br>
+*\* OpenBSD 7.7 is the only tested version*<br>
+*\* OpenBSD has limited stacktrace, needs to be tested further*<br>
+*\* Xtensa support is enabled by compiling with `-DXTENSA_ENABLE`. The [espressif llvm fork](https://github.com/espressif/llvm-project) is recommended for best compatibility*
+
+More platforms will be supported in the future.
 
 #### What can you help with?
 
 - If you wish to contribute with ideas, please file issues or discuss on Discord.
 - Interested in contributing to the stdlib? Please get in touch on Discord.
-- Install instructions for other Linux and Unix variants are appreciated.
-- Would you like to contribute bindings to some library? It would be nice to have support for SDL, Raylib and more.
+- Compilation instructions for other Linux and Unix variants are appreciated.
+- Would you like to contribute bindings to some library? It would be nice to have support for SDL3 and more. If you have created some bindings, please submit them to https://github.com/c3lang/vendor.  
 - Build something with C3 and show it off and give feedback. The language is still open for significant tweaks.
 - Start work on the C -> C3 converter which takes C code and does a "best effort" to translate it to C3. The first version only needs to work on C headers.
 - Do you have some specific area you have deep knowledge of and could help make C3 even better at doing? File or comment on issues.
 
 ### Installing
 
-#### Installing on Windows
+This installs the latest prerelease build, as opposed to the latest released version.
 
-1. Make sure you have Visual Studio 17 2022 installed.
-2. Install CMake
-3. Clone the C3C github repository: `git clone https://github.com/c3lang/c3c.git`
-4. Enter the C3C directory `cd c3c`.
-5. Set up the CMake build `cmake -B build -G "Visual Studio 17 2022" -A x64 -DCMAKE_BUILD_TYPE=Release`
-6. Build: `cmake --build build --config Release`
-7. You should now have the c3c.exe
+#### Installing on Windows with precompiled binaries
+1. Download the zip file: [https://github.com/c3lang/c3c/releases/download/latest-prerelease-tag/c3-windows.zip](https://github.com/c3lang/c3c/releases/download/latest-prerelease-tag/c3-windows.zip)
+   (debug version [here](https://github.com/c3lang/c3c/releases/download/latest-prerelease-tag/c3-windows-debug.zip))
+2. Unzip exe and standard lib.
+3. If you don't have Visual Studio 17 installed you can either do so, or run the `msvc_build_libraries.py` Python script which will download the necessary files to compile on Windows. 
+4. Run `c3c.exe`.
 
-You should now have a `c3c` executable.
+#### Installing on Windows with the install script
 
-You can try it out by running some sample code: `c3c.exe compile ../resources/examples/hash.c3`
+Open a PowerShell terminal (you may need to run it as an administrator) and run the following command:
+```bash
+iwr -useb https://raw.githubusercontent.com/c3lang/c3c/refs/heads/master/install/install.ps1 | iex
+```
+The script will inform you once the installation is successful and add the `~/.c3` directory to your PATH, which will allow you to run the c3c command from any location.
+
+You can choose another version with option `C3_VERSION`.
+For example, you can force the installation of the 0.7.4 version:
+```bash
+$env:C3_VERSION='0.7.4'; powershell -ExecutionPolicy Bypass -Command "iwr -useb https://raw.githubusercontent.com/c3lang/c3c/refs/heads/master/install/install.ps1 | iex"
+```
+
+If you don't have Visual Studio 17 installed you can either do so, or run the `msvc_build_libraries.py` Python script which will download the necessary files to compile on Windows.
+
+
+#### Installing on Debian with precompiled binaries
+1. Download tar file: [https://github.com/c3lang/c3c/releases/download/latest-prerelease-tag/c3-linux.tar.gz](https://github.com/c3lang/c3c/releases/download/latest-prerelease-tag/c3-linux.tar.gz)
+   (debug version [here](https://github.com/c3lang/c3c/releases/download/latest-prerelease-tag/c3-linux-debug.tar.gz))
+2. Unpack executable and standard lib.
+3. Run `./c3c`.
+
+#### Installing on Debian with the install script
+
+Open a terminal and run the following command:
+```bash
+curl -fsSL https://raw.githubusercontent.com/c3lang/c3c/refs/heads/master/install/install.sh | bash
+```
+The C3 compiler will be installed, and the script will also update your ~/.bashrc to include `~/.c3` in your PATH, allowing you to invoke the c3c command from anywhere. You might need to restart your terminal or source your shell for the changes to take effect.
+
+You can choose another version with option `C3_VERSION`.
+For example, you can force the installation of the 0.7.4 version:
+```bash
+curl -fsSL https://raw.githubusercontent.com/c3lang/c3c/refs/heads/master/install/install.sh | C3_VERSION=0.7.4 bash
+```
+
+#### Installing on Ubuntu with precompiled binaries
+1. Download tar file: [https://github.com/c3lang/c3c/releases/download/latest-prerelease-tag/c3-ubuntu-20.tar.gz](https://github.com/c3lang/c3c/releases/download/latest-prerelease-tag/c3-ubuntu-20.tar.gz)
+   (debug version [here](https://github.com/c3lang/c3c/releases/download/latest-prerelease-tag/c3-ubuntu-20-debug.tar.gz))
+2. Unpack executable and standard lib.
+3. Run `./c3c`.
+
+#### Installing on MacOS with precompiled binaries
+1. Make sure you have XCode with command line tools installed.
+2. Download the zip file: [https://github.com/c3lang/c3c/releases/download/latest-prerelease-tag/c3-macos.zip](https://github.com/c3lang/c3c/releases/download/latest-prerelease-tag/c3-macos.zip)
+   (debug version [here](https://github.com/c3lang/c3c/releases/download/latest-prerelease-tag/c3-macos-debug.zip))
+3. Unzip executable and standard lib.
+4. Run `./c3c`.
+
+(*Note that there is a known issue with debug symbol generation on MacOS 13, see [issue #1086](https://github.com/c3lang/c3c/issues/1086))
+
+#### Installing on OpenBSD with precompiled binaries
+1. Download tar file: [https://github.com/c3lang/c3c/releases/download/latest-prerelease-tag/c3-openbsd.tar.gz](https://github.com/c3lang/c3c/releases/download/latest-prerelease-tag/c3-openbsd.tar.gz)
+   (debug version [here](https://github.com/c3lang/c3c/releases/download/latest-prerelease-tag/c3-openbsd-debug.tar.gz))
+2. Unpack executable and standard lib.
+3. Run `./c3c`.
+
+(*Note that this is specifically for OpenBSD 7.7, running it on any other version is prone to ABI breaks)
 
 #### Installing on Arch Linux
-There is an AUR package for the C3C compiler : [c3c-git](https://aur.archlinux.org/packages/c3c-git)  
-You can use your AUR package manager or clone it manually:  
+Arch includes c3c in the official 'extra' repo. It can be easily installed the usual way:
+
+```sh
+sudo pacman -S c3c
+# or paru -S c3c
+# or yay -S c3c
+# or aura -A c3c
+```
+
+There is also an AUR package for the c3c compiler : [c3c-git](https://aur.archlinux.org/packages/c3c-git).
+
+You can use your AUR package manager:
+```sh
+paru -S c3c-git
+# or yay -S c3c-git
+# or aura -A c3c-git
+```
+
+Or clone it manually:
 ```sh
 git clone https://aur.archlinux.org/c3c-git.git
 cd c3c-git
 makepkg -si
 ```
 
-#### Installing on Ubuntu 20.10
+#### Installing via Nix
 
-1. Make sure you have a C compiler that handles C11 and a C++ compiler, such as GCC or Clang. Git also needs to be installed.
-2. Install CMake: `sudo apt install cmake`
-3. Install LLVM 12 (or greater: C3C supports LLVM 12-15): `sudo apt-get install clang-12 zlib1g zlib1g-dev libllvm12 llvm-12 llvm-12-dev llvm-12-runtime liblld-12-dev liblld-12`
-4. Clone the C3C github repository: `git clone https://github.com/c3lang/c3c.git`
-5. Enter the C3C directory `cd c3c`.
-6. Create a build directory `mkdir build`
-7. Change directory to the build directory `cd build`
-8. Set up CMake build: `cmake ..`
-9. Build: `cmake --build .`
+You can access `c3c` via [flake.nix](./flake.nix), which will contain the latest commit of the compiler. To add `c3c` to your `flake.nix`, do the following:
+```nix
+{
+  inputs = {
+    nixpkgs.url = "github:nixos/nixpkgs?ref=nixpkgs-unstable";
+    flake-utils.url = "github:numtide/flake-utils";
+    c3c.url = "github:c3lang/c3c";
+    # Those are desired if you don't want to copy extra nixpkgs
+    c3c.inputs = {
+      nixpkgs.follows = "nixpkgs";
+      flake-utils.follows = "flake-utils";
+    };
+  };
 
-You should now have a `c3c` executable.
+  outputs = { self, ... } @ inputs: inputs.flake-utils.lib.eachDefaultSystem (system: 
+    let 
+      pkgs = import inputs.nixpkgs { inherit system; };
+      c3c = inputs.c3c.packages.${system}.c3c;
+    in 
+    {
+      devShells.default = pkgs.mkShell {
+        buildInputs = [
+          pkgs.c3c
+        ];
+      };
+    }
+  );
+}
+```
 
-You can try it out by running some sample code: `./c3c compile ../resources/examples/hash.c3`
+### Installing on Gentoo
+
+`c3c` is available in the [Gentoo GURU overlay](https://wiki.gentoo.org/wiki/Project:GURU).
+
+Enable and sync the GURU repository (if not already done):
+
+```sh
+sudo eselect repository enable guru
+sudo emaint sync -r guru
+```
+
+Install `c3c` with:
+
+```sh
+sudo emerge -av dev-lang/c3c
+```
+
+* The compiler binary is installed to `/usr/bin/c3c`.
+* The standard library is installed to `/usr/lib/c3`.
+
+For Gentoo-specific issues, please use the [Gentoo Bugzilla](https://bugs.gentoo.org/) (Product: *GURU*).
 
 #### Building via Docker
 
-You can build `c3c` using either an Ubuntu 18.04 or 20.04 container:
+You can build `c3c` using an Ubuntu container. By default, the script will build through Ubuntu 22.04. You can specify the version by passing the `UBUNTU_VERSION` environment variable.
 
 ```
-./build-with-docker.sh 18
+UBUNTU_VERSION=20.04 ./build-with-docker.sh
 ```
 
-Replace `18` with `20` to build through Ubuntu 20.04.
-
-For a release build specify:
-```
-./build-with-docker.sh 20 Release
-```
-
-A `c3c` executable will be found under `bin/`.
+See the `build-with-docker.sh` script for more information on other configurable environment variables.
 
 #### Installing on OS X using Homebrew
 
-2. Install CMake: `brew install cmake`
-3. Install LLVM 13: `brew install llvm`
-4. Clone the C3C github repository: `git clone https://github.com/c3lang/c3c.git`
-5. Enter the C3C directory `cd c3c`.
-6. Create a build directory `mkdir build`
-7. Change directory to the build directory `cd build`
-8. Set up CMake build for debug: `cmake ..`
-9. Build: `cmake --build .`
+1. Install [Homebrew](https://brew.sh/)
+2. Install LLVM 17+: `brew install llvm`
+3. Install lld: `brew install lld`
+4. Install CMake: `brew install cmake`
+5. Clone the C3C github repository: `git clone https://github.com/c3lang/c3c.git`
+6. Enter the C3C directory `cd c3c`.
+7. Set up CMake build for debug: `cmake -B build -S .`
+8. Build: `cmake --build build`
+9. Change directory to the build directory `cd build`
 
-#### Installing on other Linux / Unix variants
+#### Installing on Windows using Scoop
+
+c3c is included in 'Main' bucket.
+
+```sh
+scoop install c3
+```
 
-1. Install CMake.
-2. Install or compile LLVM and LLD *libraries* (version 12+ or higher)
-3. Clone the C3C github repository: `git clone https://github.com/c3lang/c3c.git`
-4. Enter the C3C directory `cd c3c`.
-5. Create a build directory `mkdir build`
-6. Change directory to the build directory `cd build`
-7. Set up CMake build for debug: `cmake ..`. At this point you may need to manually 
-provide the link path to the LLVM CMake directories, e.g. `cmake -DLLVM_DIR=/usr/local/opt/llvm/lib/cmake/llvm/ ..`
-8. Build: `cmake --build .`
- 
 #### Getting started with a "hello world"
 
 Create a `main.c3` file with:
-```c++
+```c3
 module hello_world;
 import std::io;
 
 fn void main()
 {
-   io::println("Hello, world!");
+   io::printn("Hello, world!");
 }
 ```
 
@@ -256,13 +403,154 @@ Then run
 c3c compile main.c3
 ```
 
-The generated binary will be called `a.out`.
+The generated binary will by default be named after the module that contains the main
+function. In our case that is `hello_world`, so the resulting binary will be
+called `hello_world` or `hello_world.exe`depending on platform.
+
+### Compiling
+
+#### Compiling on Windows
+
+1. Make sure you have Visual Studio 17 2022 installed or alternatively install the "Buildtools for Visual Studio" (https://aka.ms/vs/17/release/vs_BuildTools.exe) and then select "Desktop development with C++"
+2. Install CMake
+3. Clone the C3C github repository: `git clone https://github.com/c3lang/c3c.git`
+4. Enter the C3C directory: `cd c3c`.
+5. Set up the CMake build: `cmake --preset windows-vs-2022-release`
+6. Build: `cmake --build --preset windows-vs-2022-release`
+
+You should now have a `c3c` executable in `build\Release`.
+
+You can try it out by running some sample code: `c3c.exe compile ../../resources/examples/hash.c3`
+
+Building `c3c` using Visual Studio Code is also supported when using the `CMake Tools` extension. Simply select the `Windows x64 Visual Studio 17 2022` configure preset and build.
+
+*Note that if you run into linking issues when building, make sure that you are using the latest version of VS17.*
+
+#### Compiling on Windows (Debug)
+
+Debug build requires a different set of LLVM libraries to be loaded for which a separate CMake configuration is used to avoid conflicts.
+1. Configure: `cmake --preset windows-vs-2022-debug`
+2. Build: `cmake --build --preset windows-vs-2022-debug`
+
+You should now have a `c3c` executable in `build-debug\Debug`.
+
+#### Compiling on Ubuntu 24.04 LTS
+
+1. Make sure you have a C compiler that handles C11 and a C++ compiler, such as GCC or Clang. Git also needs to be installed.
+2. Install LLVM 18 `sudo apt-get install cmake git clang zlib1g zlib1g-dev libllvm18 llvm llvm-dev llvm-runtime liblld-dev liblld-18 libpolly-18-dev`. If you're using Ubuntu 25.04, also install `libpolly-20-dev`.
+3. Clone the C3C github repository: `git clone https://github.com/c3lang/c3c.git`
+4. Enter the C3C directory `cd c3c`.
+5. Set up CMake build: `cmake -B build -S .`
+6. Build: `cmake --build build`
+7. Change directory to the build directory `cd build`
+
+You should now have a `c3c` executable.
+
+You can try it out by running some sample code: `./c3c compile ../resources/examples/hash.c3`
+
+
+#### Compiling on Void Linux
+
+1. As root, ensure that all project dependencies are installed: `xbps-install git cmake llvm17 llvm17-devel lld17-devel libcurl-devel ncurses-devel zlib-devel libzstd-devel libxml2-devel`
+2. Clone the C3C repository: `git clone https://github.com/c3lang/c3c.git`
+    - If you only need the latest commit, you may want to make a shallow clone instead: `git clone https://github.com/c3lang/c3c.git --depth=1`
+3. Enter the directory: `cd c3c`
+4. Create the CMake build cache: `cmake -B build -S .`
+5. Build: `cmake --build build`
+6. Enter the build directory: `cd build`
+
+Your c3c executable should have compiled properly. You may want to test it: `./c3c compile ../resources/examples/hash.c3`  
+For a system-wide installation, run the following as root: `cmake --install .`
+
+
+#### Compiling on Fedora
+
+1. Install required project dependencies: `dnf install cmake clang git llvm llvm-devel lld lld-devel ncurses-devel`
+2. Optionally, install additional dependencies: `dnf install libcurl-devel zlib-devel libzstd-devel libxml2-devel libffi-devel`
+3. Clone the C3C repository: `git clone https://github.com/c3lang/c3c.git`
+    - If you only need the latest commit, you may want to make a shallow clone: `git clone https://github.com/c3lang/c3c.git --depth=1`
+4. Enter the C3C directory: `cd c3c`
+5. Create the CMake build cache. The Fedora repositories provide `.so` libraries for lld, so you need to set the C3_LINK_DYNAMIC flag: `cmake -B build -S . -DC3_LINK_DYNAMIC=1`
+6. Build the project: `cmake --build build`
+7. Enter the build directory: `cd build`
+
+The c3c binary should be created in the build directory. You can try it out by running some sample code: `./c3c compile ../resources/examples/hash.c3`
+
+#### Compiling on Arch Linux
+
+1. Install required project dependencies: `sudo pacman -S curl lld llvm-libs clang cmake git libedit llvm libxml2`
+2. Clone the C3C repository: `git clone https://github.com/c3lang/c3c.git`
+    - If you only need the latest commit, you may want to make a shallow clone: `git clone https://github.com/c3lang/c3c.git --depth=1`
+3. Enter the C3C directory: `cd c3c`
+4. Create the CMake build cache:
+```bash
+cmake -B build \
+    -D C3_LINK_DYNAMIC=ON \
+    -D CMAKE_BUILD_TYPE=Release
+```
+5. Build the project: `cmake --build build`.
+
+After compilation, the `c3c` binary will be located in the `build` directory. You can test it by compiling an example: `./build/c3c compile resources/examples/ls.c3`.
+
+6. To install the compiler globally: `sudo cmake --install build`
+
+#### Compiling on NixOS
+
+1. Enter nix shell, by typing `nix develop` in root directory
+2. Configure cmake via `cmake . -Bbuild $=C3_CMAKE_FLAGS`. Note: passing `C3_CMAKE_FLAGS` is needed in due to generate `compile_commands.json` and find missing libs.
+4. Build it `cmake --build build`
+5. Test it out: `./build/c3c -V`
+6. If you use `clangd` lsp server for your editor, it is recommended to make a symbolic link to `compile_command.json` in the root: `ln -s ./build/compile_commands.json compile_commands.json`
+
+#### Compiling on other Linux / Unix variants
+
+1. Install CMake.
+2. Install or compile LLVM and LLD *libraries* (version 17+ or higher)
+3. Clone the C3C github repository: `git clone https://github.com/c3lang/c3c.git`
+4. Enter the C3C directory `cd c3c`.
+5. Set up CMake build for debug: `cmake -B build -S .`. At this point you may need to manually 
+provide the link path to the LLVM CMake directories, e.g. `cmake -B build -S . -DLLVM_DIR=/usr/local/opt/llvm/lib/cmake/llvm/`
+6. Build: `cmake --build build`
+7. Change directory to the build directory `cd build`
+
+*A note on compiling for Linux/Unix/MacOS: to be able to fetch vendor libraries
+libcurl is needed. The CMake script should detect it if it is available. Note that
+this functionality is non-essential and it is perfectly fine to use the compiler without it.*
 
 #### Licensing
 
-The C3 compiler is licensed under LGPL 3.0, the standard library itself is
-MIT licensed.
+Unless specified otherwise, the code in this repository is MIT licensed.
+The exception is the compiler source code (the source code under `src`),
+which is licensed under LGPL 3.0. 
+
+This means you are free to use all parts of standard library, 
+tests, benchmarks, grammar, examples and so on under the MIT license, including 
+using those libraries and tests if you build your own C3 compiler.
 
 #### Editor plugins
 
 Editor plugins can be found at https://github.com/c3lang/editor-plugins.
+
+#### Contributing unit tests
+
+1. Write the test, either adding to existing test files in `/test/unit/` or add
+   a new file. (If testing the standard library, put it in the `/test/unit/stdlib/` subdirectory).
+2. Make sure that the test functions have the `@test` attribute. 
+3. Run tests and see that they pass. (Recommended settings: `c3c compile-test -O0 test/unit`.
+   - in this example `test/unit/` is the relative path to the test directory, so adjust as required)
+4. Make a pull request for the new tests.
+
+## Thank yous
+
+A huge **THANK YOU** goes out to all contributors and sponsors.
+
+A special thank you to sponsors [Zack Puhl](https://github.com/NotsoanoNimus) and [konimarti](https://github.com/konimarti) for going the extra mile.
+
+And honorable mention goes to past sponsors:
+[Ygor Pontelo](https://github.com/ygorpontelo), [Simone Raimondi](https://github.com/SRaimondi),
+[Jan Válek](https://github.com/jan-valek), [Pierre Curto](https://github.com/pierrec), 
+[Caleb-o](https://github.com/Caleb-o) and [devdad](https://github.com/devdad)
+
+## Star History
+
+[![Star History Chart](https://api.star-history.com/svg?repos=c3lang/c3c&type=Date)](https://www.star-history.com/#c3lang/c3c&Date)

benchmarks/stdlib/collections/hashmap.c3

@@ -0,0 +1,219 @@
+// Copyright (c) 2025 Zack Puhl <github@xmit.xyz>. All rights reserved.
+// Use of this source code is governed by the MIT license
+// a copy of which can be found in the LICENSE_STDLIB file.
+//
+// Some benchmark test ideas are sourced from this article on C++ hashmap benchmarking:
+//   https://martin.ankerl.com/2022/08/27/hashmap-bench-01/
+//
+module hashmap_benchmarks;
+
+import std::collections::map;
+import std::math::random;
+
+
+const DEFAULT_ITERATIONS = 16384;
+
+Lcg64Random rand;
+
+HashMap { int, int } modifying_numbers_random;
+
+fn void bench_setup() @init
+{
+	set_benchmark_warmup_iterations(3);
+	set_benchmark_max_iterations(DEFAULT_ITERATIONS);
+
+	// TODO: Cannot take the address of a @benchmark function. If we could, we could pass &insert_erase as a fn ptr and use the $qnameof CT eval internally.
+	set_benchmark_func_iterations($qnameof(insert_erase), 32);
+	set_benchmark_func_iterations($qnameof(random_access), 1024);
+
+    random::seed(&rand, 0x4528_21e6_38d0_1377);
+
+    for (usz i = 0; i < 1_000; ++i) modifying_numbers_random.set(rand.next_int(), rand.next_int());
+}
+
+
+// ==============================================================================================
+module hashmap_benchmarks @benchmark;
+
+import std::collections::map;
+
+import std::math::random;
+import std::encoding::base64;
+
+
+fn void generic_hash_speeds()
+{
+	(char){}.hash();
+	(char[<100>]){}.hash();
+	(char[100]){}.hash();
+	(ichar){}.hash();
+	(ichar[<100>]){}.hash();
+	(ichar[100]){}.hash();
+	(short){}.hash();
+	(short[<100>]){}.hash();
+	(short[100]){}.hash();
+	(ushort){}.hash();
+	(ushort[<100>]){}.hash();
+	(ushort[100]){}.hash();
+	(int){}.hash();
+	(int[<100>]){}.hash();
+	(int[100]){}.hash();
+	(uint){}.hash();
+	(uint[<100>]){}.hash();
+	(uint[100]){}.hash();
+	(long){}.hash();
+	(long[<20>]){}.hash();
+	(long[100]){}.hash();
+	(ulong){}.hash();
+	(ulong[<20>]){}.hash();
+	(ulong[100]){}.hash();
+	(int128){}.hash();
+	(int128[<20>]){}.hash();
+	(int128[100]){}.hash();
+	(uint128){}.hash();
+	(uint128[<20>]){}.hash();
+	(uint128[100]){}.hash();
+	(bool){}.hash();
+	(bool[<100>]){}.hash();
+	(bool[100]){}.hash();
+	String x = "abc";
+	char[] y = "abc";
+	assert(x.hash() == y.hash());
+	String z1 = "This is a much longer string than the above value because longer values lead to longer hashing times.";
+	char[] z2 = "This is a much longer string than the above value because longer values lead to longer hashing times.";
+	assert(z1.hash() == z2.hash());
+	assert(int.typeid.hash());
+}
+
+
+fn void hash_speeds_of_many_random_values() => @pool()
+{
+	var $arrsz = 10_000;
+	uint fake_checksum;
+
+	char[] chars = allocator::new_array(tmem, char, $arrsz)[:$arrsz];
+	foreach (&v : chars) *v = (char)random::next(&rand, uint.max);
+
+	ushort[] shorts = allocator::new_array(tmem, ushort, $arrsz)[:$arrsz];
+	foreach (&v : shorts) *v = (ushort)random::next(&rand, uint.max);
+
+	uint[] ints = allocator::new_array(tmem, uint, $arrsz)[:$arrsz];
+	foreach (&v : ints) *v = random::next(&rand, uint.max);
+
+	ulong[] longs = allocator::new_array(tmem, ulong, $arrsz)[:$arrsz];
+	foreach (&v : longs) *v = (ulong)random::next(&rand, uint.max);
+
+	uint128[] vwideints = allocator::new_array(tmem, uint128, $arrsz)[:$arrsz];
+	foreach (&v : vwideints) *v = (uint128)random::next(&rand, uint.max);
+
+	char[48][] zstrs = allocator::new_array(tmem, char[48], $arrsz)[:$arrsz];
+
+	String[] strs = mem::temp_array(String, $arrsz);
+	foreach (x, &v : zstrs)
+	{
+		foreach (&c : (*v)[:random::next(&rand, 48)]) *c = (char)random::next(&rand, char.max);
+		strs[x] = ((ZString)&v[0]).str_view();
+	}
+
+	runtime::@start_benchmark();
+	foreach (v : chars) fake_checksum += v.hash();
+	foreach (v : shorts) fake_checksum += v.hash();
+	foreach (v : ints) fake_checksum += v.hash();
+	foreach (v : longs) fake_checksum += v.hash();
+	foreach (v : vwideints) fake_checksum += v.hash();
+	foreach (v : strs) fake_checksum += v.hash();
+	runtime::@end_benchmark();
+}
+
+
+fn void modifying_numbers_init_from_map() => @pool()
+{
+	HashMap { int, int } v;
+	v.tinit_from_map(&modifying_numbers_random);
+	v.free();
+}
+
+
+fn void insert_erase() => @pool()
+{
+	uint iters = 1_000_000;
+	HashMap { int, int } v;
+	v.tinit();
+
+	runtime::@start_benchmark();
+	for (int i = 0; i < iters; ++i) v[i] = i;
+	for (int i = 0; i < iters; ++i) v.remove(i);
+
+	runtime::@end_benchmark();
+
+	v.free();
+}
+
+
+fn void random_access() => @pool()
+{
+	HashMap { int, int } v;
+	v.tinit();
+
+	uint bound = 10_000;
+	usz pseudo_checksum = 0;
+
+	for (uint i = 0; i < bound; ++i) v[i] = i;
+
+	runtime::@start_benchmark();
+	for (uint i = 0; i < 1_000_000; ++i) pseudo_checksum += (v[i.hash() % bound] ?? 0);
+	runtime::@end_benchmark();
+
+	v.free();
+}
+
+
+fn void random_access_erase() => @pool()
+{
+	HashMap { int, int } v;
+	v.tinit();
+
+	uint bound = 10_000;
+
+	for (uint i = 0; i < bound; ++i) v[i] = i;
+
+	runtime::@start_benchmark();
+	for (uint i = 0; i < bound; ++i)
+	{
+		v[i.hash() % bound] = i;   // supplant an entry
+
+		v.remove(random::next(&rand, bound));   // remove a random entry
+	}
+	runtime::@end_benchmark();
+
+	v.free();
+}
+
+
+fn void random_access_string_keys() => @pool()
+{
+	HashMap { String, ulong } v;
+	v.tinit();
+
+	usz pseudo_checksum = 0;
+	String[] saved = mem::temp_array(String, 5_000);
+
+	for (usz i = 0; i < saved.len; ++i)
+	{
+		ulong hash = i.hash();
+		String b64key = base64::tencode(@as_char_view(hash));
+
+		v[b64key] = hash;
+
+		if (i < saved.len) saved[i] = b64key;
+	}
+
+	runtime::@start_benchmark();
+	for (usz i = 0; i < saved.len; ++i)
+	{
+		pseudo_checksum += v[ saved[random::next(&rand, saved.len)] ]!! % 512;
+	}
+	runtime::@end_benchmark();
+
+	v.free();
+}

benchmarks/stdlib/collections/linkedlist.c3

@@ -0,0 +1,38 @@
+module linkedlist_benchmarks;
+
+import std::collections::linkedlist;
+
+
+LinkedList{int} long_list;
+const HAY = 2;
+const NEEDLE = 1000;
+
+fn void bench_setup() @init
+{
+	set_benchmark_warmup_iterations(3);
+	set_benchmark_max_iterations(4096);
+
+    int[*] haystack = { [0..999] = HAY };
+    long_list = linkedlist::@new{int}(mem, haystack[..]);
+    long_list.push(NEEDLE);
+    long_list.push_all(haystack[..]);
+}
+
+
+// ==============================================================================================
+module linkedlist_benchmarks @benchmark;
+
+String die_str = "Failed to find the value `1`. Is something broken?";
+
+
+fn void foreach_iterator()
+{
+    foreach (v : long_list.array_view()) if (v == NEEDLE) return;
+    runtime::@kill_benchmark(die_str);
+}
+
+fn void foreach_r_iterator()
+{
+    foreach_r (v : long_list.array_view()) if (v == NEEDLE) return;
+    runtime::@kill_benchmark(die_str);
+}

benchmarks/stdlib/compression/deflate.c3

@@ -0,0 +1,51 @@
+module deflate_benchmarks;
+import std::compression::deflate;
+
+const uint SMALL_ITERATIONS = 50000;
+const uint LARGE_ITERATIONS = 100;
+
+// Data to compress
+const char[] SMALL_DATA = { [0..1023] = 'A' };
+const char[] LARGE_DATA = { [0..1048575] = 'B' };
+
+char[] small_compressed;
+char[] large_compressed;
+
+fn void initialize_bench() @init
+{
+	small_compressed = deflate::compress(mem, SMALL_DATA)!!;
+	large_compressed = deflate::compress(mem, LARGE_DATA)!!;
+	set_benchmark_warmup_iterations(2);
+	set_benchmark_max_iterations(10);
+
+	set_benchmark_func_iterations($qnameof(deflate_compress_small), SMALL_ITERATIONS);
+	set_benchmark_func_iterations($qnameof(deflate_decompress_small), SMALL_ITERATIONS);
+	set_benchmark_func_iterations($qnameof(deflate_compress_large), LARGE_ITERATIONS);
+	set_benchmark_func_iterations($qnameof(deflate_decompress_large), LARGE_ITERATIONS);
+}
+
+// =======================================================================================
+module deflate_benchmarks @benchmark;
+
+import std::compression::deflate;
+import std::core::mem;
+
+fn void deflate_compress_small() => @pool()
+{
+	char[]? compressed = deflate::compress(tmem, SMALL_DATA);
+}
+
+fn void deflate_decompress_small() => @pool()
+{
+	char[]? decompressed = deflate::decompress(tmem, small_compressed);
+}
+
+fn void deflate_compress_large() => @pool()
+{
+	char[]? compressed = deflate::compress(tmem, LARGE_DATA);
+}
+
+fn void deflate_decompress_large() => @pool()
+{
+	char[]? decompressed = deflate::decompress(tmem, large_compressed);
+}

benchmarks/stdlib/core/string_trim.c3

@@ -0,0 +1,46 @@
+module string_trim_wars;
+
+const String WHITESPACE_TARGET = "    \n\t\r\f\va \tbcde\v\f\r\t\n    ";
+const String WHITESPACE_NUMERIC_TARGET = " 25290   0969  99a \tbcde12332 34 43          0000";
+
+fn void initialize_bench() @init
+{
+	set_benchmark_warmup_iterations(64);
+	set_benchmark_max_iterations(1 << 24);
+}
+
+macro void trim_bench($trim_str, String $target = WHITESPACE_TARGET) => @pool()
+{
+	String s1;
+	String s2 = $target.tcopy();
+
+	runtime::@start_benchmark();
+
+	$switch:
+	$case $typeof($trim_str) == String:
+		s1 = s2.trim($trim_str);
+	$case $typeof($trim_str) == AsciiCharset:
+		s1 = s2.trim_charset($trim_str);
+	$default: $error "Unable to determine the right String `trim` operation to use.";
+	$endswitch
+
+	@volatile_load(s1);
+
+	runtime::@end_benchmark();
+}
+
+
+module string_trim_wars @benchmark;
+
+fn void trim_control() => trim_bench(" ");   // only spaces
+
+fn void trim_whitespace_default() => trim_bench("\t\n\r ");   // default set
+fn void trim_whitespace_default_ordered() => trim_bench(" \n\t\r");   // default \w set, but ordered by expected freq
+
+fn void trim_whitespace_bad() => trim_bench("\f\v\n\t\r ");   // bad-perf ordering, all \w
+
+fn void trim_whitespace_ordered_extended() => trim_bench(" \n\t\r\f\v");   // proposed ordering, all \w
+fn void trim_charset_whitespace() => trim_bench(ascii::WHITESPACE_SET);   // use charset, all \w
+
+fn void trim_many() => trim_bench(" \n\t\r\f\v0123456789", WHITESPACE_NUMERIC_TARGET);   // ordered, all \w + num
+fn void trim_charset_many() => trim_bench(ascii::WHITESPACE_SET | ascii::NUMBER_SET, WHITESPACE_NUMERIC_TARGET);   // set, all \w + num

benchmarks/stdlib/crypto/aes_bench.c3

@@ -0,0 +1,31 @@
+module std::crypto::aes_bench;
+
+import std::crypto::aes;
+
+fn void init() @init
+{
+	set_benchmark_warmup_iterations(5);
+	set_benchmark_max_iterations(10_000);
+}
+
+
+AesType aes   = AES256;
+char[] key    = x"603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4";
+char[] text   = x"6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710";
+char[] cipher = x"601ec313775789a5b7a7f504bbf3d228f443e3ca4d62b59aca84e990cacaf5c52b0930daa23de94ce87017ba2d84988ddfc9c58db67aada613c2dd08457941a6";
+char[16] iv     = x"f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff";
+
+fn void bench_ctr_xcrypt() @benchmark
+{
+	char[64] out;
+	Aes ctx;
+
+	// encrypt
+	ctx.init(aes, key, iv);
+	ctx.encrypt_buffer(text, &out);
+
+	// decrypt
+	ctx.init(aes, key, iv);
+	ctx.decrypt_buffer(cipher, &out);
+}
+

benchmarks/stdlib/crypto/chacha20.c3

@@ -0,0 +1,39 @@
+// Copyright (c) 2025 Zack Puhl <github@xmit.xyz>. All rights reserved.
+// Use of this source code is governed by the MIT license
+// a copy of which can be found in the LICENSE_STDLIB file.
+module chacha20_benchmarks;
+
+import std::crypto::chacha20;
+
+
+fn void initialize_bench() @init
+{
+	set_benchmark_warmup_iterations(3);
+	set_benchmark_max_iterations(1024);
+}
+
+const char[] KEY = x'98bef1469be7269837a45bfbc92a5a6ac762507cf96443bf33b96b1bd4c6f8f6';
+const char[] NONCE = x'44e792d63335abb1582e9253';
+const uint COUNTER = 42;
+
+char[] one_mb @align(ulong.sizeof) = { [0..1024*1024] = 0xA5 };
+
+// This doesn't test both encryption + decryption, because it's a symmetric operation that shares
+//   a single common data transformation. Testing one limb is enough.
+fn void gogo_chacha20() @benchmark
+{
+	chacha20::encrypt_mut(one_mb[..], KEY, NONCE, COUNTER);
+}
+
+// Check what the speed of an unligned buffer looks like.
+fn void gogo_chacha20_unaligned() @benchmark => @pool()
+{
+    char[] copy = mem::talloc_array(char, one_mb.len + 3);
+    char[] im_off_slightly = copy[3..];
+    copy[3..] = one_mb[..];
+    assert((usz)im_off_slightly.ptr % usz.sizeof > 0);
+
+    runtime::@start_benchmark();
+	chacha20::encrypt_mut(im_off_slightly, KEY, NONCE, COUNTER);
+    runtime::@end_benchmark();
+}

benchmarks/stdlib/crypto/crypto_shootout.c3

@@ -0,0 +1,113 @@
+// Copyright (c) 2025 Zack Puhl <github@xmit.xyz>. All rights reserved.
+// Use of this source code is governed by the MIT license
+// a copy of which can be found in the LICENSE_STDLIB file.
+module crypto_hash_benchmarks;
+
+import std::collections::pair;
+
+
+const usz COMMON_ITERATIONS = 1 << 17;
+
+char* common_1mib_ptr;
+char[] common_16;
+char[] common_256;
+char[] common_4kib;
+char[] common_1mib;
+
+fn void initialize_bench() @init
+{
+	set_benchmark_warmup_iterations(3);
+	set_benchmark_max_iterations(COMMON_ITERATIONS + 3);
+
+	common_1mib_ptr = mem::alloc_array(char, 1024*1024);
+	common_1mib = common_1mib_ptr[:1024*1024];
+	common_1mib[..] = 0xA5;
+
+	common_16 = common_1mib[:16];
+	common_256 = common_1mib[:256];
+	common_4kib = common_1mib[:4096];
+
+	static String[] function_prefixes = {
+		$qnameof(md5_16)[..^4],
+		$qnameof(sha1_16)[..^4],
+		$qnameof(sha2_256_16)[..^4],
+		$qnameof(sha2_512_16)[..^4],
+		//$qnameof(blake2s_256_16)[..^4],
+		//$qnameof(blake2b_256_16)[..^4],
+		$qnameof(blake3_16)[..^4],
+		$qnameof(ripemd_160_16)[..^4],
+		$qnameof(whirlpool_16)[..^4],
+		$qnameof(streebog_256_16)[..^4],
+		$qnameof(streebog_512_16)[..^4],
+	};
+
+	static Pair{ String, uint }[] to_iters = {
+		{ "_4kib", 1 << 15 },
+		{ "_1mib", 1024 },
+	};
+
+	foreach (p : to_iters)
+	{
+		foreach (name : function_prefixes) set_benchmark_func_iterations(name.tconcat(p.first), p.second);
+	}
+}
+
+fn void teardown_bench() @finalizer
+{
+	mem::free(common_1mib_ptr);
+}
+
+
+// =======================================================================================
+module crypto_hash_benchmarks @benchmark;
+
+import std::hash;
+
+
+fn void md5_16() => md5::hash(common_16);
+fn void sha1_16() => sha1::hash(common_16);
+fn void sha2_256_16() => sha256::hash(common_16);
+fn void sha2_512_16() => sha512::hash(common_16);
+//fn void blake2s_256_16() => blake2::s(256, common_16);
+//fn void blake2b_256_16() => blake2::b(256, common_16);
+fn void blake3_16() => blake3::hash(common_16);
+fn void ripemd_160_16() => ripemd::hash{160}(common_16);
+fn void whirlpool_16() => whirlpool::hash(common_16);
+fn void streebog_256_16() => streebog::hash_256(common_16);
+fn void streebog_512_16() => streebog::hash_512(common_16);
+
+fn void md5_256() => md5::hash(common_256);
+fn void sha1_256() => sha1::hash(common_256);
+fn void sha2_256_256() => sha256::hash(common_256);
+fn void sha2_512_256() => sha512::hash(common_256);
+//fn void blake2s_256_256() => blake2::s(256, common_256);
+//fn void blake2b_256_256() => blake2::b(256, common_256);
+fn void blake3_256() => blake3::hash(common_256);
+fn void ripemd_160_256() => ripemd::hash{160}(common_256);
+fn void whirlpool_256() => whirlpool::hash(common_256);
+fn void streebog_256_256() => streebog::hash_256(common_256);
+fn void streebog_512_256() => streebog::hash_512(common_256);
+
+fn void md5_4kib() => md5::hash(common_4kib);
+fn void sha1_4kib() => sha1::hash(common_4kib);
+fn void sha2_256_4kib() => sha256::hash(common_4kib);
+fn void sha2_512_4kib() => sha512::hash(common_4kib);
+//fn void blake2s_256_4kib() => blake2::s(256, common_4kib);
+//fn void blake2b_256_4kib() => blake2::b(256, common_4kib);
+fn void blake3_4kib() => blake3::hash(common_4kib);
+fn void ripemd_160_4kib() => ripemd::hash{160}(common_4kib);
+fn void whirlpool_4kib() => whirlpool::hash(common_4kib);
+fn void streebog_256_4kib() => streebog::hash_256(common_4kib);
+fn void streebog_512_4kib() => streebog::hash_512(common_4kib);
+
+fn void md5_1mib() => md5::hash(common_1mib);
+fn void sha1_1mib() => sha1::hash(common_1mib);
+fn void sha2_256_1mib() => sha256::hash(common_1mib);
+fn void sha2_512_1mib() => sha512::hash(common_1mib);
+//fn void blake2s_256_1mib() => blake2::s(256, common_1mib);
+//fn void blake2b_256_1mib() => blake2::b(256, common_1mib);
+fn void blake3_1mib() => blake3::hash(common_1mib);
+fn void ripemd_160_1mib() => ripemd::hash{160}(common_1mib);
+fn void whirlpool_1mib() => whirlpool::hash(common_1mib);
+fn void streebog_256_1mib() => streebog::hash_256(common_1mib);
+fn void streebog_512_1mib() => streebog::hash_512(common_1mib);

benchmarks/stdlib/hash/blake3.c3

@@ -0,0 +1,57 @@
+module blake3_bench;
+
+fn void initialize_bench() @init
+{
+	set_benchmark_warmup_iterations(3);
+	set_benchmark_max_iterations(128);
+
+    input = mem::alloc_array(char, BUFSZ);
+    input[:BUFSZ] = (char[]){ [0..BUFSZ-1] = 0xA5 }[..];
+    input_slice = input[:BUFSZ];
+}
+
+fn void teardown_bench() @finalizer
+{
+    mem::free(input);
+    input = null;
+}
+
+char* input;
+char[] input_slice;
+const usz BUFSZ = 1024 * 1024;
+
+module blake3_bench @benchmark;
+
+import std::hash;
+
+fn void blake3_hash()
+{
+    runtime::@start_benchmark();
+    char[*] myset = blake3::hash(input_slice);
+    runtime::@end_benchmark();
+    mem::zero_volatile(myset[..]);
+}
+
+fn void compared_with_sha256()
+{
+    runtime::@start_benchmark();
+    char[*] myset = sha256::hash(input_slice);
+    runtime::@end_benchmark();
+    mem::zero_volatile(myset[..]);
+}
+
+fn void compared_with_sha512()
+{
+    runtime::@start_benchmark();
+    char[*] myset = sha512::hash(input_slice);
+    runtime::@end_benchmark();
+    mem::zero_volatile(myset[..]);
+}
+
+fn void compared_with_whirlpool()
+{
+    runtime::@start_benchmark();
+    char[*] myset = whirlpool::hash(input_slice);
+    runtime::@end_benchmark();
+    mem::zero_volatile(myset[..]);
+}

benchmarks/stdlib/hash/md5.c3

@@ -0,0 +1,41 @@
+module md5_bench;
+
+fn void initialize_bench() @init
+{
+	set_benchmark_warmup_iterations(3);
+	set_benchmark_max_iterations(128);
+
+    input = mem::alloc_array(char, BUFSZ);
+    input[:BUFSZ] = (char[]){ [0..BUFSZ-1] = 0xA5 }[..];
+    input_slice = input[:BUFSZ];
+}
+
+fn void teardown_bench() @finalizer
+{
+    mem::free(input);
+    input = null;
+}
+
+char* input;
+char[] input_slice;
+const usz BUFSZ = 1024 * 1024;
+
+module md5_bench @benchmark;
+
+import std::hash;
+
+fn void md5_hash()
+{
+    runtime::@start_benchmark();
+    char[*] myset = md5::hash(input_slice);
+    runtime::@end_benchmark();
+    mem::zero_volatile(myset[..]);
+}
+
+fn void compared_with_sha256()
+{
+    runtime::@start_benchmark();
+    char[*] myset = sha256::hash(input_slice);
+    runtime::@end_benchmark();
+    mem::zero_volatile(myset[..]);
+}

benchmarks/stdlib/hash/non_crypto_shootout.c3

@@ -0,0 +1,94 @@
+// Copyright (c) 2025 Zack Puhl <github@xmit.xyz>. All rights reserved.
+// Use of this source code is governed by the MIT license
+// a copy of which can be found in the LICENSE_STDLIB file.
+module non_crypto_benchmarks;
+
+
+const usz COMMON_ITERATIONS = 1 << 18;
+
+const char[] COMMON_1 = { 0xA5 };
+const char[] COMMON_4 = { 0xA5, 0xA5, 0xA5, 0xA5, };
+const char[] COMMON_8 = { [0..7] = 0xA5 };
+const char[] COMMON_16 = { [0..15] = 0xA5 };
+const char[] COMMON_32 = { [0..31] = 0xA5 };
+const char[] COMMON_64 = { [0..63] = 0xA5 };
+const char[] COMMON_128 = { [0..127] = 0xA5 };
+const char[] COMMON_1024 = { [0..1023] = 0xA5 };
+
+
+fn void initialize_bench() @init
+{
+	set_benchmark_warmup_iterations(3);
+	set_benchmark_max_iterations(COMMON_ITERATIONS + 3);
+}
+
+
+// =======================================================================================
+module non_crypto_benchmarks @benchmark;
+
+import std::hash;
+
+
+fn void fnv64a_1() => fnv64a::hash(COMMON_1);
+fn void fnv32a_1() => fnv32a::hash(COMMON_1);
+fn void wyhash2_1() => wyhash2::hash(COMMON_1);
+fn void metro64_1() => metro64::hash(COMMON_1);
+fn void metro128_1() => metro128::hash(COMMON_1);
+fn void a5hash_1() => a5hash::hash(COMMON_1);
+fn void komi_1() => komi::hash(COMMON_1);
+
+fn void fnv64a_4() => fnv64a::hash(COMMON_4);
+fn void fnv32a_4() => fnv32a::hash(COMMON_4);
+fn void wyhash2_4() => wyhash2::hash(COMMON_4);
+fn void metro64_4() => metro64::hash(COMMON_4);
+fn void metro128_4() => metro128::hash(COMMON_4);
+fn void a5hash_4() => a5hash::hash(COMMON_4);
+fn void komi_4() => komi::hash(COMMON_4);
+
+fn void fnv64a_8() => fnv64a::hash(COMMON_8);
+fn void fnv32a_8() => fnv32a::hash(COMMON_8);
+fn void wyhash2_8() => wyhash2::hash(COMMON_8);
+fn void metro64_8() => metro64::hash(COMMON_8);
+fn void metro128_8() => metro128::hash(COMMON_8);
+fn void a5hash_8() => a5hash::hash(COMMON_8);
+fn void komi_8() => komi::hash(COMMON_8);
+
+fn void fnv64a_16() => fnv64a::hash(COMMON_16);
+fn void fnv32a_16() => fnv32a::hash(COMMON_16);
+fn void wyhash2_16() => wyhash2::hash(COMMON_16);
+fn void metro64_16() => metro64::hash(COMMON_16);
+fn void metro128_16() => metro128::hash(COMMON_16);
+fn void a5hash_16() => a5hash::hash(COMMON_16);
+fn void komi_16() => komi::hash(COMMON_16);
+
+fn void fnv64a_32() => fnv64a::hash(COMMON_32);
+fn void fnv32a_32() => fnv32a::hash(COMMON_32);
+// NOTE: wyhash2 cannot be used on inputs > 16 bytes.
+fn void metro64_32() => metro64::hash(COMMON_32);
+fn void metro128_32() => metro128::hash(COMMON_32);
+fn void a5hash_32() => a5hash::hash(COMMON_32);
+fn void komi_32() => komi::hash(COMMON_32);
+
+fn void fnv64a_64() => fnv64a::hash(COMMON_64);
+fn void fnv32a_64() => fnv32a::hash(COMMON_64);
+// NOTE: wyhash2 cannot be used on inputs > 16 bytes.
+fn void metro64_64() => metro64::hash(COMMON_64);
+fn void metro128_64() => metro128::hash(COMMON_64);
+fn void a5hash_64() => a5hash::hash(COMMON_64);
+fn void komi_64() => komi::hash(COMMON_64);
+
+fn void fnv64a_128() => fnv64a::hash(COMMON_128);
+fn void fnv32a_128() => fnv32a::hash(COMMON_128);
+// NOTE: wyhash2 cannot be used on inputs > 16 bytes.
+fn void metro64_128() => metro64::hash(COMMON_128);
+fn void metro128_128() => metro128::hash(COMMON_128);
+fn void a5hash_128() => a5hash::hash(COMMON_128);
+fn void komi_128() => komi::hash(COMMON_128);
+
+fn void fnv64a_1024() => fnv64a::hash(COMMON_1024);
+fn void fnv32a_1024() => fnv32a::hash(COMMON_1024);
+// NOTE: wyhash2 cannot be used on inputs > 16 bytes.
+fn void metro64_1024() => metro64::hash(COMMON_1024);
+fn void metro128_1024() => metro128::hash(COMMON_1024);
+fn void a5hash_1024() => a5hash::hash(COMMON_1024);
+fn void komi_1024() => komi::hash(COMMON_1024);

benchmarks/stdlib/hash/ripemd.c3

@@ -0,0 +1,76 @@
+// Copyright (c) 2025 Zack Puhl <github@xmit.xyz>. All rights reserved.
+// Use of this source code is governed by the MIT license
+// a copy of which can be found in the LICENSE_STDLIB file.
+module ripemd_bench;
+
+fn void initialize_bench() @init
+{
+	set_benchmark_warmup_iterations(3);
+	set_benchmark_max_iterations(256);
+
+    input = mem::alloc_array(char, BUFSZ);
+    input[:BUFSZ] = (char[]){ [0..BUFSZ-1] = 0xA5 }[..];
+    input_slice = input[:BUFSZ];
+}
+
+fn void teardown_bench() @finalizer
+{
+    mem::free(input);
+    input = null;
+}
+
+char* input;
+char[] input_slice;
+const usz BUFSZ = 1024 * 1024;
+
+module ripemd_bench @benchmark;
+
+import std::hash;
+
+fn void ripemd_128()
+{
+    runtime::@start_benchmark();
+    char[*] myset = ripemd::hash{128}(input_slice);
+    runtime::@end_benchmark();
+    mem::zero_volatile(myset[..]);
+}
+
+fn void ripemd_160()
+{
+    runtime::@start_benchmark();
+    char[*] myset = ripemd::hash{160}(input_slice);
+    runtime::@end_benchmark();
+    mem::zero_volatile(myset[..]);
+}
+
+fn void ripemd_256()
+{
+    runtime::@start_benchmark();
+    char[*] myset = ripemd::hash{256}(input_slice);
+    runtime::@end_benchmark();
+    mem::zero_volatile(myset[..]);
+}
+
+fn void ripemd_320()
+{
+    runtime::@start_benchmark();
+    char[*] myset = ripemd::hash{320}(input_slice);
+    runtime::@end_benchmark();
+    mem::zero_volatile(myset[..]);
+}
+
+fn void compared_with_sha256()
+{
+    runtime::@start_benchmark();
+    char[*] myset = sha256::hash(input_slice);
+    runtime::@end_benchmark();
+    mem::zero_volatile(myset[..]);
+}
+
+fn void compared_with_whirlpool()
+{
+    runtime::@start_benchmark();
+    char[*] myset = whirlpool::hash(input_slice);
+    runtime::@end_benchmark();
+    mem::zero_volatile(myset[..]);
+}

benchmarks/stdlib/hash/streebog.c3

@@ -0,0 +1,51 @@
+// Copyright (c) 2025 Zack Puhl <github@xmit.xyz>. All rights reserved.
+// Use of this source code is governed by the MIT license
+// a copy of which can be found in the LICENSE_STDLIB file.
+module streebog_bench;
+
+fn void initialize_bench() @init
+{
+	set_benchmark_warmup_iterations(3);
+	set_benchmark_max_iterations(256);
+}
+
+const char[] INPUT = { [0..1024*1024] = 0xA5 };
+const char[*] EXPECTED_256 = x'694676905b7cf099755db1cc186f741f0fd1877aaaa4badcbfb305537f986971';
+const char[*] EXPECTED_512 = x'fe21d08857ea97e79035d1e5c9ba5130786e8d1875bc74d628349560d94d6bdff0b0dcd2f6347eb8b3f0239b6cca76b5028c0ff45f631fcdf77b1d551dd079f3';
+
+
+module streebog_bench @benchmark;
+
+import std::hash;
+
+fn void get_in_the_bog_256()
+{
+    runtime::@start_benchmark();
+    char[*] myset = streebog::hash_256(INPUT);
+    runtime::@end_benchmark();
+    mem::zero_volatile(myset[..]);
+}
+
+fn void get_in_the_bog_512()
+{
+    runtime::@start_benchmark();
+    char[*] myset = streebog::hash_512(INPUT);
+    runtime::@end_benchmark();
+    mem::zero_volatile(myset[..]);
+}
+
+fn void compared_with_sha256()
+{
+    runtime::@start_benchmark();
+    char[*] myset = sha256::hash(INPUT);
+    runtime::@end_benchmark();
+    mem::zero_volatile(myset[..]);
+}
+
+fn void compared_with_whirlpool()
+{
+    runtime::@start_benchmark();
+    char[*] myset = whirlpool::hash(INPUT);
+    runtime::@end_benchmark();
+    mem::zero_volatile(myset[..]);
+}

benchmarks/stdlib/hash/whirlpool.c3

@@ -0,0 +1,57 @@
+module whirlpool_bench;
+
+fn void initialize_bench() @init
+{
+	set_benchmark_warmup_iterations(3);
+	set_benchmark_max_iterations(128);
+
+    input = mem::alloc_array(char, BUFSZ);
+    input[:BUFSZ] = (char[]){ [0..BUFSZ-1] = 0xA5 }[..];
+    input_slice = input[:BUFSZ];
+}
+
+fn void teardown_bench() @finalizer
+{
+    mem::free(input);
+    input = null;
+}
+
+char* input;
+char[] input_slice;
+const usz BUFSZ = 1024 * 1024;
+
+module whirlpool_bench @benchmark;
+
+import std::hash;
+
+fn void whirlpool_hash()
+{
+    runtime::@start_benchmark();
+    char[*] myset = whirlpool::hash(input_slice);
+    runtime::@end_benchmark();
+    mem::zero_volatile(myset[..]);
+}
+
+fn void compared_with_sha256()
+{
+    runtime::@start_benchmark();
+    char[*] myset = sha256::hash(input_slice);
+    runtime::@end_benchmark();
+    mem::zero_volatile(myset[..]);
+}
+
+fn void compared_with_sha512()
+{
+    runtime::@start_benchmark();
+    char[*] myset = sha512::hash(input_slice);
+    runtime::@end_benchmark();
+    mem::zero_volatile(myset[..]);
+}
+
+fn void compared_with_streebog_512()
+{
+    runtime::@start_benchmark();
+    char[*] myset = streebog::hash_512(input_slice);
+    runtime::@end_benchmark();
+    mem::zero_volatile(myset[..]);
+}

benchmarks/stdlib/sort/quicksort.c3

@@ -0,0 +1,69 @@
+module sort_bench;
+
+import std::sort;
+
+fn void init() @init
+{
+    set_benchmark_warmup_iterations(5);
+    set_benchmark_max_iterations(10_000);
+}
+
+fn void quicksort_bench() @benchmark
+{
+	// test set: 500 numbers between 0 and 99;
+	int[] data = {
+		71, 28, 2, 13, 62, 10, 54, 78, 63, 86,
+		33, 65, 89, 51, 58, 0, 51, 16, 87, 30,
+		89, 14, 52, 41, 88, 25, 83, 91, 56, 86,
+		14, 64, 76, 18, 39, 24, 79, 62, 34, 58,
+		90, 24, 56, 73, 85, 82, 79, 63, 47, 69,
+		78, 29, 49, 28, 43, 47, 56, 53, 79, 56,
+		19, 63, 29, 52, 71, 93, 61, 46, 30, 11,
+		21, 26, 37, 86, 93, 74, 62, 0, 41, 17,
+		26, 27, 34, 11, 54, 69, 72, 44, 74, 3,
+		61, 62, 80, 90, 3, 82, 16, 12, 28, 1,
+		2, 49, 4, 44, 57, 86, 63, 74, 33, 41,
+		76, 77, 56, 57, 56, 88, 74, 71, 6, 59,
+		40, 42, 94, 55, 21, 17, 17, 63, 21, 83,
+		73, 19, 39, 88, 93, 74, 21, 0, 63, 45,
+		69, 66, 22, 68, 86, 86, 85, 67, 8, 50,
+		23, 98, 64, 80, 64, 36, 40, 30, 73, 36,
+		23, 14, 1, 77, 82, 8, 18, 73, 37, 86,
+		29, 70, 27, 87, 64, 81, 13, 0, 4, 83,
+		90, 17, 71, 66, 38, 39, 54, 22, 86, 18,
+		84, 66, 77, 25, 64, 93, 80, 91, 2, 92,
+		47, 32, 90, 16, 46, 29, 56, 87, 70, 73,
+		89, 41, 5, 54, 93, 63, 16, 39, 71, 84,
+		74, 91, 69, 59, 49, 87, 74, 37, 75, 83,
+		77, 19, 51, 44, 79, 62, 94, 20, 24, 83,
+		37, 70, 57, 32, 93, 8, 29, 11, 7, 92,
+		8, 23, 20, 21, 7, 70, 28, 20, 96, 6,
+		50, 58, 30, 61, 66, 42, 50, 54, 64, 7,
+		10, 53, 63, 44, 16, 39, 83, 73, 3, 29,
+		97, 32, 36, 68, 84, 64, 73, 5, 29, 13,
+		48, 3, 84, 65, 75, 68, 66, 22, 39, 33,
+		39, 24, 27, 85, 18, 34, 3, 63, 32, 9,
+		29, 66, 24, 90, 75, 50, 11, 95, 47, 14,
+		92, 1, 76, 45, 76, 41, 55, 54, 38, 67,
+		43, 40, 5, 61, 97, 11, 61, 24, 92, 24,
+		76, 53, 60, 34, 78, 80, 70, 75, 30, 90,
+		65, 99, 80, 61, 94, 75, 63, 67, 10, 35,
+		23, 42, 31, 48, 14, 68, 84, 14, 79, 1,
+		25, 94, 23, 53, 49, 69, 44, 73, 63, 51,
+		44, 96, 88, 51, 94, 24, 64, 72, 59, 81,
+		73, 93, 14, 35, 9, 53, 25, 48, 50, 88,
+		46, 97, 67, 40, 27, 17, 2, 42, 11, 82,
+		0, 46, 44, 38, 31, 88, 63, 88, 10, 82,
+		77, 61, 24, 39, 27, 33, 10, 91, 69, 22,
+		42, 74, 71, 13, 32, 56, 12, 46, 81, 74,
+		17, 26, 45, 50, 76, 84, 76, 36, 43, 65,
+		81, 64, 0, 49, 70, 11, 76, 19, 60, 55,
+		15, 98, 31, 91, 56, 8, 97, 9, 3, 94,
+		3, 88, 7, 2, 3, 98, 10, 51, 21, 79,
+		99, 3, 8, 76, 52, 13, 40, 90, 85, 15,
+		70, 77, 43, 30, 4, 89, 18, 21, 59, 17,
+	};
+	sort::quicksort(data);
+}
+
+

build-with-docker.sh

@@ -1,56 +1,45 @@
-#!/bin/bash
-## build-with-docker.sh
-## @author gdm85
-##
-## Script to build c3c for either Ubuntu 20, 21 or 22.
-##
-#
+#!/usr/bin/env bash
 
-if [ $# -ne 1 -a $# -ne 2 ]; then
-	echo "Usage: build-with-docker.sh (20|21|22) [Debug|Release]" 1>&2
-	exit 1
+: ${DOCKER:=docker}
+: ${IMAGE:="c3c-builder"}
+: ${CMAKE_BUILD_TYPE:=Release}
+: ${LLVM_VERSION:=18}
+: ${UBUNTU_VERSION:="22.04"}
+: ${CMAKE_VERSION:="3.20.0"}
+
+cd docker || exit 1  # Exit if the 'docker' directory doesn't exist
+
+$DOCKER build \
+    --build-arg LLVM_VERSION=$LLVM_VERSION \
+    --build-arg CMAKE_VERSION=$CMAKE_VERSION \
+    --build-arg UBUNTU_VERSION=$UBUNTU_VERSION \
+    -t $IMAGE .
+
+if [ $? -ne 0 ]; then
+    echo "Docker image build failed. Exiting."
+    exit 1
 fi
 
-set -e
-
-DOCKER=docker
-DOCKER_RUN=""
-IMAGE="c3c-builder"
-if type podman 2>/dev/null >/dev/null; then
-	DOCKER=podman
-	DOCKER_RUN="--userns=keep-id"
-	IMAGE="localhost/$IMAGE"
-fi
-
-if [ -z "$2" ]; then
-	CMAKE_BUILD_TYPE=Debug
-else
-	CMAKE_BUILD_TYPE="$2"
-fi
-
-TAG="$1"
-if [ "$1" = 20 ]; then
-	UBUNTU_VERSION="20.04"
-	LLVM_VERSION="12"
-elif [ "$1" = 21 ]; then
-	UBUNTU_VERSION="21.10"
-	LLVM_VERSION="13"
-elif [ "$1" = 22 ]; then
-	UBUNTU_VERSION="22.04"
-	LLVM_VERSION="14"
-else
-	echo "ERROR: expected 20, 21 or 22 as Ubuntu version argument" 1>&2
-	exit 2
-fi
-IMAGE="$IMAGE:$TAG"
-
-cd docker && $DOCKER build -t $IMAGE --build-arg UID=$(id -u) --build-arg GID=$(id -g) \
-	--build-arg DEPS="llvm-$LLVM_VERSION-dev liblld-$LLVM_VERSION-dev clang-$LLVM_VERSION libllvm$LLVM_VERSION llvm-$LLVM_VERSION-runtime" \
-	--build-arg UBUNTU_VERSION="$UBUNTU_VERSION" .
 cd ..
 
 rm -rf build bin
 mkdir -p build bin
 
-exec $DOCKER run -ti --rm --tmpfs=/tmp $DOCKER_RUN -v "$PWD":/home/c3c/source -w /home/c3c/source $IMAGE bash -c \
-	"cd build && cmake -DCMAKE_BUILD_TYPE=$CMAKE_BUILD_TYPE -DC3_LLVM_VERSION=$LLVM_VERSION .. && cmake --build . && mv c3c lib ../bin/"
+chmod -R 777 build bin
+
+exec $DOCKER run -i --rm \
+    -v "$PWD":/home/c3c/source \
+    -w /home/c3c/source $IMAGE bash -c \
+    "git config --global --add safe.directory /home/c3c/source && \
+    cmake -S . -B build \
+            -G Ninja \
+            -DCMAKE_BUILD_TYPE=$CMAKE_BUILD_TYPE \
+            -DCMAKE_C_COMPILER=clang-$LLVM_VERSION \
+            -DCMAKE_CXX_COMPILER=clang++-$LLVM_VERSION \
+            -DCMAKE_LINKER=lld-$LLVM_VERSION \
+            -DCMAKE_OBJCOPY=llvm-objcopy-$LLVM_VERSION \
+            -DCMAKE_STRIP=llvm-strip-$LLVM_VERSION \
+            -DCMAKE_DLLTOOL=llvm-dlltool-$LLVM_VERSION \
+            -DC3_LLVM_VERSION=auto && \
+    cmake --build build && \
+    cp -r build/c3c build/lib bin"

c3c.1

@@ -0,0 +1,552 @@
+.TH "c3c" "1" "2024-10-27" "C3 Compiler" "User Commands"
+.SH NAME
+c3c \- Compiler for the C3 programming language
+
+.SH SYNOPSIS
+.B c3c
+[\fIoptions\fR ...] \fIcommand\fR [\fIargs\fR ...]
+
+.SH DESCRIPTION
+.B c3c
+is the compiler for the C3 language, providing commands for compilation, project
+management, testing, and distribution. The available commands allow users to 
+compile files, initialize projects, build targets, run benchmarks, clean build 
+files, and more.
+
+.SH COMMANDS
+.PP
+.B c3c compile 
+\fIfile1\fR [\fIfile2\fR ...]
+.RS
+Compile files without a project into an executable.
+.RE
+.PP
+.B c3c init 
+\fIproject name\fR
+.RS
+Initialize a new project structure.
+.RE
+.PP
+.B c3c init-lib 
+\fIlibrary name\fR
+.RS
+Initialize a new library structure.
+.RE
+.PP
+.B c3c build 
+[\fItarget\fR]
+.RS
+Build the target in the current project.
+.RE
+.PP
+.B c3c benchmark
+.RS
+Run the benchmarks in the current project.
+.RE
+.PP
+.B c3c test
+.RS
+Run the unit tests in the current project.
+.RE
+.PP
+.B c3c clean
+.RS
+Clean all build files.
+.RE
+.PP
+.B c3c run 
+[\fItarget\fR] [-- [\fIarg1\fR ...]]
+.RS
+Run (and build if needed) the target in the current project.
+.RE
+.PP
+.B c3c dist 
+[\fItarget\fR]
+.RS
+Clean and build a target for distribution.
+.RE
+.PP
+.B c3c directives 
+[\fItarget\fR]
+.RS
+Generate documentation for the target.
+.RE
+.PP
+.B c3c bench 
+[\fItarget\fR]
+.RS
+Benchmark a target.
+.RE
+.PP
+.B c3c clean-run 
+[\fItarget\fR] [-- [\fIarg1\fR ...]]
+.RS
+Clean, then run the target.
+.RE
+.PP
+.B c3c compile-run 
+\fIfile1\fR [\fIfile2\fR ...] [-- [\fIarg1\fR ...]]
+.RS
+Compile files then immediately run the result.
+.RE
+.PP
+.B c3c compile-only 
+\fIfile1\fR [\fIfile2\fR ...]
+.RS
+Compile files but do not perform linking.
+.RE
+.PP
+.B c3c compile-benchmark 
+\fIfile1\fR [\fIfile2\fR ...]
+.RS
+Compile files into an executable and run benchmarks.
+.RE
+.PP
+.B c3c compile-test 
+\fIfile1\fR [\fIfile2\fR ...]
+.RS
+Compile files into an executable and run unit tests.
+.RE
+.PP
+.B c3c static-lib 
+\fIfile1\fR [\fIfile2\fR ...]
+.RS
+Compile files without a project into a static library.
+.RE
+.PP
+.B c3c dynamic-lib 
+\fIfile1\fR [\fIfile2\fR ...]
+.RS
+Compile files without a project into a dynamic library.
+.RE
+.PP
+.B c3c headers 
+\fIfile1\fR [\fIfile2\fR ...]
+.RS
+Analyze files and generate C headers for public methods.
+.RE
+.PP
+.B c3c vendor-fetch 
+\fIlibrary\fR ...
+.RS
+Fetch one or more libraries from the vendor collection.
+.RE
+.PP
+.B c3c project 
+\fIsubcommand\fR ...
+.RS
+Manipulate or view project files.
+.RE
+
+.SH OPTIONS
+.PP
+.B --stdlib 
+\fIdir\fR
+.RS
+Use this directory as the C3 standard library path.
+.RE
+.PP
+.B --no-entry
+.RS
+Do not generate (or require) a main function.
+.RE
+.PP
+.B --libdir 
+\fIdir\fR
+.RS
+Add this directory to the C3 library search paths.
+.RE
+.PP
+.B --lib 
+\fIname\fR
+.RS
+Add this library to the compilation.
+.RE
+.PP
+.B --path 
+\fIdir\fR
+.RS
+Use this as the base directory for the current command.
+.RE
+.PP
+.B --template 
+\fItemplate\fR
+.RS
+Select template for 'init': "exe", "static-lib", "dynamic-lib" or a path.
+.RE
+.PP
+.B --about
+Prints a short description of C3.
+.PP
+.B --symtab 
+\fIvalue\fR
+.RS
+Sets the preferred symtab size.
+.RE
+.PP
+.B --max-mem 
+\fIvalue\fR
+.RS
+Sets the preferred max memory size.
+.RE
+.PP
+.B --run-once
+.RS
+After running the output file, delete it immediately.
+.RE
+.PP
+.B -V, --version
+Print version information.
+.PP
+.B -E
+Lex only.
+.PP
+.B -P
+Only parse and output the AST as JSON.
+.PP
+.B -C
+Only lex, parse and check.
+.PP
+.B -
+\fIcode\fR...
+.RS
+Read code from standard in.
+.RE
+.PP
+.B -o 
+\fIfile\fR
+.RS
+Write output to \fIfile\fR.
+.RE
+.PP
+.B -O0
+Safe, no optimizations, emit debug info.
+.PP
+.B -O1
+Safe, high optimization, emit debug info.
+.PP
+.B -O2
+Unsafe, high optimization, emit debug info.
+.PP
+.B -O3
+Unsafe, high optimization, single module, emit debug info.
+.PP
+.B -O4
+Unsafe, highest optimization, relaxed maths, single module, emit debug info, no panic messages.
+.PP
+.B -O5
+Unsafe, highest optimization, fast maths, single module, emit debug info, no panic messages, no backtrace.
+.PP
+.B -Os
+Unsafe, high optimization, small code, single module, no debug info, no panic messages.
+.PP
+.B -Oz
+Unsafe, high optimization, tiny code, single module, no debug info, no panic messages, no backtrace.
+.PP
+.B -D 
+\fIname\fR
+.RS
+Add feature flag \fIname\fR.
+.RE
+.PP
+.B -U 
+\fIname\fR
+.RS
+Remove feature flag \fIname\fR.
+.RE
+.PP
+.B --trust=
+\fIoption\fR
+.RS
+Trust level: none (default), include ($include allowed), full ($exec / exec allowed).
+.RE
+.PP
+.B --output-dir 
+\fIdir\fR
+.RS
+Override general output directory.
+.RE
+.PP
+.B --threads 
+\fInumber\fR
+.RS
+Set the number of threads to use for compilation.
+.RE
+.PP
+.B --show-backtrace=
+\fIyes|no\fR
+.RS
+Show detailed backtrace on segfaults.
+.RE
+
+.PP
+.B -g
+Emit debug info.
+.PP
+.B -g0
+Emit no debug info.
+
+
+.PP
+.B -l 
+\fIlibrary\fR
+.RS
+Link with the library provided.
+.RE
+.PP
+.B -L 
+\fIlibrary\fR \fIdir\fR
+.RS
+Append the directory to the linker search paths.
+.RE
+.PP
+.B -z 
+\fIargument\fR
+.RS
+Send the \fIargument\fR as a parameter to the linker.
+.RE
+.PP
+.B --cc 
+\fIpath\fR
+.RS
+Set C compiler (for C files in projects and use as system linker).
+.RE
+.PP
+.B --linker=
+\fIoption\fR [\fIpath\fR]
+.RS
+Specify the linker: builtin, cc, custom (default is 'cc'). 'Custom' requires a path.
+.RE
+
+.PP
+.B --use-stdlib=
+\fIyes|no\fR
+.RS
+Include the standard library (default: yes).
+.RE
+.PP
+.B --link-libc=
+\fIyes|no\fR
+.RS
+Link libc and other default libraries (default: yes).
+.RE
+.PP
+.B --emit-stdlib=
+\fIyes|no\fR
+.RS
+Output files for the standard library (default: yes).
+.RE
+.PP
+.B --panicfn 
+\fIname\fR
+.RS
+Override the panic function name.
+.RE
+.PP
+.B --testfn 
+\fIname\fR
+.RS
+Override the test runner function name.
+.RE
+.PP
+.B --benchfn 
+\fIname\fR
+.RS
+Override the benchmark runner function name.
+.RE
+
+.PP
+.B --reloc=
+\fIoption\fR
+.RS
+Specify the relocation model: none, pic, PIC, pie, PIE.
+.RE
+.PP
+.B --x86cpu=
+\fIoption\fR
+.RS
+Set general level of x64 CPU: baseline, ssse3, sse4, avx1, avx2-v1, avx2-v2 (Skylake/Zen1+), avx512 (Icelake/Zen4+), native.
+.RE
+.PP
+.B --x86vec=
+\fIoption\fR
+.RS
+Set maximum type of vector use: none, mmx, sse, avx, avx512, default.
+.RE
+.PP
+.B --riscvfloat=
+\fIoption\fR
+.RS
+Set type of RISC-V float support: none, float, double.
+.RE
+.PP
+.B --memory-env=
+\fIoption\fR
+.RS
+Set the memory environment: normal, small, tiny, none.
+.RE
+.PP
+.B --strip-unused=
+\fIyes|no\fR
+.RS
+Strip unused code and globals from the output (default: yes).
+.RE
+.PP
+.B --fp-math=
+\fIoption\fR
+.RS
+Specify floating-point math behavior: strict, relaxed, fast.
+.RE
+.PP
+.B --win64-simd=
+\fIoption\fR
+.RS
+Windows SIMD ABI: array, full.
+.RE
+
+.PP
+.B --debug-stats
+Print debug statistics.
+.PP
+.B --print-linking
+Print linker arguments.
+.PP
+.B --debug-log
+Print debug logging to stdout.
+
+
+.PP
+.B --benchmarking
+Run built-in benchmarks.
+.PP
+.B --testing
+Run built-in tests.
+
+
+.PP
+.B --list-attributes
+List all attributes.
+.PP
+.B --list-builtins
+List all builtins.
+.PP
+.B --list-keywords
+List all keywords.
+.PP
+.B --list-operators
+List all operators.
+.PP
+.B --list-precedence
+List operator precedence order.
+.PP
+.B --list-project-properties
+List all available keys used in project.json files.
+.PP
+.B --list-manifest-properties
+List all available keys used in manifest.json files.
+.PP
+.B --list-targets
+List all architectures the compiler supports.
+.PP
+.B --list-type-properties
+List all type properties.
+
+
+.PP
+.B --print-output
+Print the object files created to stdout.
+.PP
+.B --print-input
+Print inputted C3 files to stdout.
+
+
+.PP
+.B --winsdk 
+\fIdir\fR
+.RS
+Set the directory for Windows system library files for cross-compilation.
+.RE
+.PP
+.B --wincrt=
+\fIoption\fR
+.RS
+Windows CRT linking: none, static-debug, static, dynamic-debug (default if debug info enabled), dynamic (default).
+.RE
+.PP
+.B --windef 
+\fIfile\fR
+.RS
+Use Windows 'def' file for function exports instead of 'dllexport'.
+.RE
+
+.PP
+.B --macossdk 
+\fIdir\fR
+.RS
+Set the directory for the MacOS SDK for cross-compilation.
+.RE
+.PP
+.B --macos-min-version 
+\fIver\fR
+.RS
+Set the minimum MacOS version to compile for.
+.RE
+.PP
+.B --macos-sdk-version 
+\fIver\fR
+.RS
+Set the MacOS SDK version to compile for.
+.RE
+
+.PP
+.B --linux-crt 
+\fIdir\fR
+.RS
+Set the directory to use for finding crt1.o and related files.
+.RE
+.PP
+.B --linux-crtbegin 
+\fIdir\fR
+.RS
+Set the directory to use for finding crtbegin.o and related files.
+.RE
+
+.PP
+.B --vector-conv=
+\fIoption\fR
+.RS
+Set vector conversion behavior: default, old.
+.RE
+.PP
+.B --sanitize=
+\fIoption\fR
+.RS
+Enable a sanitizer: address, memory, thread.
+.RE
+
+.SH EXAMPLES
+.PP
+Create a project:
+.RS
+.B c3c init new_project
+.RE
+.PP
+Create a library project:
+.RS
+.B c3c init-lib new_library
+.RE
+.PP
+Compile a file:
+.RS
+.B c3c compile main.c3
+.RE
+.PP
+Build the current project:
+.RS
+.B c3c build
+.RE
+.PP
+Run tests for the current project:
+.RS
+.B c3c test
+.RE

docker/Dockerfile

@@ -1,16 +1,45 @@
+ARG UBUNTU_VERSION=22.04
+FROM ubuntu:${UBUNTU_VERSION}
 
-ARG UBUNTU_VERSION
-FROM ubuntu:$UBUNTU_VERSION
+ARG LLVM_VERSION=18
+ARG CMAKE_VERSION=3.20.0
 
-ARG DEPS
+# Prevent interactive prompts during apt install
+ENV DEBIAN_FRONTEND=noninteractive
 
-RUN export DEBIAN_FRONTEND=noninteractive && export TERM=xterm && apt-get update && apt-get install -y build-essential cmake zlib1g zlib1g-dev  \
-        $DEPS && \
-	rm -rf /var/lib/apt/lists/*
+RUN for i in 1 2 3; do apt-get update && break || sleep 2; done && \
+    apt-get install -y --fix-missing \
+    wget gnupg software-properties-common lsb-release \
+    zlib1g zlib1g-dev python3 ninja-build curl g++ libcurl4-openssl-dev git && \
+    CODENAME=$(lsb_release -cs) && \
+    ARCH=$(uname -m) && \
+    wget https://github.com/Kitware/CMake/releases/download/v${CMAKE_VERSION}/cmake-${CMAKE_VERSION}-linux-${ARCH}.sh && \
+    mkdir -p /opt/cmake && \
+    sh cmake-${CMAKE_VERSION}-linux-${ARCH}.sh --prefix=/opt/cmake --skip-license && \
+    ln -s /opt/cmake/bin/cmake /usr/local/bin/cmake && \
+    rm cmake-${CMAKE_VERSION}-linux-${ARCH}.sh
 
-ARG GID=1000
-ARG UID=1000
+RUN CODENAME=$(lsb_release -cs) && \
+    for i in 1 2; do wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key && break || sleep 2; done | apt-key add - && \
+    if [ "${LLVM_VERSION}" -ge 16 ]; then \
+        add-apt-repository "deb http://apt.llvm.org/${CODENAME}/ llvm-toolchain-${CODENAME}-${LLVM_VERSION} main"; \
+    else \
+        add-apt-repository "deb http://apt.llvm.org/${CODENAME}/ llvm-toolchain-${CODENAME} main"; \
+    fi && \
+    for i in 1 2 3; do apt-get update && break || sleep 2; done && \
+    apt-get install -y --fix-missing \
+      clang-${LLVM_VERSION} \
+      clang++-${LLVM_VERSION} \
+      llvm-${LLVM_VERSION} \
+      llvm-${LLVM_VERSION}-dev \
+      lld-${LLVM_VERSION} \
+      liblld-${LLVM_VERSION}-dev \
+      libpolly-${LLVM_VERSION}-dev && \
+    rm -rf /var/lib/apt/lists/*
 
-RUN groupadd --gid=$GID c3c && useradd --gid=$GID --uid=$GID --create-home --shell /bin/bash c3c
+RUN groupadd -g 1337 c3c && \
+    useradd -m -u 1337 -g c3c c3c
 
 USER c3c
+ENV PATH="/opt/cmake/bin:${PATH}"
+WORKDIR /home/c3c

flake.lock

@@ -0,0 +1,61 @@
+{
+  "nodes": {
+    "flake-utils": {
+      "inputs": {
+        "systems": "systems"
+      },
+      "locked": {
+        "lastModified": 1731533236,
+        "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1738297584,
+        "narHash": "sha256-AYvaFBzt8dU0fcSK2jKD0Vg23K2eIRxfsVXIPCW9a0E=",
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "rev": "9189ac18287c599860e878e905da550aa6dec1cd",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nixos",
+        "ref": "nixpkgs-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "flake-utils": "flake-utils",
+        "nixpkgs": "nixpkgs"
+      }
+    },
+    "systems": {
+      "locked": {
+        "lastModified": 1681028828,
+        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
+        "owner": "nix-systems",
+        "repo": "default",
+        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-systems",
+        "repo": "default",
+        "type": "github"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

flake.nix

@@ -0,0 +1,42 @@
+{
+  description = "C3 compiler flake";
+
+  inputs = {
+    nixpkgs.url = "github:nixos/nixpkgs?ref=nixpkgs-unstable";
+    flake-utils.url = "github:numtide/flake-utils";
+  };
+
+  outputs = { self, ... }@inputs: inputs.flake-utils.lib.eachDefaultSystem 
+  (system: 
+    let pkgs = import inputs.nixpkgs { inherit system; }; 
+        c3cBuild = set: pkgs.callPackage ./nix/default.nix (set // { 
+          rev = self.rev or "unknown"; 
+        });
+    in {
+      packages = {
+        default = self.packages.${system}.c3c;
+
+        c3c = c3cBuild {};
+        
+        c3c-checks = c3cBuild { 
+          checks = true; 
+        };
+
+        c3c-debug = c3cBuild { 
+          debug = true; 
+        };
+
+        c3c-debug-checks = c3cBuild { 
+          debug = true; 
+          checks = true; 
+        };
+      };
+
+      devShells = {
+        default = pkgs.callPackage ./nix/shell.nix {
+          c3c = self.packages.${system}.c3c-debug; 
+        };
+      };
+    }
+  );
+}

git_hash.cmake

@@ -0,0 +1,15 @@
+find_package(Git QUIET)
+
+set(GIT_HASH "unknown")
+
+if(GIT_FOUND AND EXISTS "${CMAKE_CURRENT_LIST_DIR}/.git")
+    execute_process(COMMAND ${GIT_EXECUTABLE} rev-parse HEAD
+                    WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}
+                    OUTPUT_VARIABLE GIT_HASH
+                    OUTPUT_STRIP_TRAILING_WHITESPACE
+                    COMMAND_ERROR_IS_FATAL ANY)
+endif()
+
+message("Git Hash: ${GIT_HASH}")
+
+file(WRITE ${CMAKE_BINARY_DIR}/git_hash.h "#pragma once\n#define GIT_HASH \"${GIT_HASH}\"\n")

install/install.ps1

@@ -0,0 +1,189 @@
+<#
+.SYNOPSIS
+    C3 install script.
+.DESCRIPTION
+    This script installs C3 on Windows from the command line.
+.PARAMETER C3Version
+    Specifies the version of C3 to install.
+    Default is 'latest'. Can also be set via environment variable 'C3_VERSION'.
+.PARAMETER C3Home
+    Specifies C3's installation directory.
+    Default is '$Env:USERPROFILE\.c3'. Can also be set via environment variable 'C3_HOME'.
+.PARAMETER NoPathUpdate
+    If specified, the script will not modify the PATH environment variable.
+.PARAMETER C3Repourl
+    Specifies the repository URL of C3.
+    Default is 'https://github.com/c3lang/c3c'. Can also be set via environment variable 'C3_REPOURL'.
+.LINK
+    https://c3-lang.org/
+.LINK
+    https://github.com/c3lang/c3c
+#>
+
+# Script parameters with defaults
+param (
+    [string] $C3Version = 'latest',
+    [string] $C3Home = "$Env:USERPROFILE\.c3",
+    [switch] $NoPathUpdate,
+    [string] $C3Repourl = 'https://github.com/c3lang/c3c'
+)
+
+# Enable strict mode for better error handling
+Set-StrictMode -Version Latest
+
+# Function to broadcast environment variable changes to Windows system
+function Publish-Env {
+    # Add P/Invoke type if it does not exist
+    if (-not ("Win32.NativeMethods" -as [Type])) {
+        Add-Type -Namespace Win32 -Name NativeMethods -MemberDefinition @"
+[DllImport("user32.dll", SetLastError = true, CharSet = CharSet.Auto)]
+public static extern IntPtr SendMessageTimeout(
+    IntPtr hWnd, uint Msg, UIntPtr wParam, string lParam,
+    uint fuFlags, uint uTimeout, out UIntPtr lpdwResult);
+"@
+    }
+
+    # Constants for broadcasting environment changes
+    $HWND_BROADCAST = [IntPtr] 0xffff
+    $WM_SETTINGCHANGE = 0x1a
+    $result = [UIntPtr]::Zero
+
+    # Broadcast the message to all windows
+    [Win32.Nativemethods]::SendMessageTimeout($HWND_BROADCAST,
+        $WM_SETTINGCHANGE,
+        [UIntPtr]::Zero,
+        "Environment",
+        2,
+        5000,
+        [ref] $result
+    ) | Out-Null
+}
+
+# Function to write or update an environment variable in the registry
+function Write-Env {
+    param(
+        [String] $name,
+        [String] $val,
+        [Switch] $global
+    )
+
+    # Determine the registry key based on scope (user or system)
+    $RegisterKey = if ($global) {
+        Get-Item -Path 'HKLM:\SYSTEM\CurrentControlSet\Control\Session Manager'
+    } else {
+        Get-Item -Path 'HKCU:'
+    }
+
+    $EnvRegisterKey = $RegisterKey.OpenSubKey('Environment', $true)
+
+    # If value is null, delete the variable
+    if ($null -eq $val) {
+        $EnvRegisterKey.DeleteValue($name)
+    } else {
+        # Determine the correct registry value type
+        $RegistryValueKind = if ($val.Contains('%')) {
+            [Microsoft.Win32.RegistryValueKind]::ExpandString
+        } elseif ($EnvRegisterKey.GetValue($name)) {
+            $EnvRegisterKey.GetValueKind($name)
+        } else {
+            [Microsoft.Win32.RegistryValueKind]::String
+        }
+        $EnvRegisterKey.SetValue($name, $val, $RegistryValueKind)
+    }
+
+    # Broadcast the change to the system
+    Publish-Env
+}
+
+# Function to get an environment variable from the registry
+function Get-Env {
+    param(
+        [String] $name,
+        [Switch] $global
+    )
+
+    # Determine registry key based on scope
+    $RegisterKey = if ($global) {
+        Get-Item -Path 'HKLM:\SYSTEM\CurrentControlSet\Control\Session Manager'
+    } else {
+        Get-Item -Path 'HKCU:'
+    }
+
+    $EnvRegisterKey = $RegisterKey.OpenSubKey('Environment')
+    $RegistryValueOption = [Microsoft.Win32.RegistryValueOptions]::DoNotExpandEnvironmentNames
+
+    # Retrieve the value without expanding environment variables
+    $EnvRegisterKey.GetValue($name, $null, $RegistryValueOption)
+}
+
+# Override defaults if environment variables exist
+if ($Env:C3_VERSION) { $C3Version = $Env:C3_VERSION }
+if ($Env:C3_HOME) { $C3Home = $Env:C3_HOME }
+if ($Env:C3_NO_PATH_UPDATE) { $NoPathUpdate = $true }
+if ($Env:C3_REPOURL) { $C3Repourl = $Env:C3_REPOURL -replace '/$', '' }
+
+# Set binary name
+$BINARY = "c3-windows"
+
+# Determine the download URL based on version
+if ($C3Version -eq 'latest') {
+    $DOWNLOAD_URL = "$C3Repourl/releases/latest/download/$BINARY.zip"
+} else {
+    # Ensure version starts with 'v'
+    $C3Version = "v" + ($C3Version -replace '^v', '')
+    $DOWNLOAD_URL = "$C3Repourl/releases/download/$C3Version/$BINARY.zip"
+}
+
+$BinDir = $C3Home
+
+Write-Host "This script will automatically download and install C3 ($C3Version) for you."
+Write-Host "Getting it from this url: $DOWNLOAD_URL"
+Write-Host "The binary will be installed into '$BinDir'"
+
+# Create temporary file for download
+$TEMP_FILE = [System.IO.Path]::GetTempFileName()
+
+try {
+    # Download the binary
+    Invoke-WebRequest -Uri $DOWNLOAD_URL -OutFile $TEMP_FILE
+
+    # Remove previous installation if it exists
+    if (Test-Path -Path $BinDir) {
+        Remove-Item -Path $BinDir -Recurse -Force | Out-Null
+    }
+
+    # Rename temp file to .zip
+    $ZIP_FILE = $TEMP_FILE + ".zip"
+    Rename-Item -Path $TEMP_FILE -NewName $ZIP_FILE
+
+    # Extract downloaded zip
+    Expand-Archive -Path $ZIP_FILE -DestinationPath $Env:USERPROFILE -Force
+
+    # Rename extracted folder to target installation directory
+    Rename-Item -Path "$Env:USERPROFILE/c3-windows-Release" -NewName $BinDir
+} catch {
+    Write-Host "Error: '$DOWNLOAD_URL' is not available or failed to download"
+    exit 1
+} finally {
+    # Cleanup temporary zip file
+    Remove-Item -Path $ZIP_FILE
+}
+
+# Update PATH environment variable if requested
+if (!$NoPathUpdate) {
+    $PATH = Get-Env 'PATH'
+    if ($PATH -notlike "*$BinDir*") {
+        Write-Output "Adding $BinDir to PATH"
+
+        # Persist PATH for future sessions
+        Write-Env -name 'PATH' -val "$BinDir;$PATH"
+
+        # Update PATH for current session
+        $Env:PATH = "$BinDir;$PATH"
+        Write-Output "You may need to restart your shell"
+    } else {
+        Write-Output "$BinDir is already in PATH"
+    }
+} else {
+    Write-Output "You may need to update your PATH manually to use c3"
+}

install/install.sh

@@ -0,0 +1,137 @@
+#!/usr/bin/env bash
+set -euo pipefail  # Exit on error, unset variables, and fail pipelines on any error
+
+__wrap__() {
+    # Version of C3 to install (default: latest)
+    VERSION="${C3_VERSION:-latest}"
+    # Installation directory (default: ~/.c3)
+    C3_HOME="${C3_HOME:-$HOME/.c3}"
+    # Expand '~' if present
+    C3_HOME="${C3_HOME/#\~/$HOME}"
+    BIN_DIR="$C3_HOME"
+    # C3 compiler repository URL
+    REPO="c3lang/c3c"
+    REPOURL="${C3_REPOURL:-https://github.com/$REPO}"
+
+    detect_platform() {
+        # Detects the operating system
+        local os_type
+        os_type="$(uname -s | tr '[:upper:]' '[:lower:]')"
+
+        case "$os_type" in
+            darwin)  # macOS
+                echo "macos"
+                ;;
+            msys*|mingw*|cygwin*)  # Windows (Git Bash / MSYS / Cygwin)
+                IS_MSYS=true
+                echo "windows"
+                ;;
+            *)
+                echo $os_type
+                ;;
+        esac
+    }
+
+    # Determine platform string
+    PLATFORM="$(detect_platform)"
+
+    # File extension for the archive (ZIP for Windows, TAR.GZ for others)
+    EXT=".tar.gz"
+    BINARY="c3-${PLATFORM}"
+    if [[ "${IS_MSYS:-false}" == true ]]; then
+        EXT=".zip"
+    fi
+
+    # Determine the download URL (latest release or specific version)
+    if [[ "$VERSION" == "latest" ]]; then
+        URL="${REPOURL%/}/releases/latest/download/${BINARY}${EXT}"
+    else
+        URL="${REPOURL%/}/releases/download/v${VERSION#v}/${BINARY}${EXT}"
+    fi
+
+    # Temporary file for the downloaded archive
+    TEMP_FILE="$(mktemp "${TMPDIR:-/tmp}/.C3_install.XXXXXXXX")"
+    trap 'rm -f "$TEMP_FILE"' EXIT  # Ensure temp file is deleted on exit
+
+    download_file() {
+        # Download the archive using curl or wget
+        # Check that the curl version is not 8.8.0, which is broken for --write-out
+        # https://github.com/curl/curl/issues/13845
+        if command -v curl >/dev/null && [[ "$(curl --version | awk 'NR==1{print $2}')" != "8.8.0" ]]; then
+            curl -SL "$URL" -o "$TEMP_FILE"
+        elif command -v wget >/dev/null; then
+            wget -O "$TEMP_FILE" "$URL"
+        else
+            echo "Error: curl or wget is required." >&2
+            exit 1
+        fi
+    }
+
+    echo "Downloading C3 ($VERSION) from $URL..."
+    download_file
+
+    # Remove existing installation and extract the new one
+    rm -rf "$BIN_DIR"
+    if [[ "$EXT" == ".zip" ]]; then
+        unzip "$TEMP_FILE" -d "$HOME"
+    else
+        tar -xzf "$TEMP_FILE" -C "$HOME"
+    fi
+
+    # Move extracted folder to installation directory
+    mv "$HOME/c3" "$BIN_DIR"
+    chmod +x "$BIN_DIR/c3c"  # Ensure compiler binary is executable
+    echo "✅ Installation completed in $BIN_DIR"
+
+    # Update PATH unless suppressed by environment variable
+    if [ -n "${C3_NO_PATH_UPDATE:-}" ]; then
+        echo "No path update because C3_NO_PATH_UPDATE is set"
+    else
+        update_shell() {
+            FILE="$1"
+            LINE="$2"
+
+            # Create shell config file if missing
+            if [ ! -f "$FILE" ]; then
+                touch "$FILE"
+            fi
+
+            # Add the PATH line if not already present
+            if ! grep -Fxq "$LINE" "$FILE"; then
+                echo "Updating '${FILE}'"
+                echo "$LINE" >>"$FILE"
+                echo "Please restart or source your shell."
+            fi
+        }
+
+        # Detect the current shell and add C3 to its PATH
+        case "$(basename "${SHELL-}")" in
+        bash)
+            # Default to bashrc as that is used in non login shells instead of the profile.
+            LINE="export PATH=\"${BIN_DIR}:\$PATH\""
+            update_shell ~/.bashrc "$LINE"
+            ;;
+        fish)
+            LINE="fish_add_path ${BIN_DIR}"
+            update_shell ~/.config/fish/config.fish "$LINE"
+            ;;
+        zsh)
+            LINE="export PATH=\"${BIN_DIR}:\$PATH\""
+            update_shell ~/.zshrc "$LINE"
+            ;;
+        tcsh)
+            LINE="set path = ( ${BIN_DIR} \$path )"
+            update_shell ~/.tcshrc "$LINE"
+            ;;
+        '')
+            echo "warn: Could not detect shell type." >&2
+            echo "      Please permanently add '${BIN_DIR}' to your \$PATH to enable the 'c3c' command." >&2
+            ;;
+        *)
+            echo "warn: Could not update shell $(basename "$SHELL")" >&2
+            echo "      Please permanently add '${BIN_DIR}' to your \$PATH to enable the 'c3c' command." >&2
+            ;;
+        esac
+    fi
+}
+__wrap__

lib/std/ascii.c3

@@ -0,0 +1,42 @@
+<* This module is scheduled for removal, use std::core::ascii *>
+module std::ascii;
+
+macro bool in_range_m(c, start, len) => (uint)(c - start) < len;
+macro bool is_lower_m(c)  => in_range_m(c, 0x61, 26);
+macro bool is_upper_m(c)  => in_range_m(c, 0x41, 26);
+macro bool is_digit_m(c)  => in_range_m(c, 0x30, 10);
+macro bool is_bdigit_m(c) => in_range_m(c, 0x30, 2);
+macro bool is_odigit_m(c) => in_range_m(c, 0x30, 8);
+macro bool is_xdigit_m(c) => in_range_m(c | 32, 0x61, 6) || is_digit_m(c);
+macro bool is_alpha_m(c)  => in_range_m(c | 32, 0x61, 26);
+macro bool is_print_m(c)  => in_range_m(c, 0x20, 95);
+macro bool is_graph_m(c)  => in_range_m(c, 0x21, 94);
+macro bool is_space_m(c)  => in_range_m(c, 0x9, 5) || c == 0x20;
+macro bool is_alnum_m(c)  => is_alpha_m(c) || is_digit_m(c);
+macro bool is_punct_m(c)  => !is_alnum_m(c) && is_graph_m(c);
+macro bool is_blank_m(c)  => c == 0x20 || c == 0x9;
+macro bool is_cntrl_m(c)  => c < 0x20 || c == 0x7f;
+macro to_lower_m(c) => is_upper_m(c) ? c + 0x20 : c;
+macro to_upper_m(c) => is_lower_m(c) ? c - 0x20 : c;
+
+fn bool in_range(char c, char start, char len) => in_range_m(c, start, len);
+
+fn bool char.in_range(char c, char start, char len) => in_range_m(c, start, len);
+
+fn bool uint.in_range(uint c, uint start, uint len) => in_range_m(c, start, len);
+fn bool uint.is_lower(uint c)  @deprecated => is_lower_m(c);
+fn bool uint.is_upper(uint c)  @deprecated => is_upper_m(c);
+fn bool uint.is_digit(uint c)  @deprecated => is_digit_m(c);
+fn bool uint.is_bdigit(uint c) @deprecated => is_bdigit_m(c);
+fn bool uint.is_odigit(uint c) @deprecated => is_odigit_m(c);
+fn bool uint.is_xdigit(uint c) @deprecated => is_xdigit_m(c);
+fn bool uint.is_alpha(uint c)  @deprecated => is_alpha_m(c);
+fn bool uint.is_print(uint c)  @deprecated => is_print_m(c);
+fn bool uint.is_graph(uint c)  @deprecated => is_graph_m(c);
+fn bool uint.is_space(uint c)  @deprecated => is_space_m(c);
+fn bool uint.is_alnum(uint c)  @deprecated => is_alnum_m(c);
+fn bool uint.is_punct(uint c)  @deprecated => is_punct_m(c);
+fn bool uint.is_blank(uint c)  @deprecated => is_blank_m(c);
+fn bool uint.is_cntrl(uint c)  @deprecated => is_cntrl_m(c);
+fn uint uint.to_lower(uint c)  @deprecated => (uint)to_lower_m(c);
+fn uint uint.to_upper(uint c)  @deprecated => (uint)to_upper_m(c);

lib/std/atomic.c3

@@ -1,5 +1,473 @@
-// Copyright (c) 2021 Christoffer Lerno. All rights reserved.
+// Copyright (c) 2023-2025 Eduardo José Gómez Hernández. All rights reserved.
 // Use of this source code is governed by the MIT license
 // a copy of which can be found in the LICENSE_STDLIB file.
-module std::atomic;
+module std::atomic::types;
 
+struct Atomic <Type>
+{
+	Type data;
+}
+
+<*
+ Loads data atomically, by default this uses SEQ_CONSISTENT ordering.
+
+ @param $ordering : "The ordering, cannot be release or acquire-release."
+ @require $ordering != RELEASE && $ordering != ACQUIRE_RELEASE : "Release and acquire-release are not valid for load"
+*>
+macro Type Atomic.load(&self, AtomicOrdering $ordering = SEQ_CONSISTENT)
+{
+	return $$atomic_load(&self.data, false, $ordering.ordinal);
+}
+<*
+ Stores data atomically, by default this uses SEQ_CONSISTENT ordering.
+
+ @param $ordering : "The ordering, cannot be acquire or acquire-release."
+ @require $ordering != ACQUIRE && $ordering != ACQUIRE_RELEASE : "Acquire and acquire-release are not valid for store"
+*>
+macro void Atomic.store(&self, Type value, AtomicOrdering $ordering = SEQ_CONSISTENT)
+{
+	$$atomic_store(&self.data, value, false, $ordering.ordinal);
+}
+
+macro Type Atomic.add(&self, Type value, AtomicOrdering $ordering = SEQ_CONSISTENT)
+{
+	return atomic::fetch_add(&self.data, value, $ordering);
+}
+
+macro Type Atomic.sub(&self, Type value, AtomicOrdering $ordering = SEQ_CONSISTENT)
+{
+	return atomic::fetch_sub(&self.data, value, $ordering);
+}
+
+macro Type Atomic.mul(&self, Type value, AtomicOrdering $ordering = SEQ_CONSISTENT)
+{
+	return atomic::fetch_mul(&self.data, value, $ordering);
+}
+
+macro Type Atomic.div(&self, Type value, AtomicOrdering $ordering = SEQ_CONSISTENT)
+{
+	return atomic::fetch_div(&self.data, value, $ordering);
+}
+
+macro Type Atomic.max(&self, Type value, AtomicOrdering $ordering = SEQ_CONSISTENT)
+{
+	return atomic::fetch_max(&self.data, value, $ordering);
+}
+
+macro Type Atomic.min(&self, Type value, AtomicOrdering $ordering = SEQ_CONSISTENT)
+{
+	return atomic::fetch_min(&self.data, value, $ordering);
+}
+
+macro Type Atomic.or(&self, Type value, AtomicOrdering $ordering = SEQ_CONSISTENT) @if(types::flat_kind(Type) != FLOAT)
+{
+	return atomic::fetch_or(&self.data, value, $ordering);
+}
+
+macro Type Atomic.xor(&self, Type value, AtomicOrdering $ordering = SEQ_CONSISTENT) @if(types::flat_kind(Type) != FLOAT)
+{
+	return atomic::fetch_xor(&self.data, value, $ordering);
+}
+
+macro Type Atomic.and(&self, Type value, AtomicOrdering $ordering = SEQ_CONSISTENT) @if(types::flat_kind(Type) != FLOAT)
+{
+	return atomic::fetch_and(&self.data, value, $ordering);
+}
+
+macro Type Atomic.shr(&self, Type amount, AtomicOrdering $ordering = SEQ_CONSISTENT) @if(types::flat_kind(Type) != FLOAT)
+{
+	return atomic::fetch_shift_right(&self.data, amount, $ordering);
+}
+
+macro Type Atomic.shl(&self, Type amount, AtomicOrdering $ordering = SEQ_CONSISTENT) @if(types::flat_kind(Type) != FLOAT)
+{
+	return atomic::fetch_shift_left(&self.data, amount, $ordering);
+}
+
+macro Type Atomic.set(&self, AtomicOrdering $ordering = SEQ_CONSISTENT) @if(types::flat_kind(Type) == BOOL)
+{
+	return atomic::flag_set(&self.data, $ordering);
+}
+
+macro Type Atomic.clear(&self, AtomicOrdering $ordering = SEQ_CONSISTENT) @if(types::flat_kind(Type) == BOOL)
+{
+	return atomic::flag_clear(&self.data, $ordering);
+}
+
+module std::atomic;
+import std::math;
+
+macro bool @is_native_atomic_value(#value) @private
+{
+	return is_native_atomic_type($typeof(#value));
+}
+
+macro bool is_native_atomic_type($Type)
+{
+	$if $Type.sizeof > void*.sizeof:
+		return false;
+	$else
+		$switch $Type.kindof:
+			$case SIGNED_INT:
+			$case UNSIGNED_INT:
+			$case POINTER:
+			$case FUNC:
+			$case FLOAT:
+			$case BOOL:
+				return true;
+			$case TYPEDEF:
+			$case CONSTDEF:
+				return is_native_atomic_type($Type.inner);
+			$default:
+				return false;
+		$endswitch
+	$endif
+}
+
+<*
+ @param [&inout] ptr : "the variable or dereferenced pointer to the data."
+ @param [in] y : "the value to be added to ptr."
+ @param $ordering : "atomic ordering of the load, defaults to SEQ_CONSISTENT"
+ @return "returns the old value of ptr"
+
+ @require !$alignment || math::is_power_of_2($alignment) : "Alignment must be a power of two."
+ @require $defined(*ptr) : "Expected a pointer"
+ @require @is_native_atomic_value(*ptr) : "Only types that are native atomic may be used."
+ @require $defined(*ptr + y) : "+ must be defined between the values."
+ @require $ordering != NOT_ATOMIC && $ordering != UNORDERED : "Acquire ordering is not valid."
+*>
+macro fetch_add(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT, bool $volatile = false, usz $alignment = 0)
+{
+	$if $alignment == 0:
+		$alignment = $typeof(*ptr).sizeof;
+	$endif
+	return $$atomic_fetch_add(ptr, y, $volatile, $ordering.ordinal, $alignment);
+}
+
+<*
+ @param [&inout] ptr : "the variable or dereferenced pointer to the data."
+ @param [in] y : "the value to be subtracted from ptr."
+ @param $ordering : "atomic ordering of the load, defaults to SEQ_CONSISTENT"
+ @return "returns the old value of ptr"
+
+ @require !$alignment || math::is_power_of_2($alignment) : "Alignment must be a power of two."
+ @require $defined(*ptr) : "Expected a pointer"
+ @require @is_native_atomic_value(*ptr) : "Only types that are native atomic may be used."
+ @require $defined(*ptr - y) : "- must be defined between the values."
+ @require $ordering != NOT_ATOMIC && $ordering != UNORDERED : "Acquire ordering is not valid."
+*>
+macro fetch_sub(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT, bool $volatile = false, usz $alignment = 0)
+{
+	$if $alignment == 0:
+		$alignment = $typeof(*ptr).sizeof;
+	$endif
+	return $$atomic_fetch_sub(ptr, y, $volatile, $ordering.ordinal, $alignment);
+}
+
+<*
+ @param [&inout] ptr : "the variable or dereferenced pointer to the data."
+ @param [in] y : "the value to be multiplied with ptr."
+ @param $ordering : "atomic ordering of the load, defaults to SEQ_CONSISTENT"
+ @return "returns the old value of ptr"
+
+ @require $defined(*ptr) : "Expected a pointer"
+ @require @is_native_atomic_value(*ptr) : "Only types that are native atomic may be used."
+ @require $defined(*ptr * y) : "* must be defined between the values."
+ @require $ordering != NOT_ATOMIC && $ordering != UNORDERED : "Acquire ordering is not valid."
+*>
+macro fetch_mul(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT)
+{
+	var $load_ordering = $ordering;
+	$if $ordering == RELEASE || $ordering == ACQUIRE_RELEASE:
+	    $load_ordering = SEQ_CONSISTENT;
+	$endif
+	
+	var $StorageType = types::lower_to_atomic_compatible_type($typeof(*ptr));
+
+	$StorageType* storage_ptr = ($StorageType*)ptr;
+
+	$typeof(*ptr) old_value;
+	$typeof(*ptr) new_value;
+
+	$StorageType storage_old_value;
+	$StorageType storage_new_value;
+
+	do
+	{
+		storage_old_value = $$atomic_load(storage_ptr, false, $load_ordering.ordinal);
+		old_value = bitcast(storage_old_value, $typeof(*ptr));
+		new_value = old_value * y;
+		storage_new_value = bitcast(new_value, $StorageType);
+	}
+	while (mem::compare_exchange(storage_ptr, storage_old_value, storage_new_value, $ordering, $load_ordering) != storage_old_value);
+
+	return old_value;
+}
+
+<*
+ @param [&inout] ptr : "the variable or dereferenced pointer to the data."
+ @param [in] y : "the value to divide ptr by."
+ @param $ordering : "atomic ordering of the load, defaults to SEQ_CONSISTENT"
+ @return "returns the old value of ptr"
+
+ @require $defined(*ptr) : "Expected a pointer"
+ @require @is_native_atomic_value(*ptr) : "Only types that are native atomic may be used."
+ @require $defined(*ptr / y) : "/ must be defined between the values."
+ @require $ordering != NOT_ATOMIC && $ordering != UNORDERED : "Acquire ordering is not valid."
+*>
+macro fetch_div(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT)
+{
+	var $load_ordering = $ordering;
+	$if $ordering == RELEASE || $ordering == ACQUIRE_RELEASE:
+	    $load_ordering = SEQ_CONSISTENT;
+	$endif
+	
+	var $StorageType = types::lower_to_atomic_compatible_type($typeof(*ptr));
+
+	$StorageType* storage_ptr = ($StorageType*)ptr;
+
+	$typeof(*ptr) old_value;
+	$typeof(*ptr) new_value;
+
+	$StorageType storage_old_value;
+	$StorageType storage_new_value;
+	
+	do
+	{
+		storage_old_value = $$atomic_load(storage_ptr, false, $load_ordering.ordinal);
+		old_value = bitcast(storage_old_value, $typeof(*ptr));
+		new_value = old_value / y;
+		storage_new_value = bitcast(new_value, $StorageType);
+	}
+	while (mem::compare_exchange(storage_ptr, storage_old_value, storage_new_value, $ordering, $load_ordering) != storage_old_value);
+
+	return old_value;
+}
+
+<*
+ @param [&inout] ptr : "the variable or dereferenced pointer to the data."
+ @param [in] y : "the value to perform a bitwise or with."
+ @param $ordering : "atomic ordering of the load, defaults to SEQ_CONSISTENT"
+ @return "returns the old value of ptr"
+
+ @require !$alignment || math::is_power_of_2($alignment) : "Alignment must be a power of two."
+ @require $defined(*ptr) : "Expected a pointer"
+ @require @is_native_atomic_value(*ptr) : "Only types that are native atomic may be used."
+ @require $defined(*ptr | y) : "| must be defined between the values."
+ @require $ordering != NOT_ATOMIC && $ordering != UNORDERED : "Acquire ordering is not valid."
+*>
+macro fetch_or(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT, bool $volatile = false, usz $alignment = 0)
+{
+	return $$atomic_fetch_or(ptr, y, $volatile, $ordering.ordinal, $alignment);
+}
+
+<*
+ @param [&inout] ptr : "the variable or dereferenced pointer to the data."
+ @param [in] y : "the value to perform a bitwise xor with."
+ @param $ordering : "atomic ordering of the load, defaults to SEQ_CONSISTENT"
+ @return "returns the old value of ptr"
+
+ @require !$alignment || math::is_power_of_2($alignment) : "Alignment must be a power of two."
+ @require $defined(*ptr) : "Expected a pointer"
+ @require @is_native_atomic_value(*ptr) : "Only types that are native atomic may be used."
+ @require $defined(*ptr ^ y) : "^ must be defined between the values."
+ @require $ordering != NOT_ATOMIC && $ordering != UNORDERED : "Acquire ordering is not valid."
+*>
+macro fetch_xor(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT, bool $volatile = false, usz $alignment = 0)
+{
+	return $$atomic_fetch_xor(ptr, y, $volatile, $ordering.ordinal, $alignment);
+}
+
+<*
+ @param [&inout] ptr : "the variable or dereferenced pointer to the data."
+ @param [in] y : "the value to perform a bitwise and with."
+ @param $ordering : "atomic ordering of the load, defaults to SEQ_CONSISTENT"
+ @return "returns the old value of ptr"
+
+ @require !$alignment || math::is_power_of_2($alignment) : "Alignment must be a power of two."
+ @require $defined(*ptr) : "Expected a pointer"
+ @require @is_native_atomic_value(*ptr) : "Only types that are native atomic may be used."
+ @require $defined(*ptr ^ y) : "& must be defined between the values."
+ @require $ordering != NOT_ATOMIC && $ordering != UNORDERED : "Acquire ordering is not valid."
+*>
+macro fetch_and(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT, bool $volatile = false, usz $alignment = 0)
+{
+	return $$atomic_fetch_and(ptr, y, $volatile, $ordering.ordinal, $alignment);
+}
+
+<*
+ @param [&inout] ptr : "the variable or dereferenced pointer to the data."
+ @param [in] y : "the value to shift ptr by."
+ @param $ordering : "atomic ordering of the load, defaults to SEQ_CONSISTENT"
+ @return "returns the old value of ptr"
+
+ @require $defined(*ptr) : "Expected a pointer"
+ @require @is_native_atomic_value(*ptr) : "Only types that are native atomic may be used."
+ @require types::is_int($typeof(*ptr)) : "Only integer pointers may be used."
+ @require types::is_int($typeof(y)) : "The value for shift right must be an integer"
+ @require $ordering != NOT_ATOMIC && $ordering != UNORDERED : "Acquire ordering is not valid."
+*>
+macro fetch_shift_right(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT)
+{
+	var $load_ordering = $ordering;
+	$if $ordering == RELEASE || $ordering == ACQUIRE_RELEASE:
+	    $load_ordering = SEQ_CONSISTENT;
+	$endif
+	
+	var $StorageType = types::lower_to_atomic_compatible_type($typeof(*ptr));
+
+	$StorageType* storage_ptr = ($StorageType*)ptr;
+
+	$typeof(*ptr) old_value;
+	$typeof(*ptr) new_value;
+
+	$StorageType storage_old_value;
+	$StorageType storage_new_value;
+	$StorageType storage_y = ($StorageType)y;
+	
+	do
+	{
+		storage_old_value = $$atomic_load(storage_ptr, false, $load_ordering.ordinal);
+		old_value = bitcast(storage_old_value, $typeof(*ptr));
+		new_value = storage_old_value >> storage_y;
+		storage_new_value = bitcast(new_value, $StorageType);
+	}
+	while (mem::compare_exchange(storage_ptr, storage_old_value, storage_new_value, $ordering, $load_ordering) != storage_old_value);
+
+	return old_value;
+}
+
+<*
+ @param [&inout] ptr : "the variable or dereferenced pointer to the data."
+ @param [in] y : "the value to shift ptr by."
+ @param $ordering : "atomic ordering of the load, defaults to SEQ_CONSISTENT"
+ @return "returns the old value of ptr"
+
+ @require $defined(*ptr) : "Expected a pointer"
+ @require @is_native_atomic_value(*ptr) : "Only types that are native atomic may be used."
+ @require types::is_int($typeof(*ptr)) : "Only integer pointers may be used."
+ @require types::is_int($typeof(y)) : "The value for shift left must be an integer"
+ @require $ordering != NOT_ATOMIC && $ordering != UNORDERED : "Acquire ordering is not valid."
+*>
+macro fetch_shift_left(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT)
+{
+	var $load_ordering = $ordering;
+	$if $ordering == RELEASE || $ordering == ACQUIRE_RELEASE:
+	    $load_ordering = SEQ_CONSISTENT;
+	$endif
+	
+	var $StorageType = types::lower_to_atomic_compatible_type($typeof(*ptr));
+
+	$StorageType* storage_ptr = ($StorageType*)ptr;
+
+	$typeof(*ptr) old_value;
+	$typeof(*ptr) new_value;
+
+	$StorageType storage_old_value;
+	$StorageType storage_new_value;
+	$StorageType storage_y = ($StorageType)y;
+	
+	do
+	{
+		storage_old_value = $$atomic_load(storage_ptr, false, $load_ordering.ordinal);
+		old_value = bitcast(storage_old_value, $typeof(*ptr));
+		new_value = storage_old_value << storage_y;
+		storage_new_value = bitcast(new_value, $StorageType);
+	}
+	while (mem::compare_exchange(storage_ptr, storage_old_value, storage_new_value, $ordering, $load_ordering) != storage_old_value);
+
+	return old_value;
+}
+
+<*
+ @param [&inout] ptr : "the variable or dereferenced pointer to the data."
+ @param $ordering : "atomic ordering of the load, defaults to SEQ_CONSISTENT"
+ @return "returns the old value of ptr"
+
+ @require $defined(*ptr) : "Expected a pointer"
+ @require @is_native_atomic_value(*ptr) : "Only types that are native atomic may be used."
+ @require types::flat_kind($typeof(*ptr)) == BOOL : "Only bool pointers may be used."
+
+ @require $ordering != NOT_ATOMIC && $ordering != UNORDERED : "Acquire ordering is not valid."
+*>
+macro flag_set(ptr, AtomicOrdering $ordering = SEQ_CONSISTENT)
+{
+	$typeof(*ptr) old_value;
+	$typeof(*ptr) new_value = true;
+	var $load_ordering = $ordering;
+	$if $ordering == RELEASE || $ordering == ACQUIRE_RELEASE:
+	    $load_ordering = SEQ_CONSISTENT;
+	$endif
+	do
+	{
+		old_value = $$atomic_load(ptr, false, $load_ordering.ordinal);
+	}
+	while (mem::compare_exchange(ptr, old_value, new_value, $ordering, $load_ordering) != old_value);
+
+	return old_value;
+}
+
+<*
+ @param [&inout] ptr : "the variable or dereferenced pointer to the data."
+ @param $ordering : "atomic ordering of the load, defaults to SEQ_CONSISTENT"
+ @return "returns the old value of ptr"
+
+ @require $defined(*ptr) : "Expected a pointer"
+ @require @is_native_atomic_value(*ptr) : "Only types that are native atomic may be used."
+ @require types::flat_kind($typeof(*ptr)) == BOOL : "Only bool pointers may be used."
+ @require $ordering != NOT_ATOMIC && $ordering != UNORDERED : "Acquire ordering is not valid."
+*>
+macro flag_clear(ptr, AtomicOrdering $ordering = SEQ_CONSISTENT)
+{
+	$typeof(*ptr) old_value;
+	$typeof(*ptr) new_value = false;
+	var $load_ordering = $ordering;
+	$if $ordering == RELEASE || $ordering == ACQUIRE_RELEASE:
+	    $load_ordering = SEQ_CONSISTENT;
+	$endif
+	do
+	{
+		old_value = $$atomic_load(ptr, false, $load_ordering.ordinal);
+	}
+	while (mem::compare_exchange(ptr, old_value, new_value, $ordering, $load_ordering) != old_value);
+
+	return old_value;
+}
+
+<*
+ @param [&in] ptr : "the variable or dereferenced pointer to the data."
+ @param [in] y : "the value to be compared to ptr."
+ @param $ordering : "atomic ordering of the load, defaults to SEQ_CONSISTENT"
+ @return "returns the old value of ptr"
+
+ @require $defined(*ptr) : "Expected a pointer"
+ @require @is_native_atomic_value(*ptr) : "Only types that are native atomic may be used."
+ @require $defined(*ptr > y) : "Only values that are comparable with > may be used"
+ @require $ordering != NOT_ATOMIC && $ordering != UNORDERED : "Acquire ordering is not valid."
+*>
+macro fetch_max(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT, bool $volatile = false, usz $alignment = 0)
+{
+	$if $alignment == 0:
+		$alignment = $typeof(*ptr).sizeof;
+	$endif
+	return $$atomic_fetch_max(ptr, y, $volatile, $ordering.ordinal, $alignment);
+}
+
+<*
+ @param [&in] ptr : "the variable or dereferenced pointer to the data."
+ @param [in] y : "the value to be compared to ptr."
+ @param $ordering : "atomic ordering of the load, defaults to SEQ_CONSISTENT"
+ @return "returns the old value of ptr"
+
+ @require $defined(*ptr) : "Expected a pointer"
+ @require @is_native_atomic_value(*ptr) : "Only types that are native atomic may be used."
+ @require $defined(*ptr > y) : "Only values that are comparable with > may be used"
+ @require $ordering != NOT_ATOMIC && $ordering != UNORDERED : "Acquire ordering is not valid."
+*>
+macro fetch_min(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT, bool $volatile = false, usz $alignment = 0)
+{
+	$if $alignment == 0:
+		$alignment = $typeof(*ptr).sizeof;
+	$endif
+	return $$atomic_fetch_min(ptr, y, $volatile, $ordering.ordinal, $alignment);
+}

lib/std/atomic_nolibc.c3

@@ -0,0 +1,64 @@
+// Copyright (c) 2023 Eduardo José Gómez Hernández. All rights reserved.
+// Use of this source code is governed by the MIT license
+// a copy of which can be found in the LICENSE_STDLIB file.
+module std::atomic;
+
+macro @__atomic_compare_exchange_ordering_failure(ptr, expected, desired, $success, failure, $alignment)
+{
+	switch (failure)
+	{
+		case AtomicOrdering.RELAXED.ordinal: return $$compare_exchange(ptr, expected, desired, false, false, $success, AtomicOrdering.RELAXED.ordinal, $alignment);
+		case AtomicOrdering.ACQUIRE.ordinal: return $$compare_exchange(ptr, expected, desired, false, false, $success, AtomicOrdering.ACQUIRE.ordinal, $alignment);
+		case AtomicOrdering.SEQ_CONSISTENT.ordinal: return $$compare_exchange(ptr, expected, desired, false, false, $success, AtomicOrdering.SEQ_CONSISTENT.ordinal, $alignment);
+		default: unreachable("Unrecognized failure ordering");
+	}
+	return 0;
+}
+
+macro @__atomic_compare_exchange_ordering_success(ptr, expected, desired, success, failure, $alignment)
+{
+	switch (success)
+	{
+		case AtomicOrdering.RELAXED.ordinal: return @__atomic_compare_exchange_ordering_failure(ptr, expected, desired, AtomicOrdering.RELAXED.ordinal, failure, $alignment);
+		case AtomicOrdering.ACQUIRE.ordinal: return @__atomic_compare_exchange_ordering_failure(ptr, expected, desired, AtomicOrdering.ACQUIRE.ordinal, failure, $alignment);
+		case AtomicOrdering.RELEASE.ordinal: return @__atomic_compare_exchange_ordering_failure(ptr, expected, desired, AtomicOrdering.RELEASE.ordinal, failure, $alignment);
+		case AtomicOrdering.ACQUIRE_RELEASE.ordinal: return @__atomic_compare_exchange_ordering_failure(ptr, expected, desired, AtomicOrdering.ACQUIRE_RELEASE.ordinal, failure, $alignment);
+		case AtomicOrdering.SEQ_CONSISTENT.ordinal: return @__atomic_compare_exchange_ordering_failure(ptr, expected, desired, AtomicOrdering.SEQ_CONSISTENT.ordinal, failure, $alignment);
+		default: unreachable("Unrecognized success ordering");
+	}
+	return 0;
+}
+
+fn CInt __atomic_compare_exchange(CInt size, any ptr, any expected, any desired, CInt success, CInt failure) @weak @export("__atomic_compare_exchange")
+{
+	switch (size)
+	{
+		case 1:
+			char* pt = (char*)ptr;
+			char ex = *(char*)expected;
+			char de = *(char*)desired;
+			if (ex == @__atomic_compare_exchange_ordering_success(pt, ex, de, success, failure, 1)) return 1;
+		case 2:
+			short* pt = (short*)ptr;
+			short ex = *(short*)expected;
+			short de = *(short*)desired;
+			if (ex == @__atomic_compare_exchange_ordering_success(pt, ex, de, success, failure, 2)) return 1;
+		case 4:
+			int* pt = (int*)ptr;
+			int ex = *(int*)expected;
+			int de = *(int*)desired;
+			if (ex == @__atomic_compare_exchange_ordering_success(pt, ex, de, success, failure, 4)) return 1;
+		case 8:
+			$if iptr.sizeof >= 8:
+				long* pt = (long*)ptr;
+				long ex = *(long*)expected;
+				long de = *(long*)desired;
+				if (ex == @__atomic_compare_exchange_ordering_success(pt, ex, de, success, failure, 8)) return 1;
+			$else
+				nextcase;
+			$endif
+		default:
+			unreachable("Unsupported size (%d) for atomic_compare_exchange", size);
+	}
+	return 0;
+}

lib/std/bits.c3

@@ -0,0 +1,171 @@
+module std::bits;
+
+<*
+ @require types::is_intlike($typeof(i)) : `The input must be an integer or integer vector`
+*>
+macro reverse(i) => $$bitreverse(i);
+
+<*
+ @require types::is_intlike($typeof(i)) : `The input must be an integer or integer vector`
+*>
+macro bswap(i) @builtin => $$bswap(i);
+
+macro uint[<*>].popcount(self) => $$popcount(self);
+macro uint[<*>].ctz(self) => $$ctz(self);
+macro uint[<*>].clz(self) => $$clz(self);
+macro uint[<*>] uint[<*>].fshl(hi, uint[<*>] lo, uint[<*>] shift) => $$fshl(hi, lo, shift);
+macro uint[<*>] uint[<*>].fshr(hi, uint[<*>] lo, uint[<*>] shift) => $$fshr(hi, lo, shift);
+macro uint[<*>] uint[<*>].rotl(self, uint[<*>] shift) => $$fshl(self, self, shift);
+macro uint[<*>] uint[<*>].rotr(self, uint[<*>] shift) => $$fshr(self, self, shift);
+
+macro int[<*>].popcount(self) => $$popcount(self);
+macro int[<*>].ctz(self) => $$ctz(self);
+macro int[<*>].clz(self) => $$clz(self);
+macro int[<*>] int[<*>].fshl(hi, int[<*>] lo, int[<*>] shift) => $$fshl(hi, lo, shift);
+macro int[<*>] int[<*>].fshr(hi, int[<*>] lo, int[<*>] shift) => $$fshr(hi, lo, shift);
+macro int[<*>] int[<*>].rotl(self, int[<*>] shift) => $$fshl(self, self, shift);
+macro int[<*>] int[<*>].rotr(self, int[<*>] shift) => $$fshr(self, self, shift);
+
+macro ushort[<*>].popcount(self) => $$popcount(self);
+macro ushort[<*>].ctz(self) => $$ctz(self);
+macro ushort[<*>].clz(self) => $$clz(self);
+macro ushort[<*>] ushort[<*>].fshl(hi, ushort[<*>] lo, ushort[<*>] shift) => $$fshl(hi, lo, shift);
+macro ushort[<*>] ushort[<*>].fshr(hi, ushort[<*>] lo, ushort[<*>] shift) => $$fshr(hi, lo, shift);
+macro ushort[<*>] ushort[<*>].rotl(self, ushort[<*>] shift) => $$fshl(self, self, shift);
+macro ushort[<*>] ushort[<*>].rotr(self, ushort[<*>] shift) => $$fshr(self, self, shift);
+
+macro short[<*>].popcount(self) => $$popcount(self);
+macro short[<*>].ctz(self) => $$ctz(self);
+macro short[<*>].clz(self) => $$clz(self);
+macro short[<*>] short[<*>].fshl(hi, short[<*>] lo, short[<*>] shift) => $$fshl(hi, lo, shift);
+macro short[<*>] short[<*>].fshr(hi, short[<*>] lo, short[<*>] shift) => $$fshr(hi, lo, shift);
+macro short[<*>] short[<*>].rotl(self, short[<*>] shift) => $$fshl(self, self, shift);
+macro short[<*>] short[<*>].rotr(self, short[<*>] shift) => $$fshr(self, self, shift);
+
+macro char[<*>].popcount(self) => $$popcount(self);
+macro char[<*>].ctz(self) => $$ctz(self);
+macro char[<*>].clz(self) => $$clz(self);
+macro char[<*>] char[<*>].fshl(hi, char[<*>] lo, char[<*>] shift) => $$fshl(hi, lo, shift);
+macro char[<*>] char[<*>].fshr(hi, char[<*>] lo, char[<*>] shift) => $$fshr(hi, lo, shift);
+macro char[<*>] char[<*>].rotl(self, char[<*>] shift) => $$fshl(self, self, shift);
+macro char[<*>] char[<*>].rotr(self, char[<*>] shift) => $$fshr(self, self, shift);
+
+macro ichar[<*>].popcount(self) => $$popcount(self);
+macro ichar[<*>].ctz(self) => $$ctz(self);
+macro ichar[<*>].clz(self) => $$clz(self);
+macro ichar[<*>] ichar[<*>].fshl(hi, ichar[<*>] lo, ichar[<*>] shift) => $$fshl(hi, lo, shift);
+macro ichar[<*>] ichar[<*>].fshr(hi, ichar[<*>] lo, ichar[<*>] shift) => $$fshr(hi, lo, shift);
+macro ichar[<*>] ichar[<*>].rotl(self, ichar[<*>] shift) => $$fshl(self, self, shift);
+macro ichar[<*>] ichar[<*>].rotr(self, ichar[<*>] shift) => $$fshr(self, self, shift);
+
+macro ulong[<*>].popcount(self) => $$popcount(self);
+macro ulong[<*>].ctz(self) => $$ctz(self);
+macro ulong[<*>].clz(self) => $$clz(self);
+macro ulong[<*>] ulong[<*>].fshl(hi, ulong[<*>] lo, ulong[<*>] shift) => $$fshl(hi, lo, shift);
+macro ulong[<*>] ulong[<*>].fshr(hi, ulong[<*>] lo, ulong[<*>] shift) => $$fshr(hi, lo, shift);
+macro ulong[<*>] ulong[<*>].rotl(self, ulong[<*>] shift) => $$fshl(self, self, shift);
+macro ulong[<*>] ulong[<*>].rotr(self, ulong[<*>] shift) => $$fshr(self, self, shift);
+
+macro long[<*>].popcount(self) => $$popcount(self);
+macro long[<*>].ctz(self) => $$ctz(self);
+macro long[<*>].clz(self) => $$clz(self);
+macro long[<*>] long[<*>].fshl(hi, long[<*>] lo, long[<*>] shift) => $$fshl(hi, lo, shift);
+macro long[<*>] long[<*>].fshr(hi, long[<*>] lo, long[<*>] shift) => $$fshr(hi, lo, shift);
+macro long[<*>] long[<*>].rotl(self, long[<*>] shift) => $$fshl(self, self, shift);
+macro long[<*>] long[<*>].rotr(self, long[<*>] shift) => $$fshr(self, self, shift);
+
+macro uint128[<*>].popcount(self) => $$popcount(self);
+macro uint128[<*>].ctz(self) => $$ctz(self);
+macro uint128[<*>].clz(self) => $$clz(self);
+macro uint128[<*>] uint128[<*>].fshl(hi, uint128[<*>] lo, uint128[<*>] shift) => $$fshl(hi, lo, shift);
+macro uint128[<*>] uint128[<*>].fshr(hi, uint128[<*>] lo, uint128[<*>] shift) => $$fshr(hi, lo, shift);
+macro uint128[<*>] uint128[<*>].rotl(self, uint128[<*>] shift) => $$fshl(self, self, shift);
+macro uint128[<*>] uint128[<*>].rotr(self, uint128[<*>] shift) => $$fshr(self, self, shift);
+
+macro int128[<*>].popcount(self) => $$popcount(self);
+macro int128[<*>].ctz(self) => $$ctz(self);
+macro int128[<*>].clz(self) => $$clz(self);
+macro int128[<*>] int128[<*>].fshl(hi, int128[<*>] lo, int128[<*>] shift) => $$fshl(hi, lo, shift);
+macro int128[<*>] int128[<*>].fshr(hi, int128[<*>] lo, int128[<*>] shift) => $$fshr(hi, lo, shift);
+macro int128[<*>] int128[<*>].rotl(self, int128[<*>] shift) => $$fshl(self, self, shift);
+macro int128[<*>] int128[<*>].rotr(self, int128[<*>] shift) => $$fshr(self, self, shift);
+
+macro uint.popcount(self) => $$popcount(self);
+macro uint.ctz(self) => $$ctz(self);
+macro uint.clz(self) => $$clz(self);
+macro uint uint.fshl(hi, uint lo, uint shift) => $$fshl(hi, lo, shift);
+macro uint uint.fshr(hi, uint lo, uint shift) => $$fshr(hi, lo, shift);
+macro uint uint.rotl(self, uint shift) => $$fshl(self, self, shift);
+macro uint uint.rotr(self, uint shift) => $$fshr(self, self, shift);
+
+macro int.popcount(self) => $$popcount(self);
+macro int.ctz(self) => $$ctz(self);
+macro int.clz(self) => $$clz(self);
+macro int int.fshl(hi, int lo, int shift) => $$fshl(hi, lo, shift);
+macro int int.fshr(hi, int lo, int shift) => $$fshr(hi, lo, shift);
+macro int int.rotl(self, int shift) => $$fshl(self, self, shift);
+macro int int.rotr(self, int shift) => $$fshr(self, self, shift);
+
+macro ushort.popcount(self) => $$popcount(self);
+macro ushort.ctz(self) => $$ctz(self);
+macro ushort.clz(self) => $$clz(self);
+macro ushort ushort.fshl(hi, ushort lo, ushort shift) => $$fshl(hi, lo, shift);
+macro ushort ushort.fshr(hi, ushort lo, ushort shift) => $$fshr(hi, lo, shift);
+macro ushort ushort.rotl(self, ushort shift) => $$fshl(self, self, shift);
+macro ushort ushort.rotr(self, ushort shift) => $$fshr(self, self, shift);
+
+macro short.popcount(self) => $$popcount(self);
+macro short.ctz(self) => $$ctz(self);
+macro short.clz(self) => $$clz(self);
+macro short short.fshl(hi, short lo, short shift) => $$fshl(hi, lo, shift);
+macro short short.fshr(hi, short lo, short shift) => $$fshr(hi, lo, shift);
+macro short short.rotl(self, short shift) => $$fshl(self, self, shift);
+macro short short.rotr(self, short shift) => $$fshr(self, self, shift);
+
+macro char.popcount(self) => $$popcount(self);
+macro char.ctz(self) => $$ctz(self);
+macro char.clz(self) => $$clz(self);
+macro char char.fshl(hi, char lo, char shift) => $$fshl(hi, lo, shift);
+macro char char.fshr(hi, char lo, char shift) => $$fshr(hi, lo, shift);
+macro char char.rotl(self, char shift) => $$fshl(self, self, shift);
+macro char char.rotr(self, char shift) => $$fshr(self, self, shift);
+
+macro ichar.popcount(self) => $$popcount(self);
+macro ichar.ctz(self) => $$ctz(self);
+macro ichar.clz(self) => $$clz(self);
+macro ichar ichar.fshl(hi, ichar lo, ichar shift) => $$fshl(hi, lo, shift);
+macro ichar ichar.fshr(hi, ichar lo, ichar shift) => $$fshr(hi, lo, shift);
+macro ichar ichar.rotl(self, ichar shift) => $$fshl(self, self, shift);
+macro ichar ichar.rotr(self, ichar shift) => $$fshr(self, self, shift);
+
+macro ulong.popcount(self) => $$popcount(self);
+macro ulong.ctz(self) => $$ctz(self);
+macro ulong.clz(self) => $$clz(self);
+macro ulong ulong.fshl(hi, ulong lo, ulong shift) => $$fshl(hi, lo, shift);
+macro ulong ulong.fshr(hi, ulong lo, ulong shift) => $$fshr(hi, lo, shift);
+macro ulong ulong.rotl(self, ulong shift) => $$fshl(self, self, shift);
+macro ulong ulong.rotr(self, ulong shift) => $$fshr(self, self, shift);
+
+macro long.popcount(self) => $$popcount(self);
+macro long.ctz(self) => $$ctz(self);
+macro long.clz(self) => $$clz(self);
+macro long long.fshl(hi, long lo, long shift) => $$fshl(hi, lo, shift);
+macro long long.fshr(hi, long lo, long shift) => $$fshr(hi, lo, shift);
+macro long long.rotl(self, long shift) => $$fshl(self, self, shift);
+macro long long.rotr(self, long shift) => $$fshr(self, self, shift);
+
+macro uint128.popcount(self) => $$popcount(self);
+macro uint128.ctz(self) => $$ctz(self);
+macro uint128.clz(self) => $$clz(self);
+macro uint128 uint128.fshl(hi, uint128 lo, uint128 shift) => $$fshl(hi, lo, shift);
+macro uint128 uint128.fshr(hi, uint128 lo, uint128 shift) => $$fshr(hi, lo, shift);
+macro uint128 uint128.rotl(self, uint128 shift) => $$fshl(self, self, shift);
+macro uint128 uint128.rotr(self, uint128 shift) => $$fshr(self, self, shift);
+
+macro int128.popcount(self) => $$popcount(self);
+macro int128.ctz(self) => $$ctz(self);
+macro int128.clz(self) => $$clz(self);
+macro int128 int128.fshl(hi, int128 lo, int128 shift) => $$fshl(hi, lo, shift);
+macro int128 int128.fshr(hi, int128 lo, int128 shift) => $$fshr(hi, lo, shift);
+macro int128 int128.rotl(self, int128 shift) => $$fshl(self, self, shift);
+macro int128 int128.rotr(self, int128 shift) => $$fshr(self, self, shift);

lib/std/collections/anylist.c3

@@ -0,0 +1,122 @@
+// Copyright (c) 2024-2025 Christoffer Lerno. All rights reserved.
+// Use of self source code is governed by the MIT license
+// a copy of which can be found in the LICENSE_STDLIB file.
+module std::collections::anylist;
+import std::collections::interfacelist;
+
+alias AnyPredicate = InterfacePredicate {any};
+alias AnyTest = InterfaceTest {any};
+
+<*
+ The AnyList contains a heterogenous set of types. Anything placed in the
+ list will shallowly copied in order to be stored as an `any`. This means
+ that the list will copy and free its elements.
+
+ However, because we're getting `any` values back when we pop, those operations
+ need to take an allocator, as we can only copy then pop then return the copy.
+
+ If we're not doing pop, then things are easier, since we can just hand over
+ the existing any.
+*>
+typedef AnyList = inline InterfaceList {any};
+
+<*
+ Return the first element by value, assuming it is the given type.
+
+ @param $Type : "The type of the first element"
+ @return "The first element"
+ @return? TYPE_MISMATCH, NO_MORE_ELEMENT
+*>
+macro AnyList.first(&self, $Type)
+{
+	return *anycast(self.first_any(), $Type);
+}
+
+<*
+ Return the first element
+
+ @return "The first element"
+ @return? NO_MORE_ELEMENT
+*>
+fn any? AnyList.first_any(&self) @inline => InterfaceList {any}.first(self);
+
+<*
+ Return the last element by value, assuming it is the given type.
+
+ @param $Type : "The type of the last element"
+ @return "The last element"
+ @return? TYPE_MISMATCH, NO_MORE_ELEMENT
+*>
+macro AnyList.last(&self, $Type)
+{
+	return *anycast(self.last_any(), $Type);
+}
+
+<*
+ Return the last element
+
+ @return "The last element"
+ @return? NO_MORE_ELEMENT
+*>
+fn any? AnyList.last_any(&self) @inline => InterfaceList {any}.last(self);
+
+<*
+ Pop a value who's type is known. If the type is incorrect, this
+ will still pop the element.
+
+ @param $Type : "The type we assume the value has"
+ @return "The last value as the type given"
+ @return? TYPE_MISMATCH, NO_MORE_ELEMENT
+*>
+macro AnyList.pop(&self, $Type)
+{
+	if (!self.size) return NO_MORE_ELEMENT~;
+	defer self.free_element(self.entries[self.size]);
+	return *anycast(self.entries[--self.size], $Type);
+}
+
+<*
+ Pop a value who's type is known. If the type is incorrect, this
+ will still pop the element.
+
+ @param $Type : "The type we assume the value has"
+ @return "The first value as the type given"
+ @return? TYPE_MISMATCH, NO_MORE_ELEMENT
+*>
+macro AnyList.pop_first(&self, $Type)
+{
+	if (!self.size) return NO_MORE_ELEMENT~;
+	defer self.remove_at(0);
+	return *anycast(self.entries[0], $Type);
+}
+
+<*
+ Return an element in the list by value, assuming it is the given type.
+
+ @param index : "The index of the element to retrieve"
+ @param $Type : "The type of the element"
+ @return "The element at the index"
+ @return? TYPE_MISMATCH, NO_MORE_ELEMENT
+ @require index < self.size : "Index out of range"
+*>
+macro AnyList.get(&self, usz index, $Type)
+{
+	return *anycast(self.entries[index], $Type);
+}
+
+<*
+ Return an element in the list.
+
+ @param index : "The index of the element to retrieve"
+ @return "The element at the index"
+ @return? TYPE_MISMATCH, NO_MORE_ELEMENT
+ @require index < self.size : "Index out of range"
+*>
+fn any AnyList.get_any(&self, usz index) @inline @operator([]) => InterfaceList {any}.get(self, index);
+
+<*
+ Return the length of the list.
+
+ @return "The number of elements in the list"
+*>
+fn usz AnyList.len(&self) @operator(len) @inline => InterfaceList {any}.len(self);

lib/std/collections/bitset.c3

@@ -0,0 +1,257 @@
+// Copyright (c) 2023-2025 C3 team. All rights reserved.
+// Use of self source code is governed by the MIT license
+// a copy of which can be found in the LICENSE_STDLIB file.
+<*
+ @require SIZE > 0 : "The size of the bitset in bits must be at least 1"
+*>
+module std::collections::bitset <SIZE>;
+
+const BITS = uint.sizeof * 8;
+const SZ = (SIZE + BITS - 1) / BITS;
+
+struct BitSet
+{
+	uint[SZ] data;
+}
+
+<*
+ @return "The number of bits set"
+*>
+fn usz BitSet.cardinality(&self)
+{
+	usz n;
+	foreach (x : self.data)
+	{
+		n += x.popcount();
+	}
+	return n;
+}
+
+<*
+ Set a bit in the bitset.
+
+ @param i : "The index to set"
+
+ @require i < SIZE : "Index was out of range"
+*>
+fn void BitSet.set(&self, usz i)
+{
+	usz q = i / BITS;
+	usz r = i % BITS;
+	self.data[q] |= 1 << r;
+}
+
+<*
+ Perform xor over all bits, mutating itself
+
+ @param set : "The bit set to xor with"
+ @return "The resulting bit set"
+*>
+macro BitSet BitSet.xor_self(&self, BitSet set) @operator(^=)
+{
+	foreach (i, &x : self.data) *x ^= set.data[i];
+	return *self;
+}
+
+<*
+ Perform xor over all bits, returning a new bit set.
+
+ @param set : "The bit set to xor with"
+ @return "The resulting bit set"
+*>
+fn BitSet BitSet.xor(&self, BitSet set) @operator(^)
+{
+	BitSet new_set @noinit;
+	foreach (i, x : self.data) new_set.data[i] = x ^ set.data[i];
+	return new_set;
+}
+
+<*
+ Perform or over all bits, returning a new bit set.
+
+ @param set : "The bit set to xor with"
+ @return "The resulting bit set"
+*>
+fn BitSet BitSet.or(&self, BitSet set) @operator(|)
+{
+	BitSet new_set @noinit;
+	foreach (i, x : self.data) new_set.data[i] = x | set.data[i];
+	return new_set;
+}
+
+<*
+ Perform or over all bits, mutating itself
+
+ @param set : "The bit set to xor with"
+ @return "The resulting bit set"
+*>
+macro BitSet BitSet.or_self(&self, BitSet set) @operator(|=)
+{
+	foreach (i, &x : self.data) *x |= set.data[i];
+	return *self;
+}
+
+<*
+ Perform & over all bits, returning a new bit set.
+
+ @param set : "The bit set to xor with"
+ @return "The resulting bit set"
+*>
+fn BitSet BitSet.and(&self, BitSet set) @operator(&)
+{
+	BitSet new_set @noinit;
+	foreach (i, x : self.data) new_set.data[i] = x & set.data[i];
+	return new_set;
+}
+
+<*
+ Perform & over all bits, mutating itself.
+
+ @param set : "The bit set to xor with"
+ @return "The resulting bit set"
+*>
+macro BitSet BitSet.and_self(&self, BitSet set) @operator(&=)
+{
+	foreach (i, &x : self.data) *x &= set.data[i];
+	return *self;
+}
+
+<*
+ Unset (clear) a bit in the bitset.
+
+ @param i : "The index to set"
+
+ @require i < SIZE : "Index was out of range"
+*>
+fn void BitSet.unset(&self, usz i)
+{
+	usz q = i / BITS;
+	usz r = i % BITS;
+	self.data[q] &= ~(1 << r);
+}
+
+<*
+ Get a particular bit in the bitset
+
+ @param i : "The index of the bit"
+
+ @require i < SIZE : "Index was out of range"
+ @pure
+*>
+fn bool BitSet.get(&self, usz i) @operator([]) @inline
+{
+	usz q = i / BITS;
+	usz r = i % BITS;
+	return self.data[q] & (1 << r) != 0;
+}
+
+<*
+ Return the number of bits.
+
+ @pure
+*>
+fn usz BitSet.len(&self) @operator(len) @inline
+{
+	return SZ * BITS;
+}
+
+<*
+ Change a particular bit in the bitset
+
+ @param i : "The index of the bit"
+ @param value : "The value to set the bit to"
+
+ @require i < SIZE : "Index was out of range"
+*>
+fn void BitSet.set_bool(&self, usz i, bool value) @operator([]=) @inline
+{
+	if (value) return self.set(i);
+	self.unset(i);
+}
+
+<*
+ @require Type.kindof == UNSIGNED_INT
+*>
+module std::collections::growablebitset <Type>;
+import std::collections::list;
+
+const BITS = Type.sizeof * 8;
+
+alias GrowableBitSetList = List{Type};
+
+struct GrowableBitSet
+{
+	GrowableBitSetList data;
+}
+
+<*
+ @param initial_capacity
+ @param [&inout] allocator : "The allocator to use, defaults to the heap allocator"
+*>
+fn GrowableBitSet* GrowableBitSet.init(&self, Allocator allocator, usz initial_capacity = 1)
+{
+	self.data.init(allocator, initial_capacity);
+	return self;
+}
+
+fn GrowableBitSet* GrowableBitSet.tinit(&self, usz initial_capacity = 1)
+{
+	return self.init(tmem, initial_capacity) @inline;
+}
+
+fn void GrowableBitSet.free(&self)
+{
+	self.data.free();
+}
+
+fn usz GrowableBitSet.cardinality(&self)
+{
+	usz n;
+	foreach (x : self.data)
+	{
+		n += x.popcount();
+	}
+	return n;
+}
+
+fn void GrowableBitSet.set(&self, usz i)
+{
+	usz q = i / BITS;
+	usz r = i % BITS;
+	usz current_len = self.data.len();
+	while (q >= current_len)
+	{
+		self.data.push(0);
+		current_len++;
+	}
+	self.data.set(q, self.data[q] | (1 << r));
+}
+
+fn void GrowableBitSet.unset(&self, usz i)
+{
+	usz q = i / BITS;
+	usz r = i % BITS;
+	if (q >= self.data.len()) return;
+	self.data.set(q, self.data[q] &~ (1 << r));
+}
+
+fn bool GrowableBitSet.get(&self, usz i) @operator([]) @inline
+{
+	usz q = i / BITS;
+	usz r = i % BITS;
+	if (q >= self.data.len()) return false;
+	return self.data[q] & (1 << r) != 0;
+}
+
+fn usz GrowableBitSet.len(&self) @operator(len)
+{
+	usz n = self.data.len() * BITS;
+	if (n > 0) n -= (usz)self.data[^1].clz();
+	return n;
+}
+
+fn void GrowableBitSet.set_bool(&self, usz i, bool value) @operator([]=) @inline
+{
+	if (value) return self.set(i);
+	self.unset(i);
+}

lib/std/collections/elastic_array.c3

@@ -0,0 +1,461 @@
+// Copyright (c) 2021-2024 Christoffer Lerno. All rights reserved.
+// Use of self source code is governed by the MIT license
+// a copy of which can be found in the LICENSE_STDLIB file.
+<*
+ @require MAX_SIZE >= 1 : `The size must be at least 1 element big.`
+*>
+module std::collections::elastic_array <Type, MAX_SIZE>;
+import std::io, std::math, std::collections::list_common;
+
+alias ElementPredicate = fn bool(Type *type);
+alias ElementTest = fn bool(Type *type, any context);
+const ELEMENT_IS_EQUATABLE = types::is_equatable_type(Type);
+const ELEMENT_IS_POINTER = Type.kindof == POINTER;
+macro bool type_is_overaligned() => Type.alignof > mem::DEFAULT_MEM_ALIGNMENT;
+
+struct ElasticArray (Printable)
+{
+	usz size;
+	Type[MAX_SIZE] entries;
+}
+
+fn usz? ElasticArray.to_format(&self, Formatter* formatter) @dynamic
+{
+	switch (self.size)
+	{
+		case 0:
+			return formatter.print("[]")!;
+		case 1:
+			return formatter.printf("[%s]", self.entries[0])!;
+		default:
+			usz n = formatter.print("[")!;
+			foreach (i, element : self.entries[:self.size])
+			{
+				if (i != 0) formatter.print(", ")!;
+				n += formatter.printf("%s", element)!;
+			}
+			n += formatter.print("]")!;
+			return n;
+	}
+}
+
+fn String ElasticArray.to_tstring(&self)
+{
+	return string::tformat("%s", *self);
+}
+
+fn void? ElasticArray.push_try(&self, Type element) @inline
+{
+	if (self.size == MAX_SIZE) return mem::OUT_OF_MEMORY~;
+	self.entries[self.size++] = element;
+}
+
+<*
+ @require self.size < MAX_SIZE : `Tried to exceed the max size`
+*>
+fn void ElasticArray.push(&self, Type element) @inline
+{
+	self.entries[self.size++] = element;
+}
+
+fn Type? ElasticArray.pop(&self)
+{
+	if (!self.size) return NO_MORE_ELEMENT~;
+	return self.entries[--self.size];
+}
+
+fn void ElasticArray.clear(&self)
+{
+	self.size = 0;
+}
+
+<*
+ @require self.size > 0
+*>
+fn Type? ElasticArray.pop_first(&self)
+{
+	if (!self.size) return NO_MORE_ELEMENT~;
+	defer self.remove_at(0);
+	return self.entries[0];
+}
+
+<*
+ @require index < self.size
+*>
+fn void ElasticArray.remove_at(&self, usz index)
+{
+	if (!--self.size || index == self.size) return;
+	self.entries[index .. self.size - 1] = self.entries[index + 1 .. self.size];
+}
+
+<*
+ @require other_list.size + self.size <= MAX_SIZE
+*>
+fn void ElasticArray.add_all(&self, ElasticArray* other_list)
+{
+	if (!other_list.size) return;
+	foreach (&value : other_list)
+	{
+		self.entries[self.size++] = *value;
+	}
+}
+
+<*
+ Add as many elements as possible to the new array,
+ returning the number of elements that didn't fit.
+*>
+fn usz ElasticArray.add_all_to_limit(&self, ElasticArray* other_list)
+{
+	if (!other_list.size) return 0;
+	foreach (i, &value : other_list)
+	{
+		if (self.size == MAX_SIZE) return other_list.size - i;
+		self.entries[self.size++] = *value;
+	}
+	return 0;
+}
+
+<*
+ Add as many values from this array as possible, returning the
+ number of elements that didn't fit.
+
+ @param [in] array
+*>
+fn usz ElasticArray.add_array_to_limit(&self, Type[] array) @deprecated("Use push_all_to_limit")
+{
+	if (!array.len) return 0;
+	foreach (i, &value : array)
+	{
+		if (self.size == MAX_SIZE) return array.len - i;
+		self.entries[self.size++] = *value;
+	}
+	return 0;
+}
+
+<*
+ Add as many values from this array as possible, returning the
+ number of elements that didn't fit.
+
+ @param [in] array
+*>
+fn usz ElasticArray.push_all_to_limit(&self, Type[] array)
+{
+	if (!array.len) return 0;
+	foreach (i, &value : array)
+	{
+		if (self.size == MAX_SIZE) return array.len - i;
+		self.entries[self.size++] = *value;
+	}
+	return 0;
+}
+
+<*
+ Add the values of an array to this list.
+
+ @param [in] array
+ @require array.len + self.size <= MAX_SIZE : `Size would exceed max.`
+ @ensure self.size >= array.len
+*>
+fn void ElasticArray.add_array(&self, Type[] array) @deprecated("Use push_all")
+{
+	if (!array.len) return;
+	foreach (&value : array)
+	{
+		self.entries[self.size++] = *value;
+	}
+}
+
+<*
+ Add the values of an array to this list.
+
+ @param [in] array
+ @require array.len + self.size <= MAX_SIZE : `Size would exceed max.`
+ @ensure self.size >= array.len
+*>
+fn void ElasticArray.push_all(&self, Type[] array)
+{
+	if (!array.len) return;
+	foreach (&value : array)
+	{
+		self.entries[self.size++] = *value;
+	}
+}
+
+
+<*
+ IMPORTANT The returned array must be freed using free_aligned.
+*>
+fn Type[] ElasticArray.to_aligned_array(&self, Allocator allocator)
+{
+	return list_common::list_to_aligned_array(Type, self, allocator);
+}
+
+<*
+ @require !type_is_overaligned() : "This function is not available on overaligned types"
+*>
+macro Type[] ElasticArray.to_array(&self, Allocator allocator)
+{
+	return list_common::list_to_array(Type, self, allocator);
+}
+
+fn Type[] ElasticArray.to_tarray(&self)
+{
+	$if type_is_overaligned():
+	return self.to_aligned_array(tmem);
+	$else
+	return self.to_array(tmem);
+	$endif;
+}
+
+<*
+ Reverse the elements in a list.
+*>
+fn void ElasticArray.reverse(&self)
+{
+	list_common::list_reverse(self);
+}
+
+fn Type[] ElasticArray.array_view(&self)
+{
+	return self.entries[:self.size];
+}
+
+<*
+ @require self.size < MAX_SIZE : `List would exceed max size`
+*>
+fn void ElasticArray.push_front(&self, Type type) @inline
+{
+	self.insert_at(0, type);
+}
+
+<*
+ @require self.size < MAX_SIZE : `List would exceed max size`
+*>
+fn void? ElasticArray.push_front_try(&self, Type type) @inline
+{
+	return self.insert_at_try(0, type);
+}
+
+<*
+ @require index <= self.size
+*>
+fn void? ElasticArray.insert_at_try(&self, usz index, Type value)
+{
+	if (self.size == MAX_SIZE) return mem::OUT_OF_MEMORY~;
+	self.insert_at(index, value);
+}
+
+<*
+ @require self.size < MAX_SIZE : `List would exceed max size`
+ @require index <= self.size
+*>
+fn void ElasticArray.insert_at(&self, usz index, Type type)
+{
+	for (usz i = self.size; i > index; i--)
+	{
+		self.entries[i] = self.entries[i - 1];
+	}
+	self.size++;
+	self.entries[index] = type;
+}
+
+<*
+ @require index < self.size
+*>
+fn void ElasticArray.set_at(&self, usz index, Type type)
+{
+	self.entries[index] = type;
+}
+
+fn void? ElasticArray.remove_last(&self) @maydiscard
+{
+	if (!self.size) return NO_MORE_ELEMENT~;
+	self.size--;
+}
+
+fn void? ElasticArray.remove_first(&self) @maydiscard
+{
+	if (!self.size) return NO_MORE_ELEMENT~;
+	self.remove_at(0);
+}
+
+fn Type? ElasticArray.first(&self)
+{
+	if (!self.size) return NO_MORE_ELEMENT~;
+	return self.entries[0];
+}
+
+fn Type? ElasticArray.last(&self)
+{
+	if (!self.size) return NO_MORE_ELEMENT~;
+	return self.entries[self.size - 1];
+}
+
+fn bool ElasticArray.is_empty(&self) @inline
+{
+	return !self.size;
+}
+
+fn usz ElasticArray.byte_size(&self) @inline
+{
+	return Type.sizeof * self.size;
+}
+
+fn usz ElasticArray.len(&self) @operator(len) @inline
+{
+	return self.size;
+}
+
+fn Type ElasticArray.get(&self, usz index) @inline
+{
+	return self.entries[index];
+}
+
+fn void ElasticArray.swap(&self, usz i, usz j)
+{
+	@swap(self.entries[i], self.entries[j]);
+}
+
+<*
+ @param filter : "The function to determine if it should be removed or not"
+ @return "the number of deleted elements"
+*>
+fn usz ElasticArray.remove_if(&self, ElementPredicate filter)
+{
+	return list_common::list_remove_if(self, filter, false);
+}
+
+<*
+ @param selection : "The function to determine if it should be kept or not"
+ @return "the number of deleted elements"
+*>
+fn usz ElasticArray.retain_if(&self, ElementPredicate selection)
+{
+	return list_common::list_remove_if(self, selection, true);
+}
+
+fn usz ElasticArray.remove_using_test(&self, ElementTest filter, any context)
+{
+	return list_common::list_remove_using_test(self, filter, false, context);
+}
+
+fn usz ElasticArray.retain_using_test(&self, ElementTest filter, any context)
+{
+	return list_common::list_remove_using_test(self, filter, true, context);
+}
+
+
+macro Type ElasticArray.@item_at(&self, usz index) @operator([])
+{
+	return self.entries[index];
+}
+
+fn Type* ElasticArray.get_ref(&self, usz index) @operator(&[]) @inline
+{
+	return &self.entries[index];
+}
+
+fn void ElasticArray.set(&self, usz index, Type value) @operator([]=)
+{
+	self.entries[index] = value;
+}
+
+
+// Functions for equatable types
+fn usz? ElasticArray.index_of(&self, Type type) @if(ELEMENT_IS_EQUATABLE)
+{
+	foreach (i, v : self)
+	{
+		if (equals(v, type)) return i;
+	}
+	return NOT_FOUND~;
+}
+
+fn usz? ElasticArray.rindex_of(&self, Type type) @if(ELEMENT_IS_EQUATABLE)
+{
+	foreach_r (i, v : self)
+	{
+		if (equals(v, type)) return i;
+	}
+	return NOT_FOUND~;
+}
+
+fn bool ElasticArray.equals(&self, ElasticArray other_list) @if(ELEMENT_IS_EQUATABLE)
+{
+	if (self.size != other_list.size) return false;
+	foreach (i, v : self)
+	{
+		if (!equals(v, other_list.entries[i])) return false;
+	}
+	return true;
+}
+
+<*
+ Check for presence of a value in a list.
+
+ @param [&in] self : "the list to find elements in"
+ @param value : "The value to search for"
+ @return "True if the value is found, false otherwise"
+*>
+fn bool ElasticArray.contains(&self, Type value) @if(ELEMENT_IS_EQUATABLE)
+{
+	foreach (i, v : self)
+	{
+		if (equals(v, value)) return true;
+	}
+	return false;
+}
+
+<*
+ @param [&inout] self : "The list to remove elements from"
+ @param value : "The value to remove"
+ @return "true if the value was found"
+*>
+fn bool ElasticArray.remove_last_item(&self, Type value) @if(ELEMENT_IS_EQUATABLE)
+{
+	return @ok(self.remove_at(self.rindex_of(value)));
+}
+
+<*
+ @param [&inout] self : "The list to remove elements from"
+ @param value : "The value to remove"
+ @return "true if the value was found"
+*>
+fn bool ElasticArray.remove_first_item(&self, Type value) @if(ELEMENT_IS_EQUATABLE)
+{
+	return @ok(self.remove_at(self.index_of(value)));
+}
+
+<*
+ @param [&inout] self : "The list to remove elements from"
+ @param value : "The value to remove"
+ @return "the number of deleted elements."
+*>
+fn usz ElasticArray.remove_item(&self, Type value) @if(ELEMENT_IS_EQUATABLE)
+{
+	return list_common::list_remove_item(self, value);
+}
+
+
+
+fn void ElasticArray.remove_all_from(&self, ElasticArray* other_list) @if(ELEMENT_IS_EQUATABLE)
+{
+	if (!other_list.size) return;
+	foreach (v : other_list) self.remove_item(v);
+}
+
+<*
+ @param [&in] self
+ @return "The number non-null values in the list"
+*>
+fn usz ElasticArray.compact_count(&self) @if(ELEMENT_IS_POINTER)
+{
+	usz vals = 0;
+	foreach (v : self) if (v) vals++;
+	return vals;
+}
+
+fn usz ElasticArray.compact(&self) @if(ELEMENT_IS_POINTER)
+{
+	return list_common::list_compact(self);
+}

lib/std/collections/enummap.c3

@@ -0,0 +1,58 @@
+<*
+ @require Enum.kindof == TypeKind.ENUM : "Only enums may be used with an enummap"
+ @require Enum.values.len > 0 : "Only non-empty enums may be used with enummap"
+*>
+module std::collections::enummap <Enum, ValueType>;
+import std::io;
+
+struct EnumMap (Printable)
+{
+	ValueType[Enum.values.len] values;
+}
+
+fn void EnumMap.init(&self, ValueType init_value)
+{
+	foreach (&a : self.values)
+	{
+		*a = init_value;
+	}
+}
+
+fn usz? EnumMap.to_format(&self, Formatter* formatter) @dynamic
+{
+	usz n = formatter.print("{ ")!;
+	foreach (i, &value : self.values)
+	{
+		if (i != 0) formatter.print(", ")!;
+		n += formatter.printf("%s: %s", Enum.from_ordinal(i), *value)!;
+	}
+	n += formatter.print(" }")!;
+	return n;
+}
+
+<*
+ @return "The total size of this map, which is the same as the number of enum values"
+ @pure
+*>
+fn usz EnumMap.len(&self) @operator(len) @inline
+{
+	return self.values.len;
+}
+
+<*
+ @return "Retrieve a value given the underlying enum, if there is no entry, then the zero value for the value is returned."
+*>
+fn ValueType EnumMap.get(&self, Enum key) @operator([]) @inline
+{
+	return self.values[key.ordinal];
+}
+
+fn ValueType* EnumMap.get_ref(&self, Enum key) @operator(&[]) @inline
+{
+	return &self.values[key.ordinal];
+}
+
+fn void EnumMap.set(&self, Enum key, ValueType value) @operator([]=) @inline
+{
+	self.values[key.ordinal] = value;
+}

lib/std/collections/enumset.c3

@@ -0,0 +1,161 @@
+// Copyright (c) 2021-2024 Christoffer Lerno. All rights reserved.
+// Use of self source code is governed by the MIT license
+// a copy of which can be found in the LICENSE_STDLIB file.
+
+<*
+ @require Enum.kindof == TypeKind.ENUM : "Only enums may be used with an enumset"
+*>
+module std::collections::enumset <Enum>;
+import std::io;
+
+const ENUM_COUNT @private = Enum.values.len;
+alias EnumSetType @private = $typefrom(type_for_enum_elements(ENUM_COUNT));
+
+const IS_CHAR_ARRAY = ENUM_COUNT > 128;
+typedef EnumSet (Printable) = EnumSetType;
+
+fn void EnumSet.add(&self, Enum v)
+{
+	$if IS_CHAR_ARRAY:
+		(*self)[(usz)v.ordinal / 8] |= (char)(1u << ((usz)v.ordinal % 8));
+	$else
+		*self = (EnumSet)((EnumSetType)*self | 1u << (EnumSetType)v.ordinal);
+	$endif
+}
+
+fn void EnumSet.clear(&self)
+{
+	$if IS_CHAR_ARRAY:
+		*self = {};
+	$else
+		*self = 0;
+	$endif
+}
+
+fn bool EnumSet.remove(&self, Enum v)
+{
+	$if IS_CHAR_ARRAY:
+		if (!self.has(v) @inline) return false;
+		(*self)[(usz)v.ordinal / 8] &= (char)~(1u << ((usz)v.ordinal % 8));
+		return true;
+	$else
+		EnumSetType old = (EnumSetType)*self;
+		EnumSetType new = old & ~(1u << (EnumSetType)v.ordinal);
+		*self = (EnumSet)new;
+		return old != new;
+	$endif
+}
+
+fn bool EnumSet.has(&self, Enum v)
+{
+	$if IS_CHAR_ARRAY:
+		return (bool)(((*self)[(usz)v.ordinal / 8] << ((usz)v.ordinal % 8)) & 0x01);
+	$else
+		return ((EnumSetType)*self & (1u << (EnumSetType)v.ordinal)) != 0;
+	$endif
+}
+
+fn void EnumSet.add_all(&self, EnumSet s)
+{
+	$if IS_CHAR_ARRAY:
+		foreach (i, c : s) (*self)[i] |= c;
+	$else
+		*self = (EnumSet)((EnumSetType)*self | (EnumSetType)s);
+	$endif
+}
+
+fn void EnumSet.retain_all(&self, EnumSet s)
+{
+	$if IS_CHAR_ARRAY:
+		foreach (i, c : s) (*self)[i] &= c;
+	$else
+		*self = (EnumSet)((EnumSetType)*self & (EnumSetType)s);
+	$endif
+}
+
+fn void EnumSet.remove_all(&self, EnumSet s)
+{
+	$if IS_CHAR_ARRAY:
+		foreach (i, c : s) (*self)[i] &= ~c;
+	$else
+		*self = (EnumSet)((EnumSetType)*self & ~(EnumSetType)s);
+	$endif
+}
+
+fn EnumSet EnumSet.and_of(&self, EnumSet s)
+{
+	$if IS_CHAR_ARRAY:
+		EnumSet copy = *self;
+		copy.retain_all(s);
+		return copy;
+	$else
+		return (EnumSet)((EnumSetType)*self & (EnumSetType)s);
+	$endif
+}
+
+fn EnumSet EnumSet.or_of(&self, EnumSet s)
+{
+	$if IS_CHAR_ARRAY:
+		EnumSet copy = *self;
+		copy.add_all(s);
+		return copy;
+	$else
+		return (EnumSet)((EnumSetType)*self | (EnumSetType)s);
+	$endif
+}
+
+
+fn EnumSet EnumSet.diff_of(&self, EnumSet s)
+{
+	$if IS_CHAR_ARRAY:
+		EnumSet copy = *self;
+		copy.remove_all(s);
+		return copy;
+	$else
+		return (EnumSet)((EnumSetType)*self & ~(EnumSetType)s);
+	$endif
+}
+
+fn EnumSet EnumSet.xor_of(&self, EnumSet s)
+{
+	$if IS_CHAR_ARRAY:
+		EnumSet copy = *self;
+		foreach (i, c : s) copy[i] ^= c;
+		return copy;
+	$else
+		return (EnumSet)((EnumSetType)*self ^ (EnumSetType)s);
+	$endif
+}
+
+fn usz? EnumSet.to_format(&set, Formatter* formatter) @dynamic
+{
+	usz n = formatter.print("[")!;
+	bool found;
+	foreach (value : Enum.values)
+	{
+		if (!set.has(value)) continue;
+		if (found) n += formatter.print(", ")!;
+		found = true;
+		n += formatter.printf("%s", value)!;
+	}
+	n += formatter.print("]")!;
+	return n;
+}
+
+macro typeid type_for_enum_elements(usz $elements) @local
+{
+	$switch:
+		$case ($elements > 128):
+			return char[($elements + 7) / 8].typeid;
+		$case ($elements > 64):
+			return uint128.typeid;
+		$case ($elements > 32 || $$C_INT_SIZE > 32):
+			return ulong.typeid;
+		$case ($elements > 16 || $$C_INT_SIZE > 16):
+			return uint.typeid;
+		$case ($elements > 8 || $$C_INT_SIZE > 8):
+			return ushort.typeid;
+		$default:
+			return char.typeid;
+	$endswitch
+}

lib/std/collections/hashmap.c3

@@ -0,0 +1,610 @@
+// Copyright (c) 2023 Christoffer Lerno. All rights reserved.
+// Use of this source code is governed by the MIT license
+// a copy of which can be found in the LICENSE_STDLIB file.
+<*
+ @require $defined((Key){}.hash()) : `No .hash function found on the key`
+*>
+module std::collections::map <Key, Value>;
+import std::math;
+import std::io @norecurse;
+
+const uint DEFAULT_INITIAL_CAPACITY = 16;
+const uint MAXIMUM_CAPACITY = 1u << 31;
+const float DEFAULT_LOAD_FACTOR = 0.75;
+const VALUE_IS_EQUATABLE = Value.is_eq;
+const bool COPY_KEYS = types::implements_copy(Key);
+
+const Allocator MAP_HEAP_ALLOCATOR = (Allocator)&dummy;
+
+const HashMap ONHEAP = { .allocator = MAP_HEAP_ALLOCATOR };
+
+struct Entry
+{
+	uint hash;
+	Key key;
+	Value value;
+	Entry* next;
+}
+
+struct HashMap (Printable)
+{
+	Entry*[] table;
+	Allocator allocator;
+	<* Last inserted LinkedEntry *>
+	uint count;
+	<* Resize limit *>
+	uint threshold;
+	float load_factor;
+}
+
+
+<*
+ @param [&inout] allocator : "The allocator to use"
+ @require capacity > 0 : "The capacity must be 1 or higher"
+ @require load_factor > 0.0 : "The load factor must be higher than 0"
+ @require !self.is_initialized() : "Map was already initialized"
+ @require capacity < MAXIMUM_CAPACITY : "Capacity cannot exceed maximum"
+*>
+fn HashMap* HashMap.init(&self, Allocator allocator, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
+{
+	capacity = math::next_power_of_2(capacity);
+	self.allocator = allocator;
+	self.load_factor = load_factor;
+	self.threshold = (uint)(capacity * load_factor);
+	self.table = allocator::new_array(allocator, Entry*, capacity);
+	return self;
+}
+
+<*
+ @require capacity > 0 : "The capacity must be 1 or higher"
+ @require load_factor > 0.0 : "The load factor must be higher than 0"
+ @require !self.is_initialized() : "Map was already initialized"
+ @require capacity < MAXIMUM_CAPACITY : "Capacity cannot exceed maximum"
+*>
+fn HashMap* HashMap.tinit(&self, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
+{
+	return self.init(tmem, capacity, load_factor) @inline;
+}
+
+<*
+ @param [&inout] allocator : "The allocator to use"
+ @require $vacount % 2 == 0 : "There must be an even number of arguments provided for keys and values"
+ @require capacity > 0 : "The capacity must be 1 or higher"
+ @require load_factor > 0.0 : "The load factor must be higher than 0"
+ @require !self.is_initialized() : "Map was already initialized"
+ @require capacity < MAXIMUM_CAPACITY : "Capacity cannot exceed maximum"
+*>
+macro HashMap* HashMap.init_with_key_values(&self, Allocator allocator, ..., uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
+{
+	self.init(allocator, capacity, load_factor);
+	$for var $i = 0; $i < $vacount; $i += 2:
+		self.set($vaarg[$i], $vaarg[$i + 1]);
+	$endfor
+	return self;
+}
+
+<*
+ @require $vacount % 2 == 0 : "There must be an even number of arguments provided for keys and values"
+ @require capacity > 0 : "The capacity must be 1 or higher"
+ @require load_factor > 0.0 : "The load factor must be higher than 0"
+ @require !self.is_initialized() : "Map was already initialized"
+ @require capacity < MAXIMUM_CAPACITY : "Capacity cannot exceed maximum"
+*>
+macro HashMap* HashMap.tinit_with_key_values(&self, ..., uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
+{
+	return self.init_with_key_values(tmem, $vasplat, capacity: capacity, load_factor: load_factor);
+}
+
+<*
+ @param [in] keys : "The keys for the HashMap entries"
+ @param [in] values : "The values for the HashMap entries"
+ @param [&inout] allocator : "The allocator to use"
+ @require keys.len == values.len : "Both keys and values arrays must be the same length"
+ @require capacity > 0 : "The capacity must be 1 or higher"
+ @require load_factor > 0.0 : "The load factor must be higher than 0"
+ @require !self.is_initialized() : "Map was already initialized"
+ @require capacity < MAXIMUM_CAPACITY : "Capacity cannot exceed maximum"
+*>
+fn HashMap* HashMap.init_from_keys_and_values(&self, Allocator allocator, Key[] keys, Value[] values, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
+{
+	assert(keys.len == values.len);
+	self.init(allocator, capacity, load_factor);
+	for (usz i = 0; i < keys.len; i++)
+	{
+		self.set(keys[i], values[i]);
+	}
+	return self;
+}
+
+
+<*
+ @param [in] keys : "The keys for the HashMap entries"
+ @param [in] values : "The values for the HashMap entries"
+ @require keys.len == values.len : "Both keys and values arrays must be the same length"
+ @require capacity > 0 : "The capacity must be 1 or higher"
+ @require load_factor > 0.0 : "The load factor must be higher than 0"
+ @require !self.is_initialized() : "Map was already initialized"
+ @require capacity < MAXIMUM_CAPACITY : "Capacity cannot exceed maximum"
+*>
+fn HashMap* HashMap.tinit_from_keys_and_values(&self, Key[] keys, Value[] values, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
+{
+	return self.init_from_keys_and_values(tmem, keys, values, capacity, load_factor);
+}
+
+<*
+ Has this hash map been initialized yet?
+
+ @param [&in] map : "The hash map we are testing"
+ @return "Returns true if it has been initialized, false otherwise"
+*>
+fn bool HashMap.is_initialized(&map)
+{
+	return map.allocator && map.allocator.ptr != &dummy;
+}
+
+<*
+ @param [&inout] allocator : "The allocator to use"
+ @param [&in] other_map : "The map to copy from."
+ @require !self.is_initialized() : "Map was already initialized"
+*>
+fn HashMap* HashMap.init_from_map(&self, Allocator allocator, HashMap* other_map)
+{
+	self.init(allocator, other_map.table.len, other_map.load_factor);
+	hashmap_put_all_for_create(self, other_map);
+	return self;
+}
+
+<*
+ @param [&in] other_map : "The map to copy from."
+ @require !map.is_initialized() : "Map was already initialized"
+*>
+fn HashMap* HashMap.tinit_from_map(&map, HashMap* other_map)
+{
+	return map.init_from_map(tmem, other_map) @inline;
+}
+
+fn bool HashMap.is_empty(&map) @inline
+{
+	return !map.count;
+}
+
+fn usz HashMap.len(&map) @inline
+{
+	return map.count;
+}
+
+fn Value*? HashMap.get_ref(&map, Key key)
+{
+	if (!map.count) return NOT_FOUND~;
+	uint hash = rehash(key.hash());
+	for (Entry *e = map.table[index_for(hash, map.table.len)]; e != null; e = e.next)
+	{
+		if (e.hash == hash && equals(key, e.key)) return &e.value;
+	}
+	return NOT_FOUND~;
+}
+
+fn Value* HashMap.get_or_create_ref(&map, Key key) @operator(&[])
+{
+	uint hash = rehash(key.hash());
+	if (map.count)
+	{
+		for (Entry *e = map.table[index_for(hash, map.table.len)]; e != null; e = e.next)
+		{
+			if (e.hash == hash && equals(key, e.key)) return &e.value;
+		}
+	}
+	map.set(key, {});
+	for (Entry *e = map.table[index_for(hash, map.table.len)]; e != null; e = e.next)
+    {
+    	if (e.hash == hash && equals(key, e.key)) return &e.value;
+    }
+	unreachable();
+}
+
+fn Entry*? HashMap.get_entry(&map, Key key)
+{
+	if (!map.count) return NOT_FOUND~;
+	uint hash = rehash(key.hash());
+	for (Entry *e = map.table[index_for(hash, map.table.len)]; e != null; e = e.next)
+	{
+		if (e.hash == hash && equals(key, e.key)) return e;
+	}
+	return NOT_FOUND~;
+}
+
+<*
+ Get the value or set it to the value
+
+ @require $defined(Value val = #expr)
+*>
+macro Value HashMap.@get_or_set(&map, Key key, Value #expr)
+{
+	if (!map.count)
+	{
+		Value val = #expr;
+		map.set(key, val);
+		return val;
+	}
+	uint hash = rehash(key.hash());
+	uint index = index_for(hash, map.table.len);
+	for (Entry *e = map.table[index]; e != null; e = e.next)
+	{
+		if (e.hash == hash && equals(key, e.key)) return e.value;
+	}
+	Value val = #expr;
+	hashmap_add_entry(map, hash, key, val, index);
+	return val;
+}
+
+fn Value? HashMap.get(&map, Key key) @operator([])
+{
+	return *map.get_ref(key) @inline;
+}
+
+fn bool HashMap.has_key(&map, Key key)
+{
+	return @ok(map.get_ref(key));
+}
+
+fn bool HashMap.set(&map, Key key, Value value) @operator([]=)
+{
+	// If the map isn't initialized, use the defaults to initialize it.
+	switch (map.allocator.ptr)
+	{
+		case &dummy:
+			map.init(mem);
+		case null:
+			map.tinit();
+		default:
+			break;
+	}
+	uint hash = rehash(key.hash());
+	uint index = index_for(hash, map.table.len);
+	for (Entry *e = map.table[index]; e != null; e = e.next)
+	{
+		if (e.hash == hash && equals(key, e.key))
+		{
+			e.value = value;
+			return true;
+		}
+	}
+	hashmap_add_entry(map, hash, key, value, index);
+	return false;
+}
+
+fn void? HashMap.remove(&map, Key key) @maydiscard
+{
+	if (!hashmap_remove_entry_for_key(map, key)) return NOT_FOUND~;
+}
+
+fn void HashMap.clear(&map)
+{
+	if (!map.count) return;
+	foreach (Entry** &entry_ref : map.table)
+	{
+		Entry* entry = *entry_ref;
+		if (!entry) continue;
+		Entry *next = entry.next;
+		while (next)
+		{
+			Entry *to_delete = next;
+			next = next.next;
+			hashmap_free_entry(map, to_delete);
+		}
+		hashmap_free_entry(map, entry);
+		*entry_ref = null;
+	}
+	map.count = 0;
+}
+
+fn void HashMap.free(&map)
+{
+	if (!map.is_initialized()) return;
+	map.clear();
+	hashmap_free_internal(map, map.table.ptr);
+	map.table = {};
+}
+
+fn Key[] HashMap.tkeys(&self)
+{
+	return self.keys(tmem) @inline;
+}
+
+fn Key[] HashMap.keys(&self, Allocator allocator)
+{
+	if (!self.count) return {};
+
+	Key[] list = allocator::alloc_array(allocator, Key, self.count);
+	usz index = 0;
+	foreach (Entry* entry : self.table)
+	{
+		while (entry)
+		{
+			$if COPY_KEYS:
+				list[index++] = entry.key.copy(allocator);
+			$else
+				list[index++] = entry.key;
+			$endif
+			entry = entry.next;
+		}
+	}
+	return list;
+}
+
+macro HashMap.@each(map; @body(key, value))
+{
+	map.@each_entry(; Entry* entry)
+	{
+		@body(entry.key, entry.value);
+	};
+}
+
+macro HashMap.@each_entry(map; @body(entry))
+{
+	if (!map.count) return;
+	foreach (Entry* entry : map.table)
+	{
+		while (entry)
+		{
+			@body(entry);
+			entry = entry.next;
+		}
+	}
+}
+
+fn Value[] HashMap.tvalues(&self) => self.values(tmem) @inline;
+
+fn Value[] HashMap.values(&self, Allocator allocator)
+{
+	if (!self.count) return {};
+	Value[] list = allocator::alloc_array(allocator, Value, self.count);
+	usz index = 0;
+	foreach (Entry* entry : self.table)
+	{
+		while (entry)
+		{
+			list[index++] = entry.value;
+			entry = entry.next;
+		}
+	}
+	return list;
+}
+
+fn bool HashMap.has_value(&map, Value v) @if(VALUE_IS_EQUATABLE)
+{
+	if (!map.count) return false;
+	foreach (Entry* entry : map.table)
+	{
+		while (entry)
+		{
+			if (equals(v, entry.value)) return true;
+			entry = entry.next;
+		}
+	}
+	return false;
+}
+
+fn HashMapIterator HashMap.iter(&self)
+{
+	return { .map = self, .index = -1 };
+}
+
+fn HashMapValueIterator HashMap.value_iter(&self)
+{
+	return { .map = self, .index = -1 };
+}
+
+fn HashMapKeyIterator HashMap.key_iter(&self)
+{
+	return { .map = self, .index = -1 };
+}
+
+// --- private methods
+
+fn void hashmap_add_entry(HashMap* map, uint hash, Key key, Value value, uint bucket_index) @private
+{
+	$if COPY_KEYS:
+	key = key.copy(map.allocator);
+	$endif
+	Entry* entry = allocator::new(map.allocator, Entry, { .hash = hash, .key = key, .value = value, .next = map.table[bucket_index] });
+	map.table[bucket_index] = entry;
+	if (map.count++ >= map.threshold)
+	{
+		hashmap_resize(map, map.table.len * 2);
+	}
+}
+
+fn void hashmap_resize(HashMap* map, uint new_capacity) @private
+{
+	Entry*[] old_table = map.table;
+	uint old_capacity = old_table.len;
+	if (old_capacity == MAXIMUM_CAPACITY)
+	{
+		map.threshold = uint.max;
+		return;
+	}
+	Entry*[] new_table = allocator::new_array(map.allocator, Entry*, new_capacity);
+	hashmap_transfer(map, new_table);
+	map.table = new_table;
+	hashmap_free_internal(map, old_table.ptr);
+	map.threshold = (uint)(new_capacity * map.load_factor);
+}
+
+fn usz? HashMap.to_format(&self, Formatter* f) @dynamic
+{
+	usz len;
+	len += f.print("{ ")!;
+	self.@each_entry(; Entry* entry)
+	{
+		if (len > 2) len += f.print(", ")!;
+		len += f.printf("%s: %s", entry.key, entry.value)!;
+	};
+	return len + f.print(" }");
+}
+
+fn void hashmap_transfer(HashMap* map, Entry*[] new_table) @private
+{
+	Entry*[] src = map.table;
+	uint new_capacity = new_table.len;
+	foreach (uint j, Entry *e : src)
+	{
+		if (!e) continue;
+		do
+		{
+			Entry* next = e.next;
+			uint i = index_for(e.hash, new_capacity);
+			e.next = new_table[i];
+			new_table[i] = e;
+			e = next;
+		}
+		while (e);
+	}
+}
+
+fn void hashmap_put_all_for_create(HashMap* map, HashMap* other_map) @private
+{
+	if (!other_map.count) return;
+	foreach (Entry *e : other_map.table)
+	{
+		while (e)
+		{
+			hashmap_put_for_create(map, e.key, e.value);
+			e = e.next;
+		}
+	}
+}
+
+fn void hashmap_put_for_create(HashMap* map, Key key, Value value) @private
+{
+	uint hash = rehash(key.hash());
+	uint i = index_for(hash, map.table.len);
+	for (Entry *e = map.table[i]; e != null; e = e.next)
+	{
+		if (e.hash == hash && equals(key, e.key))
+		{
+			e.value = value;
+			return;
+		}
+	}
+	hashmap_create_entry(map, hash, key, value, i);
+}
+
+fn void hashmap_free_internal(HashMap* map, void* ptr) @inline @private
+{
+	allocator::free(map.allocator, ptr);
+}
+
+fn bool hashmap_remove_entry_for_key(HashMap* map, Key key) @private
+{
+	if (!map.count) return false;
+	uint hash = rehash(key.hash());
+	uint i = index_for(hash, map.table.len);
+	Entry* prev = map.table[i];
+	Entry* e = prev;
+	while (e)
+	{
+		Entry *next = e.next;
+		if (e.hash == hash && equals(key, e.key))
+		{
+			map.count--;
+			if (prev == e)
+			{
+				map.table[i] = next;
+			}
+			else
+			{
+				prev.next = next;
+			}
+			hashmap_free_entry(map, e);
+			return true;
+		}
+		prev = e;
+		e = next;
+	}
+	return false;
+}
+
+fn void hashmap_create_entry(HashMap* map, uint hash, Key key, Value value, int bucket_index) @private
+{
+	Entry *e = map.table[bucket_index];
+	$if COPY_KEYS:
+	key = key.copy(map.allocator);
+	$endif
+	Entry* entry = allocator::new(map.allocator, Entry, { .hash = hash, .key = key, .value = value, .next = map.table[bucket_index] });
+	map.table[bucket_index] = entry;
+	map.count++;
+}
+
+fn void hashmap_free_entry(HashMap* map, Entry *entry) @local
+{
+	$if COPY_KEYS:
+	allocator::free(map.allocator, entry.key);
+	$endif
+	hashmap_free_internal(map, entry);
+}
+
+
+struct HashMapIterator
+{
+	HashMap* map;
+	int top_index;
+	int index;
+	Entry* current_entry;
+}
+
+typedef HashMapValueIterator = HashMapIterator;
+typedef HashMapKeyIterator = HashMapIterator;
+
+
+<*
+ @require idx < self.map.count
+*>
+fn Entry HashMapIterator.get(&self, usz idx) @operator([])
+{
+	if (idx < self.index)
+	{
+		self.top_index = 0;
+		self.current_entry = null;
+		self.index = -1;
+	}
+	while (self.index != idx)
+	{
+		if (self.current_entry)
+		{
+			self.current_entry = self.current_entry.next;
+			if (self.current_entry) self.index++;
+			continue;
+		}
+		self.current_entry = self.map.table[self.top_index++];
+		if (self.current_entry) self.index++;
+	}
+	return *self.current_entry;
+}
+
+fn Value HashMapValueIterator.get(&self, usz idx) @operator([])
+{
+	return ((HashMapIterator*)self).get(idx).value;
+}
+
+fn Key HashMapKeyIterator.get(&self, usz idx) @operator([])
+{
+	return ((HashMapIterator*)self).get(idx).key;
+}
+
+fn usz HashMapValueIterator.len(self) @operator(len) => self.map.count;
+fn usz HashMapKeyIterator.len(self) @operator(len) => self.map.count;
+fn usz HashMapIterator.len(self) @operator(len) => self.map.count;
+
+fn uint rehash(uint hash) @inline @private
+{
+	hash ^= (hash >> 20) ^ (hash >> 12);
+	return hash ^ ((hash >> 7) ^ (hash >> 4));
+}
+
+macro uint index_for(uint hash, uint capacity) @private
+{
+	return hash & (capacity - 1);
+}
+
+int dummy @local;

lib/std/collections/hashset.c3

@@ -0,0 +1,654 @@
+<*
+ @require $defined((Value){}.hash()) : `No .hash function found on the value`
+*>
+module std::collections::set <Value>;
+import std::math;
+import std::io @norecurse;
+
+const uint DEFAULT_INITIAL_CAPACITY = 16;
+const uint MAXIMUM_CAPACITY = 1u << 31;
+const float DEFAULT_LOAD_FACTOR = 0.75;
+
+const Allocator SET_HEAP_ALLOCATOR = (Allocator)&dummy;
+
+<* Copy the ONHEAP allocator to initialize to a set that is heap allocated *>
+const HashSet ONHEAP = { .allocator = SET_HEAP_ALLOCATOR };
+
+struct Entry
+{
+	uint hash;
+	Value value;
+	Entry* next;
+}
+
+struct HashSet (Printable)
+{
+	Entry*[] table;
+	Allocator allocator;
+	<* Number of elements *>
+	usz count;
+	<* Resize limit *>
+	usz threshold;
+	float load_factor;
+}
+
+fn usz HashSet.len(&self) @operator(len) => self.count;
+
+<*
+ @param [&inout] allocator : "The allocator to use"
+ @require capacity > 0 : "The capacity must be 1 or higher"
+ @require load_factor > 0.0 : "The load factor must be higher than 0"
+ @require !self.is_initialized() : "Set was already initialized"
+ @require capacity < MAXIMUM_CAPACITY : "Capacity cannot exceed maximum"
+*>
+fn HashSet* HashSet.init(&self, Allocator allocator, usz capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
+{
+	capacity = math::next_power_of_2(capacity);
+	self.allocator = allocator;
+	self.threshold = (usz) (capacity * load_factor);
+	self.load_factor = load_factor;
+	self.table = allocator::new_array(allocator, Entry*, capacity);
+	return self;
+}
+
+<*
+ @require capacity > 0 : "The capacity must be 1 or higher"
+ @require load_factor > 0.0 : "The load factor must be higher than 0"
+ @require !self.is_initialized() : "Set was already initialized"
+ @require capacity < MAXIMUM_CAPACITY : "Capacity cannot exceed maximum"
+*>
+fn HashSet* HashSet.tinit(&self, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
+{
+	return self.init(tmem, capacity, load_factor) @inline;
+}
+
+<*
+ @param [&inout] allocator : "The allocator to use"
+ @require capacity > 0 : "The capacity must be 1 or higher"
+ @require load_factor > 0.0 : "The load factor must be higher than 0"
+ @require !self.is_initialized() : "Set was already initialized"
+ @require capacity < MAXIMUM_CAPACITY : "Capacity cannot exceed maximum"
+*>
+macro HashSet* HashSet.init_with_values(&self, Allocator allocator, ..., uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
+{
+	self.init(allocator, capacity, load_factor);
+	$for var $i = 0; $i < $vacount; $i++:
+		self.add($vaarg[$i]);
+	$endfor
+	return self;
+}
+
+<*
+ @require capacity > 0 : "The capacity must be 1 or higher"
+ @require load_factor > 0.0 : "The load factor must be higher than 0"
+ @require !self.is_initialized() : "Set was already initialized"
+ @require capacity < MAXIMUM_CAPACITY : "Capacity cannot exceed maximum"
+*>
+macro HashSet* HashSet.tinit_with_values(&self, ..., uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
+{
+	return self.init_with_values(tmem, $vasplat, capacity: capacity, load_factor: load_factor);
+}
+
+<*
+ @param [in] values : "The values for the HashSet"
+ @param [&inout] allocator : "The allocator to use"
+ @require capacity > 0 : "The capacity must be 1 or higher"
+ @require load_factor > 0.0 : "The load factor must be higher than 0"
+ @require !self.is_initialized() : "Set was already initialized"
+ @require capacity < MAXIMUM_CAPACITY : "Capacity cannot exceed maximum"
+*>
+fn HashSet* HashSet.init_from_values(&self, Allocator allocator, Value[] values, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
+{
+	self.init(allocator, capacity, load_factor);
+	foreach (v : values) self.add(v);
+	return self;
+}
+
+<*
+ @param [in] values : "The values for the HashSet entries"
+ @require capacity > 0 : "The capacity must be 1 or higher"
+ @require load_factor > 0.0 : "The load factor must be higher than 0"
+ @require !self.is_initialized() : "Set was already initialized"
+ @require capacity < MAXIMUM_CAPACITY : "Capacity cannot exceed maximum"
+*>
+fn HashSet* HashSet.tinit_from_values(&self, Value[] values, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
+{
+	return self.init_from_values(tmem, values, capacity, load_factor);
+}
+
+<*
+ Has this hash set been initialized yet?
+
+ @param [&in] set : "The hash set we are testing"
+ @return "Returns true if it has been initialized, false otherwise"
+*>
+fn bool HashSet.is_initialized(&set)
+{
+	return set.allocator && set.allocator.ptr != &dummy;
+}
+
+<*
+ @param [&inout] allocator : "The allocator to use"
+ @param [&in] other_set : "The set to copy from."
+ @require !self.is_initialized() : "Set was already initialized"
+*>
+fn HashSet* HashSet.init_from_set(&self, Allocator allocator, HashSet* other_set)
+{
+	self.init(allocator, other_set.table.len, other_set.load_factor);
+	hashset_put_all_for_create(self, other_set);
+	return self;
+}
+
+<*
+ @param [&in] other_set : "The set to copy from."
+ @require !set.is_initialized() : "Set was already initialized"
+*>
+fn HashSet* HashSet.tinit_from_set(&set, HashSet* other_set)
+{
+	return set.init_from_set(tmem, other_set) @inline;
+}
+
+<*
+ Check if the set is empty
+
+ @return "true if it is empty"
+ @pure
+*>
+fn bool HashSet.is_empty(&set) @inline
+{
+	return !set.count;
+}
+
+<*
+ Add all elements in the slice to the set.
+
+ @param [in] list
+ @return "The number of new elements added"
+ @ensure total <= list.len
+*>
+fn usz HashSet.add_all(&set, Value[] list)
+{
+	usz total;
+	foreach (v : list)
+	{
+		if (set.add(v)) total++;
+	}
+	return total;
+}
+
+<*
+ @param [&in] other
+ @return "The number of new elements added"
+ @ensure return <= other.count
+*>
+fn usz HashSet.add_all_from(&set, HashSet* other)
+{
+	usz total;
+	other.@each(;Value value)
+	{
+		if (set.add(value)) total++;
+	};
+	return total;
+}
+
+<*
+ @param value : "The value to add"
+ @return "true if the value didn't exist in the set"
+*>
+fn bool HashSet.add(&set, Value value)
+{
+	// If the set isn't initialized, use the defaults to initialize it.
+	switch (set.allocator.ptr)
+	{
+		case &dummy:
+			set.init(mem);
+		case null:
+			set.tinit();
+		default:
+			break;
+	}
+	uint hash = rehash(value.hash());
+	uint index = index_for(hash, set.table.len);
+	for (Entry *e = set.table[index]; e != null; e = e.next)
+	{
+		if (e.hash == hash && equals(value, e.value)) return false;
+	}
+	hashset_add_entry(set, hash, value, index);
+	return true;
+}
+
+<*
+ Iterate over all the values in the set
+*>
+macro HashSet.@each(set; @body(value))
+{
+	if (!set.count) return;
+	foreach (Entry* entry : set.table)
+	{
+		while (entry)
+		{
+			@body(entry.value);
+			entry = entry.next;
+		}
+	}
+}
+
+<*
+ Check if the set contains the given value.
+
+ @param value : "The value to check"
+ @return "true if it exists in the set"
+*>
+fn bool HashSet.contains(&set, Value value)
+{
+	if (!set.count) return false;
+	uint hash = rehash(value.hash());
+	for (Entry *e = set.table[index_for(hash, set.table.len)]; e != null; e = e.next)
+	{
+		if (e.hash == hash && equals(value, e.value)) return true;
+	}
+	return false;
+}
+
+<*
+ Remove a single value from the set.
+
+ @param value : "The value to remove"
+ @return? NOT_FOUND : "If the entry is not found"
+*>
+fn void? HashSet.remove(&set, Value value) @maydiscard
+{
+	if (!hashset_remove_entry_for_value(set, value)) return NOT_FOUND~;
+}
+
+fn usz HashSet.remove_all(&set, Value[] values)
+{
+	usz total;
+	foreach (v : values)
+	{
+		if (hashset_remove_entry_for_value(set, v)) total++;
+	}
+	return total;
+}
+
+<*
+ @param [&in] other : "Other set"
+*>
+fn usz HashSet.remove_all_from(&set, HashSet* other)
+{
+	usz total;
+	other.@each(;Value val)
+    {
+		if (hashset_remove_entry_for_value(set, val)) total++;
+    };
+    return total;
+}
+
+<*
+ Free all memory allocated by the hash set.
+*>
+fn void HashSet.free(&set)
+{
+	if (!set.is_initialized()) return;
+	set.clear();
+	hashset_free_internal(set, set.table.ptr);
+	*set = {};
+}
+
+<*
+ Clear all elements from the set while keeping the underlying storage
+
+ @ensure set.count == 0
+*>
+fn void HashSet.clear(&set)
+{
+	if (!set.count) return;
+
+	foreach (Entry** &entry_ref : set.table)
+	{
+		Entry* entry = *entry_ref;
+		if (!entry) continue;
+
+		Entry *next = entry.next;
+		while (next)
+		{
+			Entry *to_delete = next;
+			next = next.next;
+			hashset_free_entry(set, to_delete);
+		}
+
+		hashset_free_entry(set, entry);
+		*entry_ref = null;
+	}
+	set.count = 0;
+}
+
+fn void HashSet.reserve(&set, usz capacity)
+{
+	if (capacity > set.threshold)
+	{
+		hashset_resize(set, math::next_power_of_2(capacity));
+	}
+}
+
+fn Value[] HashSet.tvalues(&self) => self.values(tmem) @inline;
+
+fn Value[] HashSet.values(&self, Allocator allocator)
+{
+	if (!self.count) return {};
+	Value[] list = allocator::alloc_array(allocator, Value, self.count);
+	usz index = 0;
+	foreach (Entry* entry : self.table)
+	{
+		while (entry)
+		{
+			list[index++] = entry.value;
+			entry = entry.next;
+		}
+	}
+	return list;
+}
+
+// --- Set Operations ---
+
+<*
+ Returns the union of two sets (A | B)
+
+ @param [&in] other : "The other set to union with"
+ @param [&inout] allocator : "Allocator for the new set"
+ @return "A new set containing the union of both sets"
+*>
+fn HashSet HashSet.set_union(&self, Allocator allocator, HashSet* other)
+{
+	usz new_capacity = math::next_power_of_2(self.count + other.count);
+	HashSet result;
+	result.init(allocator, new_capacity, self.load_factor);
+	result.add_all_from(self);
+	result.add_all_from(other);
+	return result;
+}
+
+fn HashSet HashSet.tset_union(&self, HashSet* other) => self.set_union(tmem, other);
+
+<*
+ Returns the intersection of the two sets (A & B)
+
+ @param [&in] other : "The other set to intersect with"
+ @param [&inout] allocator : "Allocator for the new set"
+ @return "A new set containing the intersection of both sets"
+*>
+fn HashSet HashSet.intersection(&self, Allocator allocator, HashSet* other)
+{
+	HashSet result;
+	result.init(allocator, math::min(self.table.len, other.table.len), self.load_factor);
+
+	// Iterate through the smaller set for efficiency
+	HashSet* smaller = self.count <= other.count ? self : other;
+	HashSet* larger = self.count > other.count ? self : other;
+
+	smaller.@each(;Value value)
+	{
+		if (larger.contains(value)) result.add(value);
+	};
+
+	return result;
+}
+
+fn HashSet HashSet.tintersection(&self, HashSet* other) => self.intersection(tmem, other);
+
+<*
+ Return this set - other, so (A & ~B)
+
+ @param [&in] other : "The other set to compare with"
+ @param [&inout] allocator : "Allocator for the new set"
+ @return "A new set containing elements in this set but not in the other"
+*>
+fn HashSet HashSet.difference(&self, Allocator allocator, HashSet* other)
+{
+	HashSet result;
+	result.init(allocator, self.table.len, self.load_factor);
+	self.@each(;Value value)
+	{
+		if (!other.contains(value))
+		{
+			result.add(value);
+		}
+	};
+	return result;
+}
+
+fn HashSet HashSet.tdifference(&self, HashSet* other) => self.difference(tmem, other) @inline;
+
+<*
+ Return (A ^ B)
+
+ @param [&in] other : "The other set to compare with"
+ @param [&inout] allocator : "Allocator for the new set"
+ @return "A new set containing elements in this set or the other, but not both"
+*>
+fn HashSet HashSet.symmetric_difference(&self, Allocator allocator, HashSet* other)
+{
+	HashSet result;
+	result.init(allocator, self.table.len, self.load_factor);
+	result.add_all_from(self);
+	other.@each(;Value value)
+	{
+		if (!result.add(value))
+		{
+			result.remove(value);
+		}
+	};
+	return result;
+}
+
+fn HashSet HashSet.tsymmetric_difference(&self, HashSet* other) => self.symmetric_difference(tmem, other) @inline;
+
+<*
+ Check if this hash set is a subset of another set.
+
+ @param [&in] other : "The other set to check against"
+ @return "True if all elements of this set are in the other set"
+*>
+fn bool HashSet.is_subset(&self, HashSet* other)
+{
+	if (self.count == 0) return true;
+	if (self.count > other.count) return false;
+
+	self.@each(;Value value)
+	{
+		if (!other.contains(value)) return false;
+	};
+	return true;
+}
+
+
+// --- private methods
+
+fn void hashset_add_entry(HashSet* set, uint hash, Value value, uint bucket_index) @private
+{
+	Entry* entry = allocator::new(set.allocator, Entry, { .hash = hash, .value = value, .next = set.table[bucket_index] });
+	set.table[bucket_index] = entry;
+	if (set.count++ >= set.threshold)
+	{
+		hashset_resize(set, set.table.len * 2);
+	}
+}
+
+fn void hashset_resize(HashSet* self, usz new_capacity) @private
+{
+	Entry*[] old_table = self.table;
+	usz old_capacity = old_table.len;
+	if (old_capacity == MAXIMUM_CAPACITY)
+	{
+		self.threshold = uint.max;
+		return;
+	}
+	Entry*[] new_table = allocator::new_array(self.allocator, Entry*, new_capacity);
+	hashset_transfer(self, new_table);
+	self.table = new_table;
+	hashset_free_internal(self, old_table.ptr);
+	self.threshold = (uint)(new_capacity * self.load_factor);
+}
+
+fn usz? HashSet.to_format(&self, Formatter* f) @dynamic
+{
+	usz len;
+	len += f.print("{ ")!;
+	self.@each(; Value value)
+	{
+		if (len > 2) len += f.print(", ")!;
+		len += f.printf("%s", value)!;
+	};
+	return len + f.print(" }");
+}
+
+fn void hashset_transfer(HashSet* self, Entry*[] new_table) @private
+{
+	Entry*[] src = self.table;
+	uint new_capacity = new_table.len;
+	foreach (uint j, Entry *e : src)
+	{
+		if (!e) continue;
+		do
+		{
+			Entry* next = e.next;
+			uint i = index_for(e.hash, new_capacity);
+			e.next = new_table[i];
+			new_table[i] = e;
+			e = next;
+		}
+		while (e);
+	}
+}
+
+fn void hashset_put_all_for_create(HashSet* set, HashSet* other_set) @private
+{
+	if (!other_set.count) return;
+	foreach (Entry *e : other_set.table)
+	{
+		while (e)
+		{
+			hashset_put_for_create(set, e.value);
+			e = e.next;
+		}
+	}
+}
+
+fn void hashset_put_for_create(HashSet* set, Value value) @private
+{
+	uint hash = rehash(value.hash());
+	uint i = index_for(hash, set.table.len);
+	for (Entry *e = set.table[i]; e != null; e = e.next)
+	{
+		if (e.hash == hash && equals(value, e.value))
+		{
+			// Value already exists, no need to do anything
+			return;
+		}
+	}
+	hashset_create_entry(set, hash, value, i);
+}
+
+fn void hashset_free_internal(HashSet* self, void* ptr) @inline @private
+{
+	allocator::free(self.allocator, ptr);
+}
+
+fn void hashset_create_entry(HashSet* set, uint hash, Value value, int bucket_index) @private
+{
+	Entry* entry = allocator::new(set.allocator, Entry, {
+		.hash = hash,
+		.value = value,
+		.next = set.table[bucket_index]
+	});
+	set.table[bucket_index] = entry;
+	set.count++;
+}
+
+<*
+ Removes the entry for the specified value if present
+ @return "true if found and removed, false otherwise"
+*>
+fn bool hashset_remove_entry_for_value(HashSet* set, Value value) @private
+{
+	if (!set.count) return false;
+	uint hash = rehash(value.hash());
+	uint i = index_for(hash, set.table.len);
+	Entry* prev = set.table[i];
+	Entry* e = prev;
+	while (e)
+	{
+		Entry *next = e.next;
+		if (e.hash == hash && equals(value, e.value))
+		{
+			set.count--;
+			if (prev == e)
+			{
+				set.table[i] = next;
+			}
+			else
+			{
+				prev.next = next;
+			}
+			hashset_free_entry(set, e);
+			return true;
+		}
+		prev = e;
+		e = next;
+	}
+
+	return false;
+}
+
+fn void hashset_free_entry(HashSet* set, Entry *entry) @private
+{
+	allocator::free(set.allocator, entry);
+}
+
+struct HashSetIterator
+{
+	HashSet* set;
+	usz bucket_index;
+	Entry* current;
+}
+
+fn HashSetIterator HashSet.iter(&set) => { .set = set, .bucket_index = 0, .current = null };
+
+fn Value? HashSetIterator.next(&self)
+{
+	if (self.current)
+	{
+		Value value = self.current.value;
+		self.current = self.current.next;
+		return value;
+	}
+
+	while (self.bucket_index < self.set.table.len)
+	{
+		self.current = self.set.table[self.bucket_index++];
+		if (self.current)
+		{
+			Value value = self.current.value;
+			self.current = self.current.next;
+			return value;
+		}
+	}
+
+	return NOT_FOUND~;
+}
+
+fn usz HashSetIterator.len(&self) @operator(len)
+{
+	return self.set.count;
+}
+
+<* @pure *>
+fn uint rehash(uint hash) @inline @private
+{
+	hash ^= (hash >> 20) ^ (hash >> 12);
+	return hash ^ ((hash >> 7) ^ (hash >> 4));
+}
+
+macro uint index_for(uint hash, uint capacity) @private => hash & (capacity - 1);
+
+int dummy @local;

lib/std/collections/interfacelist.c3

@@ -0,0 +1,539 @@
+// Copyright (c) 2024-2025 Christoffer Lerno. All rights reserved.
+// Use of self source code is governed by the MIT license
+// a copy of which can be found in the LICENSE_STDLIB file.
+<*
+ @require Type.kindof == INTERFACE || Type.kindof == ANY : "The kind of an interfacelist must be an interface or `any`"
+*>
+module std::collections::interfacelist <Type>;
+import std::io,std::math;
+
+alias InterfacePredicate = fn bool(Type value);
+alias InterfaceTest = fn bool(Type type, Type context);
+
+<*
+ The InterfaceList contains a heterogenous set of types implementing an interface. anything placed in the
+ list will shallowly copied in order to be stored as the interface. This means
+ that the list will copy and free its elements.
+
+ However, because we're getting interface values back when we pop, those operations
+ need to take an allocator, as we can only copy then pop then return the copy.
+
+ If we're not doing pop, then things are easier, since we can just hand over
+ the existing value.
+*>
+struct InterfaceList (Printable)
+{
+	usz size;
+	usz capacity;
+	Allocator allocator;
+	Type* entries;
+}
+
+
+<*
+ Initialize the list. If not initialized then it will use the temp allocator
+ when something is pushed to it.
+
+ @param [&inout] allocator : "The allocator to use"
+ @param initial_capacity : "The initial capacity to reserve, defaults to 16"
+*>
+fn InterfaceList* InterfaceList.init(&self, Allocator allocator, usz initial_capacity = 16)
+{
+	self.allocator = allocator;
+	self.size = 0;
+	if (initial_capacity > 0)
+	{
+		initial_capacity = math::next_power_of_2(initial_capacity);
+		self.entries = allocator::alloc_array(allocator, Type, initial_capacity);
+	}
+	else
+	{
+		self.entries = null;
+	}
+	self.capacity = initial_capacity;
+	return self;
+}
+
+<*
+ Initialize the list using the temp allocator.
+
+ @param initial_capacity : "The initial capacity to reserve"
+*>
+fn InterfaceList* InterfaceList.tinit(&self, usz initial_capacity = 16)
+{
+	return self.init(tmem, initial_capacity) @inline;
+}
+
+fn bool InterfaceList.is_initialized(&self) @inline => self.allocator != null;
+
+<*
+ Push an element on the list by cloning it.
+ @require $defined(Type t = &element) : "Element must implement the interface"
+*>
+macro void InterfaceList.push(&self, element)
+{
+	if (!self.allocator) self.allocator = tmem;
+	interfacelist_append(self, allocator::clone(self.allocator, element));
+}
+
+<*
+ Free a retained element removed using *_retained.
+*>
+fn void InterfaceList.free_element(&self, Type element) @inline
+{
+	allocator::free(self.allocator, element.ptr);
+}
+
+<*
+ Copy the last value, pop it and return the copy of it.
+
+ @param [&inout] allocator : "The allocator to use for copying"
+ @return "A copy of the last value if it exists"
+ @return? NO_MORE_ELEMENT
+*>
+fn Type? InterfaceList.copy_pop(&self, Allocator allocator)
+{
+	if (!self.size) return NO_MORE_ELEMENT~;
+	defer self.free_element(self.entries[self.size]);
+	return (Type)allocator::clone_any(allocator, self.entries[--self.size]);
+}
+
+<*
+ Copy the last value, pop it and return the copy of it.
+
+ @return "A temp copy of the last value if it exists"
+ @return? NO_MORE_ELEMENT
+*>
+fn Type? InterfaceList.tcopy_pop(&self) => self.copy_pop(tmem);
+
+<*
+ Pop the last value. It must later be released using `list.free_element()`.
+
+ @return "The last value if it exists"
+ @return? NO_MORE_ELEMENT
+*>
+fn Type? InterfaceList.pop_retained(&self)
+{
+	if (!self.size) return NO_MORE_ELEMENT~;
+	return self.entries[--self.size];
+}
+
+<*
+ Remove all elements in the list.
+*>
+fn void InterfaceList.clear(&self)
+{
+	for (usz i = 0; i < self.size; i++)
+	{
+		self.free_element(self.entries[i]);
+	}
+	self.size = 0;
+}
+
+<*
+ Pop the first value. It must later be released using `list.free_element()`.
+
+ @return "The first value if it exists"
+ @return? NO_MORE_ELEMENT
+*>
+fn Type? InterfaceList.pop_first_retained(&self)
+{
+	if (!self.size) return NO_MORE_ELEMENT~;
+	defer self.remove_at(0);
+	return self.entries[0];
+}
+
+<*
+ Copy the first value, pop it and return the copy of it.
+
+ @param [&inout] allocator : "The allocator to use for copying"
+ @return "A copy of the first value if it exists"
+ @return? NO_MORE_ELEMENT
+*>
+fn Type? InterfaceList.copy_pop_first(&self, Allocator allocator)
+{
+	if (!self.size) return NO_MORE_ELEMENT~;
+	defer self.free_element(self.entries[self.size]);
+	defer self.remove_at(0);
+	return (Type)allocator::clone_any(allocator, self.entries[0]);
+}
+
+<*
+ Copy the first value, pop it and return the temp copy of it.
+
+ @return "A temp copy of the first value if it exists"
+ @return? NO_MORE_ELEMENT
+*>
+fn Type? InterfaceList.tcopy_pop_first(&self) => self.copy_pop_first(tmem);
+
+<*
+ Remove the element at the particular index.
+
+ @param index : "The index of the element to remove"
+ @require index < self.size
+*>
+fn void InterfaceList.remove_at(&self, usz index)
+{
+	if (!--self.size || index == self.size) return;
+	self.free_element(self.entries[index]);
+	self.entries[index .. self.size - 1] = self.entries[index + 1 .. self.size];
+}
+
+<*
+ Add all the elements in another InterfaceList.
+
+ @param [&in] other_list : "The list to add"
+*>
+fn void InterfaceList.add_all(&self, InterfaceList* other_list)
+{
+	if (!other_list.size) return;
+	self.reserve(other_list.size);
+	foreach (value : other_list)
+	{
+		self.entries[self.size++] = (Type)allocator::clone_any(self.allocator, value);
+	}
+}
+
+<*
+ Reverse the order of the elements in the list.
+*>
+fn void InterfaceList.reverse(&self)
+{
+	if (self.size < 2) return;
+	usz half = self.size / 2U;
+	usz end = self.size - 1;
+	for (usz i = 0; i < half; i++)
+	{
+		self.swap(i, end - i);
+	}
+}
+
+<*
+ Return a view of the data as a slice.
+
+ @return "The slice view"
+*>
+fn Type[] InterfaceList.array_view(&self)
+{
+	return self.entries[:self.size];
+}
+
+<*
+ Push an element to the front of the list.
+
+ @param value : "The value to push to the list"
+ @require $defined(Type t = &value) : "Value must implement the interface"
+*>
+macro void InterfaceList.push_front(&self, value)
+{
+	self.insert_at(0, value);
+}
+
+<*
+ Insert an element at a particular index.
+
+ @param index : "the index where the element should be inserted"
+ @param type : "the value to insert"
+ @require index <= self.size : "The index is out of bounds"
+ @require $defined(Type t = &type) : "Type must implement the interface"
+*>
+macro void InterfaceList.insert_at(&self, usz index, type)
+{
+	if (index == self.size)
+	{
+		self.push(type);
+		return;
+	}
+	Type value = allocator::clone(self.allocator, type);
+	self._insert_at(self, index, value);
+}
+
+<*
+ Remove the last element in the list. The list may not be empty.
+
+ @require self.size > 0 : "The list was already empty"
+*>
+fn void InterfaceList.remove_last(&self)
+{
+	self.free_element(self.entries[--self.size]);
+}
+
+<*
+ Remove the first element in the list, the list may not be empty.
+
+ @require self.size > 0
+*>
+fn void InterfaceList.remove_first(&self)
+{
+	self.remove_at(0);
+}
+
+<*
+ Return the first element
+
+ @return "The first element"
+ @return? NO_MORE_ELEMENT
+*>
+fn Type? InterfaceList.first(&self) @inline
+{
+	return self.size ? self.entries[0] : NO_MORE_ELEMENT~;
+}
+
+<*
+ Return the last element
+
+ @return "The last element"
+ @return? NO_MORE_ELEMENT
+*>
+fn Type? InterfaceList.last(&self) @inline
+{
+	return self.size ? self.entries[self.size - 1] : NO_MORE_ELEMENT~;
+}
+
+<*
+ Return whether the list is empty.
+
+ @return "True if the list is empty"
+*>
+fn bool InterfaceList.is_empty(&self) @inline
+{
+	return !self.size;
+}
+
+<*
+ Return the length of the list.
+
+ @return "The number of elements in the list"
+*>
+fn usz InterfaceList.len(&self) @operator(len) @inline
+{
+	return self.size;
+}
+
+<*
+ Return an element in the list.
+
+ @param index : "The index of the element to retrieve"
+ @return "The element at the index"
+ @return? TYPE_MISMATCH, NO_MORE_ELEMENT
+ @require index < self.size : "Index out of range"
+*>
+fn Type InterfaceList.get(&self, usz index) @inline @operator([])
+{
+	return self.entries[index];
+}
+
+<*
+ Completely free and clear a list.
+*>
+fn void InterfaceList.free(&self)
+{
+	if (!self.allocator) return;
+	self.clear();
+	allocator::free(self.allocator, self.entries);
+	self.capacity = 0;
+	self.entries = null;
+}
+
+<*
+ Swap two elements in a list.
+
+ @param i : "Index of one of the elements"
+ @param j : "Index of the other element"
+ @require i < self.size : "The first index is out of range"
+ @require j < self.size : "The second index is out of range"
+*>
+fn void InterfaceList.swap(&self, usz i, usz j)
+{
+	Type temp = self.entries[i];
+	self.entries[i] = self.entries[j];
+	self.entries[j] = temp;
+}
+
+<*
+ Print the list to a formatter.
+*>
+fn usz? InterfaceList.to_format(&self, Formatter* formatter) @dynamic
+{
+	switch (self.size)
+	{
+		case 0:
+			return formatter.print("[]")!;
+		case 1:
+			return formatter.printf("[%s]", self.entries[0])!;
+		default:
+			usz n = formatter.print("[")!;
+			foreach (i, element : self.entries[:self.size])
+			{
+				if (i != 0) formatter.print(", ")!;
+				n += formatter.printf("%s", element)!;
+			}
+			n += formatter.print("]")!;
+			return n;
+	}
+}
+
+<*
+ Remove Type elements matching the predicate.
+
+ @param filter : "The function to determine if it should be removed or not"
+ @return "the number of deleted elements"
+*>
+fn usz InterfaceList.remove_if(&self, InterfacePredicate filter)
+{
+	return interfacelist_remove_if(self, filter, false);
+}
+
+<*
+ Retain the elements matching the predicate.
+
+ @param selection : "The function to determine if it should be kept or not"
+ @return "the number of deleted elements"
+*>
+fn usz InterfaceList.retain_if(&self, InterfacePredicate selection)
+{
+	return interfacelist_remove_if(self, selection, true);
+}
+
+<*
+ Remove Type elements matching the predicate.
+
+ @param filter : "The function to determine if it should be removed or not"
+ @param context : "The context to the function"
+ @return "the number of deleted elements"
+*>
+fn usz InterfaceList.remove_using_test(&self, InterfaceTest filter, Type context)
+{
+	return interfacelist_remove_using_test(self, filter, false, context);
+}
+
+<*
+ Retain Type elements matching the predicate.
+
+ @param selection : "The function to determine if it should be retained or not"
+ @param context : "The context to the function"
+ @return "the number of deleted elements"
+*>
+fn usz InterfaceList.retain_using_test(&self, InterfaceTest selection, Type context)
+{
+	return interfacelist_remove_using_test(self, selection, true, context);
+}
+
+<*
+ Reserve memory so that at least the `min_capacity` exists.
+
+ @param min_capacity : "The min capacity to hold"
+*>
+fn void InterfaceList.reserve(&self, usz min_capacity)
+{
+	if (!min_capacity) return;
+	if (self.capacity >= min_capacity) return;
+	if (!self.allocator) self.allocator = tmem;
+	min_capacity = math::next_power_of_2(min_capacity);
+	self.entries = allocator::realloc(self.allocator, self.entries, Type.sizeof * min_capacity);
+	self.capacity = min_capacity;
+}
+
+<*
+ Set the element at Type index.
+
+ @param index : "The index where to set the value."
+ @param value : "The value to set"
+ @require index <= self.size : "Index out of range"
+ @require $defined(Type t = &value) : "Value must implement the interface"
+*>
+macro void InterfaceList.set(&self, usz index, value)
+{
+	if (index == self.size)
+	{
+		self.push(value);
+		return;
+	}
+	self.free_element(self.entries[index]);
+	self.entries[index] = allocator::clone(self.allocator, value);
+}
+
+// -- private
+
+fn void interfacelist_ensure_capacity(InterfaceList* self, usz added = 1) @inline @private
+{
+	usz new_size = self.size + added;
+	if (self.capacity >= new_size) return;
+
+	assert(new_size < usz.max / 2U);
+	usz new_capacity = self.capacity ? 2U * self.capacity : 16U;
+	while (new_capacity < new_size) new_capacity *= 2U;
+	self.reserve(new_capacity);
+}
+
+fn void interfacelist_append(InterfaceList* self, Type element) @local
+{
+	interfacelist_ensure_capacity(self);
+	self.entries[self.size++] = element;
+}
+
+<*
+ @require index < self.size
+*>
+fn void interfacelist_insert_at(InterfaceList* self, usz index, Type value) @local
+{
+	interfacelist_ensure_capacity(self);
+	for (usz i = self.size; i > index; i--)
+	{
+		self.entries[i] = self.entries[i - 1];
+	}
+	self.size++;
+	self.entries[index] = value;
+}
+
+macro usz interfacelist_remove_using_test(InterfaceList* self, InterfaceTest filter, bool $invert, ctx) @local
+{
+	usz size = self.size;
+	for (usz i = size, usz k = size; k > 0; k = i)
+	{
+		// Find last index of item to be deleted.
+		$if $invert:
+			while (i > 0 && !filter(self.entries[i - 1], ctx)) i--;
+		$else
+			while (i > 0 && filter(self.entries[i - 1], ctx)) i--;
+		$endif
+		// Remove the items from this index up to the one not to be deleted.
+		usz n = self.size - k;
+		for (usz j = i; j < k; j++) self.free_element(self.entries[j]);
+		self.entries[i:n] = self.entries[k:n];
+		self.size -= k - i;
+		// Find last index of item not to be deleted.
+		$if $invert:
+			while (i > 0 && filter(self.entries[i - 1], ctx)) i--;
+		$else
+			while (i > 0 && !filter(self.entries[i - 1], ctx)) i--;
+		$endif
+	}
+	return size - self.size;
+}
+
+macro usz interfacelist_remove_if(InterfaceList* self, InterfacePredicate filter, bool $invert) @local
+{
+	usz size = self.size;
+	for (usz i = size, usz k = size; k > 0; k = i)
+	{
+		// Find last index of item to be deleted.
+		$if $invert:
+			while (i > 0 && !filter(self.entries[i - 1])) i--;
+		$else
+			while (i > 0 && filter(self.entries[i - 1])) i--;
+		$endif
+		// Remove the items from this index up to the one not to be deleted.
+		usz n = self.size - k;
+		for (usz j = i; j < k; j++) self.free_element(self.entries[j]);
+		self.entries[i:n] = self.entries[k:n];
+		self.size -= k - i;
+		// Find last index of item not to be deleted.
+		$if $invert:
+			while (i > 0 && filter(self.entries[i - 1])) i--;
+		$else
+			while (i > 0 && !filter(self.entries[i - 1])) i--;
+		$endif
+	}
+	return size - self.size;
+}

lib/std/collections/linked_blockingqueue.c3

@@ -0,0 +1,333 @@
+module std::collections::blockingqueue <Value>;
+import std::thread, std::time;
+
+
+const INITIAL_CAPACITY = 16;
+
+struct QueueEntry 
+{
+	Value value;
+	<* Next in queue order *>
+	QueueEntry* next;
+	<* Previous in queue order *>
+	QueueEntry* prev;
+}
+
+struct LinkedBlockingQueue 
+{
+	<* First element in queue *>
+	QueueEntry* head;
+	<* Last element in queue *>
+	QueueEntry* tail;
+	<* Current number of elements *>
+	usz count;
+	<* Maximum capacity (0 for unbounded) *>
+	usz capacity;
+	Mutex lock;
+	ConditionVariable not_empty;
+	ConditionVariable not_full;
+	Allocator allocator;
+}
+
+<*
+ @param [&inout] allocator : "The allocator to use"
+ @param capacity : "Maximum capacity (0 for unbounded)"
+ @require !self.is_initialized() : "Queue was already initialized"
+*>
+fn LinkedBlockingQueue* LinkedBlockingQueue.init(&self, Allocator allocator, usz capacity = 0)
+{
+	self.allocator = allocator;
+	self.capacity = capacity;
+	self.count = 0;
+	self.head = null;
+	self.tail = null;
+
+	self.lock.init()!!;
+	self.not_empty.init()!!;
+	self.not_full.init()!!;
+	return self;
+}
+
+fn LinkedBlockingQueue* LinkedBlockingQueue.tinit(&self, usz capacity = 0)
+{
+	return self.init(tmem, capacity) @inline;
+}
+
+<*
+ @require self.is_initialized() : "Queue must be initialized"
+*>
+fn void LinkedBlockingQueue.free(&self)
+{
+	self.lock.@in_lock()
+	{
+		// Free all remaining entries
+		QueueEntry* entry = self.head;
+		while (entry != null)
+		{
+			QueueEntry* next = entry.next;
+			allocator::free(self.allocator, entry);
+			entry = next;
+		}
+	};
+
+	self.lock.destroy();
+	self.not_empty.destroy();
+	self.not_full.destroy();
+}
+
+fn void linkedblockingqueue_link_entry(LinkedBlockingQueue* self, QueueEntry* entry) @private
+{
+	entry.next = null;
+	entry.prev = self.tail;
+
+	if (self.tail == null)
+	{
+		// First element in queue
+		self.head = entry;
+	}
+	else
+	{
+		// Append to tail
+		self.tail.next = entry;
+	}
+	self.tail = entry;
+	self.count++;
+}
+
+
+fn QueueEntry* linkedblockingqueue_unlink_head(LinkedBlockingQueue* self) @private
+{
+	if (self.head == null) return null;
+
+	QueueEntry* entry = self.head;
+	self.head = entry.next;
+
+	if (self.head != null)
+	{
+		self.head.prev = null;
+	}
+	else
+	{
+		// Queue is now empty
+		self.tail = null;
+	}
+
+	self.count--;
+	return entry;
+}
+
+<*
+ @param value : "Value to add to the queue"
+ @require self.is_initialized() : "Queue must be initialized"
+*>
+fn void LinkedBlockingQueue.push(&self, Value value)
+{
+	self.lock.@in_lock()
+	{
+		while (self.capacity > 0 && self.count >= self.capacity)
+		{
+			self.not_full.wait(&self.lock);
+		}
+
+		QueueEntry* entry = allocator::new(self.allocator, QueueEntry, {
+			.value = value,
+			.next = null,
+			.prev = null
+		});
+		linkedblockingqueue_link_entry(self, entry);
+
+		// Signal that queue is no longer empty
+		self.not_empty.signal();
+	};
+}
+
+<*
+ Get a value from the queue, blocking if there is no element in the queue.
+
+ @require self.is_initialized() : "Queue must be initialized"
+ @return "The removed value"
+*>
+fn Value LinkedBlockingQueue.poll(&self)
+{
+	self.lock.@in_lock()
+	{
+		while (self.count == 0)
+		{
+			self.not_empty.wait(&self.lock);
+		}
+
+		QueueEntry* entry = linkedblockingqueue_unlink_head(self);
+		Value value = entry.value;
+		allocator::free(self.allocator, entry);
+		if (self.capacity > 0)
+		{
+			self.not_full.signal();
+		}
+		return value;
+	};
+}
+
+<*
+ Pop an element from the queue, fail is it is empty.
+
+ @require self.is_initialized() : "Queue must be initialized"
+ @return "The removed value"
+ @return? NO_MORE_ELEMENT : "If the queue is empty"
+*>
+fn Value? LinkedBlockingQueue.pop(&self)
+{
+	self.lock.@in_lock()
+	{
+		if (self.count == 0) return NO_MORE_ELEMENT~;
+
+		QueueEntry* entry = linkedblockingqueue_unlink_head(self);
+		Value value = entry.value;
+		allocator::free(self.allocator, entry);
+
+		if (self.capacity > 0)
+		{
+			self.not_full.signal();
+		}
+		return value;
+	};
+}
+
+<*
+ Poll with a timeout.
+
+ @param timeout : "Timeout in microseconds"
+ @require self.is_initialized() : "Queue must be initialized"
+ @return "The removed value or null if timeout occurred"
+ @return? NO_MORE_ELEMENT : "If we reached the timeout"
+*>
+fn Value? LinkedBlockingQueue.poll_timeout(&self, Duration timeout)
+{
+	self.lock.@in_lock()
+	{
+		// Use while loop to handle spurious wakeups
+		if (!self.count)
+		{
+			Time start = time::now();
+			Time end = start + timeout;
+			while (!self.count)
+			{
+        		if (end <= time::now()) break;
+        		if (catch self.not_empty.wait_until(&self.lock, end)) break;
+			}
+			if (!self.count) return NO_MORE_ELEMENT~;
+		}
+
+		QueueEntry* entry = linkedblockingqueue_unlink_head(self);
+		Value value = entry.value;
+		allocator::free(self.allocator, entry);
+
+		// Must signal not_full after removing an item
+		if (self.capacity > 0)
+		{
+			self.not_full.signal();
+		}
+		return value;
+	};
+}
+
+
+<*
+ @require self.is_initialized() : "Queue must be initialized"
+ @return "Current size of the queue"
+*>
+fn usz LinkedBlockingQueue.size(&self)
+{
+	self.lock.@in_lock()
+	{
+		return self.count;
+	};
+}
+
+<*
+ @require self.is_initialized() : "Queue must be initialized"
+ @return "True if queue is empty"
+*>
+fn bool LinkedBlockingQueue.is_empty(&self)
+{
+	self.lock.@in_lock()
+	{
+		return self.count == 0;
+	};
+}
+
+<*
+ Try to push, return CAPACITY_EXCEEDED if the queue is full.
+
+ @param value : "Value to add to the queue"
+ @require self.is_initialized() : "Queue must be initialized"
+ @return? CAPACITY_EXCEEDED : "If the queue is full"
+*>
+fn void? LinkedBlockingQueue.try_push(&self, Value value)
+{
+	self.lock.@in_lock()
+	{
+		if (self.capacity > 0 && self.count >= self.capacity) return CAPACITY_EXCEEDED~;
+
+		QueueEntry* entry = allocator::new(self.allocator, QueueEntry, {
+			.value = value,
+			.next = null,
+			.prev = null
+		});
+		linkedblockingqueue_link_entry(self, entry);
+		self.not_empty.signal();
+	};
+}
+
+<*
+ Try to push, return CAPACITY_EXCEEDED if the queue is still full after timeout is reached.
+
+ @param value : "Value to add to the queue"
+ @param timeout : "Timeout in microseconds"
+ @require self.is_initialized() : "Queue must be initialized"
+ @return? CAPACITY_EXCEEDED : "If the queue is full"
+*>
+fn void? LinkedBlockingQueue.push_timeout(&self, Value value, Duration timeout)
+{
+	self.lock.@in_lock()
+	{
+		if (self.capacity > 0 && self.count >= self.capacity)
+		{
+			Time start = time::now();
+			Time end = start + timeout;
+        	while (self.capacity > 0 && self.count >= self.capacity)
+			{
+        		if (end <= time::now()) break;
+				if (catch self.not_empty.wait_until(&self.lock, end)) break;
+			}
+			if (self.capacity > 0 && self.count >= self.capacity) return CAPACITY_EXCEEDED~;
+		}
+
+		QueueEntry* entry = allocator::new(self.allocator, QueueEntry, {
+			.value = value,
+			.next = null,
+			.prev = null
+		});
+		linkedblockingqueue_link_entry(self, entry);
+		self.not_empty.signal();
+	};
+}
+
+<*
+ @require self.is_initialized() : "Queue must be initialized"
+ @return "The head value or NO_MORE_ELEMENT~ if queue is empty"
+*>
+fn Value? LinkedBlockingQueue.peek(&self)
+{
+	self.lock.@in_lock()
+	{
+		return (self.head != null) ? self.head.value : NO_MORE_ELEMENT~;
+	};
+}
+
+<*
+ @return "True if queue is initialized"
+*>
+fn bool LinkedBlockingQueue.is_initialized(&self)
+{
+	return self.allocator && self.lock.initialized;
+}

lib/std/collections/linked_hashmap.c3

@@ -0,0 +1,651 @@
+// Copyright (c) 2023 Christoffer Lerno. All rights reserved.
+// Use of this source code is governed by the MIT license
+// a copy of which can be found in the LICENSE_STDLIB file.
+<*
+ @require $defined((Key){}.hash()) : `No .hash function found on the key`
+*>
+module std::collections::map <Key, Value>;
+import std::math;
+import std::io @norecurse;
+
+const LinkedHashMap LINKEDONHEAP = { .allocator = MAP_HEAP_ALLOCATOR };
+
+struct LinkedEntry
+{
+	uint hash;
+	Key key;
+	Value value;
+	<* For bucket chain *>
+	LinkedEntry* next;
+	<* Previous in insertion order *>
+	LinkedEntry* before;
+	<* Next in insertion order *>
+	LinkedEntry* after;
+}
+
+struct LinkedHashMap (Printable)
+{
+	LinkedEntry*[] table;
+	Allocator allocator;
+	usz count;
+	usz threshold;
+	float load_factor;
+	<* First inserted LinkedEntry *>
+	LinkedEntry* head;
+	<* Last inserted LinkedEntry *>
+	LinkedEntry* tail;
+}
+
+
+<*
+ @param [&inout] allocator : "The allocator to use"
+ @require capacity > 0 : "The capacity must be 1 or higher"
+ @require load_factor > 0.0 : "The load factor must be higher than 0"
+ @require !self.is_initialized() : "Map was already initialized"
+ @require capacity < MAXIMUM_CAPACITY : "Capacity cannot exceed maximum"
+*>
+fn LinkedHashMap* LinkedHashMap.init(&self, Allocator allocator, usz capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
+{
+	capacity = math::next_power_of_2(capacity);
+	self.allocator = allocator;
+	self.load_factor = load_factor;
+	self.threshold = (usz)(capacity * load_factor);
+	self.table = allocator::new_array(allocator, LinkedEntry*, capacity);
+	self.head = null;
+	self.tail = null;
+	return self;
+}
+
+<*
+ @require capacity > 0 : "The capacity must be 1 or higher"
+ @require load_factor > 0.0 : "The load factor must be higher than 0"
+ @require !self.is_initialized() : "Map was already initialized"
+ @require capacity < MAXIMUM_CAPACITY : "Capacity cannot exceed maximum"
+*>
+fn LinkedHashMap* LinkedHashMap.tinit(&self, usz capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
+{
+	return self.init(tmem, capacity, load_factor) @inline;
+}
+
+<*
+ @param [&inout] allocator : "The allocator to use"
+ @require $vacount % 2 == 0 : "There must be an even number of arguments provided for keys and values"
+ @require capacity > 0 : "The capacity must be 1 or higher"
+ @require load_factor > 0.0 : "The load factor must be higher than 0"
+ @require !self.is_initialized() : "Map was already initialized"
+ @require capacity < MAXIMUM_CAPACITY : "Capacity cannot exceed maximum"
+*>
+macro LinkedHashMap* LinkedHashMap.init_with_key_values(&self, Allocator allocator, ..., uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
+{
+	self.init(allocator, capacity, load_factor);
+	$for var $i = 0; $i < $vacount; $i += 2:
+		self.set($vaarg[$i], $vaarg[$i + 1]);
+	$endfor
+	return self;
+}
+
+<*
+ @require $vacount % 2 == 0 : "There must be an even number of arguments provided for keys and values"
+ @require capacity > 0 : "The capacity must be 1 or higher"
+ @require load_factor > 0.0 : "The load factor must be higher than 0"
+ @require !self.is_initialized() : "Map was already initialized"
+ @require capacity < MAXIMUM_CAPACITY : "Capacity cannot exceed maximum"
+*>
+macro LinkedHashMap* LinkedHashMap.tinit_with_key_values(&self, ..., uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
+{
+	return self.init_with_key_values(tmem, $vasplat, capacity: capacity, load_factor: load_factor);
+}
+
+<*
+ @param [in] keys : "The keys for the LinkedHashMap entries"
+ @param [in] values : "The values for the LinkedHashMap entries"
+ @param [&inout] allocator : "The allocator to use"
+ @require keys.len == values.len : "Both keys and values arrays must be the same length"
+ @require capacity > 0 : "The capacity must be 1 or higher"
+ @require load_factor > 0.0 : "The load factor must be higher than 0"
+ @require !self.is_initialized() : "Map was already initialized"
+ @require capacity < MAXIMUM_CAPACITY : "Capacity cannot exceed maximum"
+*>
+fn LinkedHashMap* LinkedHashMap.init_from_keys_and_values(&self, Allocator allocator, Key[] keys, Value[] values, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
+{
+	assert(keys.len == values.len);
+	self.init(allocator, capacity, load_factor);
+	for (usz i = 0; i < keys.len; i++)
+	{
+		self.set(keys[i], values[i]);
+	}
+	return self;
+}
+
+<*
+ @param [in] keys : "The keys for the LinkedHashMap entries"
+ @param [in] values : "The values for the LinkedHashMap entries"
+ @require keys.len == values.len : "Both keys and values arrays must be the same length"
+ @require capacity > 0 : "The capacity must be 1 or higher"
+ @require load_factor > 0.0 : "The load factor must be higher than 0"
+ @require !self.is_initialized() : "Map was already initialized"
+ @require capacity < MAXIMUM_CAPACITY : "Capacity cannot exceed maximum"
+*>
+fn LinkedHashMap* LinkedHashMap.tinit_from_keys_and_values(&self, Key[] keys, Value[] values, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
+{
+	return self.init_from_keys_and_values(tmem, keys, values, capacity, load_factor);
+}
+
+<*
+ Has this hash map been initialized yet?
+
+ @param [&in] map : "The hash map we are testing"
+ @return "Returns true if it has been initialized, false otherwise"
+*>
+fn bool LinkedHashMap.is_initialized(&map)
+{
+	return map.allocator && map.allocator.ptr != &dummy;
+}
+
+<*
+ @param [&inout] allocator : "The allocator to use"
+ @param [&in] other_map : "The map to copy from."
+ @require !self.is_initialized() : "Map was already initialized"
+*>
+fn LinkedHashMap* LinkedHashMap.init_from_map(&self, Allocator allocator, LinkedHashMap* other_map)
+{
+	self.init(allocator, other_map.table.len, other_map.load_factor);
+	linkedhashmap_put_all_for_create(self, other_map);
+	return self;
+}
+
+<*
+ @param [&in] other_map : "The map to copy from."
+ @require !map.is_initialized() : "Map was already initialized"
+*>
+fn LinkedHashMap* LinkedHashMap.tinit_from_map(&map, LinkedHashMap* other_map)
+{
+	return map.init_from_map(tmem, other_map) @inline;
+}
+
+fn bool LinkedHashMap.is_empty(&map) @inline
+{
+	return !map.count;
+}
+
+fn usz LinkedHashMap.len(&map) @inline => map.count;
+
+fn Value*? LinkedHashMap.get_ref(&map, Key key)
+{
+	if (!map.count) return NOT_FOUND~;
+	uint hash = rehash(key.hash());
+	for (LinkedEntry *e = map.table[index_for(hash, map.table.len)]; e != null; e = e.next)
+	{
+		if (e.hash == hash && equals(key, e.key)) return &e.value;
+	}
+	return NOT_FOUND~;
+}
+
+fn LinkedEntry*? LinkedHashMap.get_entry(&map, Key key)
+{
+	if (!map.count) return NOT_FOUND~;
+	uint hash = rehash(key.hash());
+	for (LinkedEntry *e = map.table[index_for(hash, map.table.len)]; e != null; e = e.next)
+	{
+		if (e.hash == hash && equals(key, e.key)) return e;
+	}
+	return NOT_FOUND~;
+}
+
+<*
+ Get the value or set it to the value
+
+ @require $defined(Value val = #expr)
+*>
+macro Value LinkedHashMap.@get_or_set(&map, Key key, Value #expr)
+{
+	if (!map.count)
+	{
+		Value val = #expr;
+		map.set(key, val);
+		return val;
+	}
+	uint hash = rehash(key.hash());
+	uint index = index_for(hash, map.table.len);
+	for (LinkedEntry *e = map.table[index]; e != null; e = e.next)
+	{
+		if (e.hash == hash && equals(key, e.key)) return e.value;
+	}
+	Value val = #expr;
+	map.add_entry(hash, key, val, index);
+	return val;
+}
+
+fn Value? LinkedHashMap.get(&map, Key key) @operator([]) => *map.get_ref(key) @inline;
+
+fn bool LinkedHashMap.has_key(&map, Key key) => @ok(map.get_ref(key));
+
+fn bool LinkedHashMap.set(&map, Key key, Value value) @operator([]=)
+{
+	// If the map isn't initialized, use the defaults to initialize it.
+	switch (map.allocator.ptr)
+	{
+		case &dummy:
+			map.init(mem);
+		case null:
+			map.tinit();
+		default:
+			break;
+	}
+	uint hash = rehash(key.hash());
+	uint index = index_for(hash, map.table.len);
+	for (LinkedEntry *e = map.table[index]; e != null; e = e.next)
+	{
+		if (e.hash == hash && equals(key, e.key))
+		{
+			e.value = value;
+			return true;
+		}
+	}
+	linkedhashmap_add_entry(map, hash, key, value, index);
+	return false;
+}
+
+fn void? LinkedHashMap.remove(&map, Key key) @maydiscard
+{
+	if (!linkedhashmap_remove_entry_for_key(map, key)) return NOT_FOUND~;
+}
+
+fn void LinkedHashMap.clear(&map)
+{
+	if (!map.count) return;
+
+	LinkedEntry* entry = map.head;
+	while (entry)
+	{
+		LinkedEntry* next = entry.after;
+		linkedhashmap_free_entry(map, entry);
+		entry = next;
+	}
+
+	foreach (LinkedEntry** &bucket : map.table)
+	{
+		*bucket = null;
+	}
+
+	map.count = 0;
+	map.head = null;
+	map.tail = null;
+}
+
+fn void LinkedHashMap.free(&map)
+{
+	if (!map.is_initialized()) return;
+	map.clear();
+	linkedhashmap_free_internal(map, map.table.ptr);
+	map.table = {};
+}
+
+fn Key[] LinkedHashMap.tkeys(&self)
+{
+	return self.keys(tmem) @inline;
+}
+
+fn Key[] LinkedHashMap.keys(&self, Allocator allocator)
+{
+	if (!self.count) return {};
+
+	Key[] list = allocator::alloc_array(allocator, Key, self.count);
+	usz index = 0;
+
+	LinkedEntry* entry = self.head;
+	while (entry)
+	{
+		$if COPY_KEYS:
+			list[index++] = entry.key.copy(allocator);
+		$else
+			list[index++] = entry.key;
+		$endif
+		entry = entry.after;
+	}
+	return list;
+}
+
+macro LinkedHashMap.@each(map; @body(key, value))
+{
+	map.@each_entry(; LinkedEntry* entry)
+	{
+		@body(entry.key, entry.value);
+	};
+}
+
+macro LinkedHashMap.@each_entry(map; @body(entry))
+{
+	LinkedEntry* entry = map.head;
+	while (entry)
+	{
+		@body(entry);
+		entry = entry.after;
+	}
+}
+
+fn Value[] LinkedHashMap.tvalues(&map) => map.values(tmem) @inline;
+
+fn Value[] LinkedHashMap.values(&self, Allocator allocator)
+{
+	if (!self.count) return {};
+	Value[] list = allocator::alloc_array(allocator, Value, self.count);
+	usz index = 0;
+	LinkedEntry* entry = self.head;
+	while (entry)
+	{
+		list[index++] = entry.value;
+		entry = entry.after;
+	}
+	return list;
+}
+
+fn bool LinkedHashMap.has_value(&map, Value v) @if(VALUE_IS_EQUATABLE)
+{
+	if (!map.count) return false;
+
+	LinkedEntry* entry = map.head;
+	while (entry)
+	{
+		if (equals(v, entry.value)) return true;
+		entry = entry.after;
+	}
+	return false;
+}
+
+fn LinkedHashMapIterator LinkedHashMap.iter(&self) => { .map = self, .current = self.head, .started = false };
+
+fn LinkedHashMapValueIterator LinkedHashMap.value_iter(&self) => { .map = self, .current = self.head, .started = false };
+
+fn LinkedHashMapKeyIterator LinkedHashMap.key_iter(&self) => { .map = self, .current = self.head, .started = false };
+
+fn bool LinkedHashMapIterator.next(&self)
+{
+	if (!self.started)
+	{
+		self.current = self.map.head;
+		self.started = true;
+	}
+	else if (self.current)
+	{
+		self.current = self.current.after;
+	}
+	return self.current != null;
+}
+
+fn LinkedEntry*? LinkedHashMapIterator.get(&self)
+{
+	return self.current ? self.current : NOT_FOUND~;
+}
+
+fn Value*? LinkedHashMapValueIterator.get(&self)
+{
+	return self.current ? &self.current.value : NOT_FOUND~;
+}
+
+fn Key*? LinkedHashMapKeyIterator.get(&self)
+{
+	return self.current ? &self.current.key : NOT_FOUND~;
+}
+
+fn bool LinkedHashMapIterator.has_next(&self)
+{
+	if (!self.started) return self.map.head != null;
+	return self.current && self.current.after != null;
+}
+
+// --- private methods
+
+fn void linkedhashmap_add_entry(LinkedHashMap* map, uint hash, Key key, Value value, uint bucket_index) @private
+{
+	$if COPY_KEYS:
+	key = key.copy(map.allocator);
+	$endif
+
+	LinkedEntry* entry = allocator::new(map.allocator, LinkedEntry, {
+		.hash = hash,
+		.key = key,
+		.value = value,
+		.next = map.table[bucket_index],
+		.before = map.tail,
+		.after = null
+	});
+
+	// Update bucket chain
+	map.table[bucket_index] = entry;
+
+	// Update linked list
+	if (map.tail)
+	{
+		map.tail.after = entry;
+		entry.before = map.tail;
+	}
+	else
+	{
+		map.head = entry;
+	}
+	map.tail = entry;
+
+	if (map.count++ >= map.threshold)
+	{
+		linkedhashmap_resize(map, map.table.len * 2);
+	}
+}
+
+fn void linkedhashmap_resize(LinkedHashMap* map, uint new_capacity) @private
+{
+	LinkedEntry*[] old_table = map.table;
+	uint old_capacity = old_table.len;
+
+	if (old_capacity == MAXIMUM_CAPACITY)
+	{
+		map.threshold = uint.max;
+		return;
+	}
+
+	LinkedEntry*[] new_table = allocator::new_array(map.allocator, LinkedEntry*, new_capacity);
+	map.table = new_table;
+	map.threshold = (uint)(new_capacity * map.load_factor);
+
+	// Rehash all entries - linked list order remains unchanged
+	foreach (uint i, LinkedEntry *e : old_table)
+	{
+		if (!e) continue;
+
+		// Split the bucket chain into two chains based on new bit
+		LinkedEntry* lo_head = null;
+		LinkedEntry* lo_tail = null;
+		LinkedEntry* hi_head = null;
+		LinkedEntry* hi_tail = null;
+
+		do
+		{
+			LinkedEntry* next = e.next;
+			if ((e.hash & old_capacity) == 0)
+			{
+				if (!lo_tail)
+				{
+					lo_head = e;
+				}
+				else
+				{
+					lo_tail.next = e;
+				}
+				lo_tail = e;
+			}
+			else
+			{
+				if (!hi_tail)
+				{
+					hi_head = e;
+				}
+				else
+				{
+					hi_tail.next = e;
+				}
+				hi_tail = e;
+			}
+			e.next = null;
+			e = next;
+		}
+		while (e);
+
+		if (lo_tail)
+		{
+			lo_tail.next = null;
+			new_table[i] = lo_head;
+		}
+		if (hi_tail)
+		{
+			hi_tail.next = null;
+			new_table[i + old_capacity] = hi_head;
+		}
+	}
+
+	linkedhashmap_free_internal(map, old_table.ptr);
+}
+
+fn usz? LinkedHashMap.to_format(&self, Formatter* f) @dynamic
+{
+	usz len;
+	len += f.print("{ ")!;
+	self.@each_entry(; LinkedEntry* entry)
+	{
+		if (len > 2) len += f.print(", ")!;
+		len += f.printf("%s: %s", entry.key, entry.value)!;
+	};
+	return len + f.print(" }");
+}
+
+fn void linkedhashmap_transfer(LinkedHashMap* map, LinkedEntry*[] new_table) @private
+{
+	LinkedEntry*[] src = map.table;
+	uint new_capacity = new_table.len;
+	foreach (uint j, LinkedEntry *e : src)
+	{
+		if (!e) continue;
+		do
+		{
+			LinkedEntry* next = e.next;
+			uint i = index_for(e.hash, new_capacity);
+			e.next = new_table[i];
+			new_table[i] = e;
+			e = next;
+		}
+		while (e);
+	}
+}
+
+fn void linkedhashmap_put_all_for_create(LinkedHashMap* map, LinkedHashMap* other_map) @private
+{
+	if (!other_map.count) return;
+	other_map.@each(; Key key, Value value) {
+		map.set(key, value);
+	};
+}
+
+fn void linkedhashmap_put_for_create(LinkedHashMap* map, Key key, Value value) @private
+{
+	uint hash = rehash(key.hash());
+	uint i = index_for(hash, map.table.len);
+	for (LinkedEntry *e = map.table[i]; e != null; e = e.next)
+	{
+		if (e.hash == hash && equals(key, e.key))
+		{
+			e.value = value;
+			return;
+		}
+	}
+	linkedhashmap_create_entry(map, hash, key, value, i);
+}
+
+fn void linkedhashmap_free_internal(LinkedHashMap* map, void* ptr) @inline @private
+{
+	allocator::free(map.allocator, ptr);
+}
+
+fn bool linkedhashmap_remove_entry_for_key(LinkedHashMap* map, Key key) @private
+{
+	if (!map.count) return false;
+
+	uint hash = rehash(key.hash());
+	uint i = index_for(hash, map.table.len);
+	LinkedEntry* prev = null;
+	LinkedEntry* e = map.table[i];
+
+	while (e)
+	{
+		if (e.hash == hash && equals(key, e.key))
+		{
+			if (prev)
+			{
+				prev.next = e.next;
+			}
+			else
+			{
+				map.table[i] = e.next;
+			}
+
+			if (e.before)
+			{
+				e.before.after = e.after;
+			}
+			else
+			{
+				map.head = e.after;
+			}
+
+			if (e.after)
+			{
+				e.after.before = e.before;
+			}
+			else
+			{
+				map.tail = e.before;
+			}
+
+			map.count--;
+			linkedhashmap_free_entry(map, e);
+			return true;
+		}
+		prev = e;
+		e = e.next;
+	}
+	return false;
+}
+
+fn void linkedhashmap_create_entry(LinkedHashMap* map, uint hash, Key key, Value value, int bucket_index) @private
+{
+	LinkedEntry *e = map.table[bucket_index];
+	$if COPY_KEYS:
+		key = key.copy(map.allocator);
+	$endif
+	LinkedEntry* entry = allocator::new(map.allocator, LinkedEntry, { .hash = hash, .key = key, .value = value, .next = map.table[bucket_index] });
+	map.table[bucket_index] = entry;
+	map.count++;
+}
+
+fn void linkedhashmap_free_entry(LinkedHashMap* self, LinkedEntry *entry) @local
+{
+	$if COPY_KEYS:
+		allocator::free(self.allocator, entry.key);
+	$endif
+	linkedhashmap_free_internal(self, entry);
+}
+
+
+struct LinkedHashMapIterator
+{
+	LinkedHashMap* map;
+	LinkedEntry* current;
+	bool started;
+}
+
+typedef LinkedHashMapValueIterator = inline LinkedHashMapIterator;
+typedef LinkedHashMapKeyIterator = inline LinkedHashMapIterator;
+
+fn usz LinkedHashMapValueIterator.len(self) @operator(len) => self.map.count;
+fn usz LinkedHashMapKeyIterator.len(self) @operator(len) => self.map.count;
+fn usz LinkedHashMapIterator.len(self) @operator(len) => self.map.count;
+
+int dummy @local;

lib/std/collections/linked_hashset.c3

@@ -0,0 +1,730 @@
+<*
+ @require $defined((Value){}.hash()) : `No .hash function found on the value`
+*>
+module std::collections::set <Value>;
+import std::math;
+import std::io @norecurse;
+
+const LinkedHashSet LINKEDONHEAP = { .allocator = SET_HEAP_ALLOCATOR };
+
+struct LinkedEntry
+{
+	uint hash;
+	Value value;
+	<* For bucket chain *>
+	LinkedEntry* next;
+	<* Previous in insertion order *>
+	LinkedEntry* before;
+	<* Next in insertion order *>
+	LinkedEntry* after;
+}
+
+struct LinkedHashSet (Printable)
+{
+	LinkedEntry*[] table;
+	Allocator allocator;
+	<* Number of elements *>
+	usz count;
+	<* Resize limit *>
+	usz threshold;
+	float load_factor;
+	<* Resize limit *>
+	LinkedEntry* head;
+	<* First inserted LinkedEntry *>
+	LinkedEntry* tail;
+}
+
+fn usz LinkedHashSet.len(&self) @operator(len) => self.count;
+
+<*
+ @param [&inout] allocator : "The allocator to use"
+ @require capacity > 0 : "The capacity must be 1 or higher"
+ @require load_factor > 0.0 : "The load factor must be higher than 0"
+ @require !self.is_initialized() : "Set was already initialized"
+ @require capacity < MAXIMUM_CAPACITY : "Capacity cannot exceed maximum"
+*>
+fn LinkedHashSet* LinkedHashSet.init(&self, Allocator allocator, usz capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
+{
+	capacity = math::next_power_of_2(capacity);
+	self.allocator = allocator;
+	self.threshold = (usz)(capacity * load_factor);
+	self.load_factor = load_factor;
+	self.table = allocator::new_array(allocator, LinkedEntry*, capacity);
+
+	self.head = null;
+	self.tail = null;
+	return self;
+}
+
+<*
+ @require capacity > 0 : "The capacity must be 1 or higher"
+ @require load_factor > 0.0 : "The load factor must be higher than 0"
+ @require !self.is_initialized() : "Set was already initialized"
+ @require capacity < MAXIMUM_CAPACITY : "Capacity cannot exceed maximum"
+*>
+fn LinkedHashSet* LinkedHashSet.tinit(&self, usz capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
+{
+	return self.init(tmem, capacity, load_factor) @inline;
+}
+
+<*
+ @param [&inout] allocator : "The allocator to use"
+ @require capacity > 0 : "The capacity must be 1 or higher"
+ @require load_factor > 0.0 : "The load factor must be higher than 0"
+ @require !self.is_initialized() : "Set was already initialized"
+ @require capacity < MAXIMUM_CAPACITY : "Capacity cannot exceed maximum"
+*>
+macro LinkedHashSet* LinkedHashSet.init_with_values(&self, Allocator allocator, ..., uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
+{
+	self.init(allocator, capacity, load_factor);
+	$for var $i = 0; $i < $vacount; $i++:
+		self.add($vaarg[$i]);
+	$endfor
+	return self;
+}
+
+<*
+ @require capacity > 0 : "The capacity must be 1 or higher"
+ @require load_factor > 0.0 : "The load factor must be higher than 0"
+ @require !self.is_initialized() : "Set was already initialized"
+ @require capacity < MAXIMUM_CAPACITY : "Capacity cannot exceed maximum"
+*>
+macro LinkedHashSet* LinkedHashSet.tinit_with_values(&self, ..., uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
+{
+	return self.init_with_values(tmem, $vasplat, capacity: capacity, load_factor: load_factor);
+}
+
+<*
+ @param [in] values : "The values for the LinkedHashSet"
+ @param [&inout] allocator : "The allocator to use"
+ @require capacity > 0 : "The capacity must be 1 or higher"
+ @require load_factor > 0.0 : "The load factor must be higher than 0"
+ @require !self.is_initialized() : "Set was already initialized"
+ @require capacity < MAXIMUM_CAPACITY : "Capacity cannot exceed maximum"
+*>
+fn LinkedHashSet* LinkedHashSet.init_from_values(&self, Allocator allocator, Value[] values, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
+{
+	self.init(allocator, capacity, load_factor);
+	foreach (v : values) self.add(v);
+	return self;
+}
+
+<*
+ @param [in] values : "The values for the LinkedHashSet entries"
+ @require capacity > 0 : "The capacity must be 1 or higher"
+ @require load_factor > 0.0 : "The load factor must be higher than 0"
+ @require !self.is_initialized() : "Set was already initialized"
+ @require capacity < MAXIMUM_CAPACITY : "Capacity cannot exceed maximum"
+*>
+fn LinkedHashSet* LinkedHashSet.tinit_from_values(&self, Value[] values, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
+{
+	return self.init_from_values(tmem, values, capacity, load_factor);
+}
+
+<*
+ Has this linked hash set been initialized yet?
+
+ @param [&in] set : "The linked hash set we are testing"
+ @return "Returns true if it has been initialized, false otherwise"
+*>
+fn bool LinkedHashSet.is_initialized(&set)
+{
+	return set.allocator && set.allocator.ptr != &dummy;
+}
+
+<*
+ @param [&inout] allocator : "The allocator to use"
+ @param [&in] other_set : "The set to copy from."
+ @require !self.is_initialized() : "Set was already initialized"
+*>
+fn LinkedHashSet* LinkedHashSet.init_from_set(&self, Allocator allocator, LinkedHashSet* other_set)
+{
+	self.init(allocator, other_set.table.len, other_set.load_factor);
+	LinkedEntry* entry = other_set.head;
+	while (entry) // Save insertion order
+	{
+		linkedhashset_put_for_create(self, entry.value);
+		entry = entry.after;
+	}
+	return self;
+}
+
+<*
+ @param [&in] other_set : "The set to copy from."
+ @require !set.is_initialized() : "Set was already initialized"
+*>
+fn LinkedHashSet* LinkedHashSet.tinit_from_set(&set, LinkedHashSet* other_set)
+{
+	return set.init_from_set(tmem, other_set) @inline;
+}
+
+<*
+ Check if the set is empty
+
+ @return "true if it is empty"
+ @pure
+*>
+fn bool LinkedHashSet.is_empty(&set) @inline
+{
+	return !set.count;
+}
+
+<*
+ Add all elements in the slice to the set.
+
+ @param [in] list
+ @return "The number of new elements added"
+ @ensure total <= list.len
+*>
+fn usz LinkedHashSet.add_all(&set, Value[] list)
+{
+	usz total;
+	foreach (v : list)
+	{
+		if (set.add(v)) total++;
+	}
+	return total;
+}
+
+<*
+ @param [&in] other
+ @return "The number of new elements added"
+ @ensure return <= other.count
+*>
+fn usz LinkedHashSet.add_all_from(&set, LinkedHashSet* other)
+{
+	usz total;
+	other.@each(;Value value)
+	{
+		if (set.add(value)) total++;
+	};
+	return total;
+}
+
+<*
+ @param value : "The value to add"
+ @return "true if the value didn't exist in the set"
+*>
+fn bool LinkedHashSet.add(&set, Value value)
+{
+	// If the set isn't initialized, use the defaults to initialize it.
+	switch (set.allocator.ptr)
+	{
+		case &dummy:
+			set.init(mem);
+		case null:
+			set.tinit();
+		default:
+			break;
+	}
+	uint hash = rehash(value.hash());
+	uint index = index_for(hash, set.table.len);
+	for (LinkedEntry *e = set.table[index]; e != null; e = e.next)
+	{
+		if (e.hash == hash && equals(value, e.value)) return false;
+	}
+	linkedhashset_add_entry(set, hash, value, index);
+	return true;
+}
+
+<*
+ Iterate over all the values in the set
+*>
+macro LinkedHashSet.@each(set; @body(value))
+{
+	if (!set.count) return;
+    LinkedEntry* entry = set.head;
+	while (entry)
+	{
+		@body(entry.value);
+		entry = entry.after;
+	}
+}
+
+<*
+ Check if the set contains the given value.
+
+ @param value : "The value to check"
+ @return "true if it exists in the set"
+*>
+fn bool LinkedHashSet.contains(&set, Value value)
+{
+	if (!set.count) return false;
+	uint hash = rehash(value.hash());
+	for (LinkedEntry *e = set.table[index_for(hash, set.table.len)]; e != null; e = e.next)
+	{
+		if (e.hash == hash && equals(value, e.value)) return true;
+	}
+	return false;
+}
+
+<*
+ Remove a single value from the set.
+
+ @param value : "The value to remove"
+ @return? NOT_FOUND : "If the entry is not found"
+*>
+fn void? LinkedHashSet.remove(&set, Value value) @maydiscard
+{
+	if (!linkedhashset_remove_entry_for_value(set, value)) return NOT_FOUND~;
+}
+
+fn usz LinkedHashSet.remove_all(&set, Value[] values)
+{
+	usz total;
+	foreach (v : values)
+	{
+		if (linkedhashset_remove_entry_for_value(set, v)) total++;
+	}
+	return total;
+}
+
+<*
+ @param [&in] other : "Other set"
+*>
+fn usz LinkedHashSet.remove_all_from(&set, LinkedHashSet* other)
+{
+	usz total;
+	other.@each(;Value val)
+    {
+		if (linkedhashset_remove_entry_for_value(set, val)) total++;
+    };
+    return total;
+}
+
+<*
+ Free all memory allocated by the hash set.
+*>
+fn void LinkedHashSet.free(&set)
+{
+	if (!set.is_initialized()) return;
+	set.clear();
+	linkedhashset_free_internal(set, set.table.ptr);
+	set.table = {};
+}
+
+<*
+ Clear all elements from the set while keeping the underlying storage
+
+ @ensure set.count == 0
+*>
+fn void LinkedHashSet.clear(&set)
+{
+	if (!set.count) return;
+
+	LinkedEntry* entry = set.head;
+	while (entry)
+	{
+		LinkedEntry* next = entry.after;
+		linkedhashset_free_entry(set, entry);
+		entry = next;
+	}
+
+	foreach (LinkedEntry** &bucket : set.table)
+	{
+		*bucket = null;
+	}
+
+	set.count = 0;
+	set.head = null;
+	set.tail = null;
+}
+
+fn void LinkedHashSet.reserve(&set, usz capacity)
+{
+	if (capacity > set.threshold)
+	{
+		linkedhashset_resize(set, math::next_power_of_2(capacity));
+	}
+}
+
+// --- Set Operations ---
+
+<*
+ Returns the union of two sets (A | B)
+
+ @param [&in] other : "The other set to union with"
+ @param [&inout] allocator : "Allocator for the new set"
+ @return "A new set containing the union of both sets"
+*>
+fn LinkedHashSet LinkedHashSet.set_union(&self, Allocator allocator, LinkedHashSet* other)
+{
+	usz new_capacity = math::next_power_of_2(self.count + other.count);
+	LinkedHashSet result;
+	result.init(allocator, new_capacity, self.load_factor);
+	result.add_all_from(self);
+	result.add_all_from(other);
+	return result;
+}
+
+fn LinkedHashSet LinkedHashSet.tset_union(&self, LinkedHashSet* other) => self.set_union(tmem, other) @inline;
+
+<*
+ Returns the intersection of the two sets (A & B)
+
+ @param [&in] other : "The other set to intersect with"
+ @param [&inout] allocator : "Allocator for the new set"
+ @return "A new set containing the intersection of both sets"
+*>
+fn LinkedHashSet LinkedHashSet.intersection(&self, Allocator allocator, LinkedHashSet* other)
+{
+	LinkedHashSet result;
+	result.init(allocator, math::min(self.table.len, other.table.len), self.load_factor);
+
+	// Iterate through the smaller set for efficiency
+	LinkedHashSet* smaller = self.count <= other.count ? self : other;
+	LinkedHashSet* larger = self.count > other.count ? self : other;
+
+	smaller.@each(;Value value)
+    {
+		if (larger.contains(value)) result.add(value);
+	};
+
+	return result;
+}
+
+fn LinkedHashSet LinkedHashSet.tintersection(&self, LinkedHashSet* other) => self.intersection(tmem, other) @inline;
+
+<*
+ Return this set - other, so (A & ~B)
+
+ @param [&in] other : "The other set to compare with"
+ @param [&inout] allocator : "Allocator for the new set"
+ @return "A new set containing elements in this set but not in the other"
+*>
+fn LinkedHashSet LinkedHashSet.difference(&self, Allocator allocator, LinkedHashSet* other)
+{
+	LinkedHashSet result;
+	result.init(allocator, self.table.len, self.load_factor);
+	self.@each(;Value value)
+	{
+		if (!other.contains(value))
+		{
+			result.add(value);
+		}
+	};
+	return result;
+}
+
+fn LinkedHashSet LinkedHashSet.tdifference(&self, LinkedHashSet* other) => self.difference(tmem, other) @inline;
+
+<*
+ Return (A ^ B)
+
+ @param [&in] other : "The other set to compare with"
+ @param [&inout] allocator : "Allocator for the new set"
+ @return "A new set containing elements in this set or the other, but not both"
+*>
+fn LinkedHashSet LinkedHashSet.symmetric_difference(&self, Allocator allocator, LinkedHashSet* other)
+{
+	LinkedHashSet result;
+	result.init(allocator, self.table.len, self.load_factor);
+	result.add_all_from(self);
+	other.@each(;Value value)
+	{
+		if (!result.add(value))
+		{
+			result.remove(value);
+		}
+	};
+	return result;
+}
+
+fn LinkedHashSet LinkedHashSet.tsymmetric_difference(&self, LinkedHashSet* other) => self.symmetric_difference(tmem, other) @inline;
+
+<*
+ Check if this hash set is a subset of another set.
+
+ @param [&in] other : "The other set to check against"
+ @return "True if all elements of this set are in the other set"
+*>
+fn bool LinkedHashSet.is_subset(&self, LinkedHashSet* other)
+{
+	if (self.count == 0) return true;
+	if (self.count > other.count) return false;
+
+	self.@each(; Value value) {
+		if (!other.contains(value)) return false;
+	};
+	return true;
+}
+
+// --- private methods
+
+fn void linkedhashset_add_entry(LinkedHashSet* set, uint hash, Value value, uint bucket_index) @private
+{
+	LinkedEntry* entry = allocator::new(set.allocator, LinkedEntry, {
+		.hash = hash,
+		.value = value,
+		.next = set.table[bucket_index],
+		.before = set.tail,
+		.after = null
+	});
+
+	// Update bucket chain
+	set.table[bucket_index] = entry;
+
+	// Update linked list
+	if (set.tail)
+	{
+		set.tail.after = entry;
+		entry.before = set.tail;
+	}
+	else
+	{
+		set.head = entry;
+	}
+	set.tail = entry;
+
+	if (set.count++ >= set.threshold)
+	{
+		linkedhashset_resize(set, set.table.len * 2);
+	}
+}
+
+fn void linkedhashset_resize(LinkedHashSet* set, usz new_capacity) @private
+{
+	LinkedEntry*[] old_table = set.table;
+	usz old_capacity = old_table.len;
+
+	if (old_capacity == MAXIMUM_CAPACITY)
+	{
+		set.threshold = uint.max;
+		return;
+	}
+
+	LinkedEntry*[] new_table = allocator::new_array(set.allocator, LinkedEntry*, new_capacity);
+	set.table = new_table;
+	set.threshold = (uint)(new_capacity * set.load_factor);
+
+	// Rehash all entries - linked list order remains unchanged
+	foreach (uint i, LinkedEntry *e : old_table)
+	{
+		if (!e) continue;
+
+		// Split the bucket chain into two chains based on new bit
+		LinkedEntry* lo_head = null;
+		LinkedEntry* lo_tail = null;
+		LinkedEntry* hi_head = null;
+		LinkedEntry* hi_tail = null;
+
+		do
+		{
+			LinkedEntry* next = e.next;
+			if ((e.hash & old_capacity) == 0)
+			{
+				if (!lo_tail)
+				{
+					lo_head = e;
+				}
+				else
+				{
+					lo_tail.next = e;
+				}
+				lo_tail = e;
+			}
+			else
+			{
+				if (!hi_tail)
+				{
+					hi_head = e;
+				}
+				else
+				{
+					hi_tail.next = e;
+				}
+				hi_tail = e;
+			}
+			e.next = null;
+			e = next;
+		}
+		while (e);
+
+		if (lo_tail)
+		{
+			lo_tail.next = null;
+			new_table[i] = lo_head;
+		}
+		if (hi_tail)
+		{
+			hi_tail.next = null;
+			new_table[i + old_capacity] = hi_head;
+		}
+	}
+
+	linkedhashset_free_internal(set, old_table.ptr);
+}
+
+fn usz? LinkedHashSet.to_format(&self, Formatter* f) @dynamic
+{
+	usz len;
+	len += f.print("{ ")!;
+	self.@each(; Value value)
+	{
+		if (len > 2) len += f.print(", ")!;
+		len += f.printf("%s", value)!;
+	};
+	return len + f.print(" }");
+}
+
+fn void linked_hashset_transfer(LinkedHashSet* set, LinkedEntry*[] new_table) @private
+{
+	LinkedEntry*[] src = set.table;
+	uint new_capacity = new_table.len;
+	foreach (uint j, LinkedEntry *e : src)
+	{
+		if (!e) continue;
+		do
+		{
+			LinkedEntry* next = e.next;
+			uint i = index_for(e.hash, new_capacity);
+			e.next = new_table[i];
+			new_table[i] = e;
+			e = next;
+		}
+		while (e);
+	}
+}
+
+fn void linkedhashset_put_for_create(LinkedHashSet* set, Value value) @private
+{
+	uint hash = rehash(value.hash());
+	uint i = index_for(hash, set.table.len);
+	for (LinkedEntry *e = set.table[i]; e != null; e = e.next)
+	{
+		if (e.hash == hash && equals(value, e.value))
+		{
+			// Value already exists, no need to do anything
+			return;
+		}
+	}
+	linkedhashset_create_entry(set, hash, value, i);
+}
+
+fn void linkedhashset_free_internal(LinkedHashSet* set, void* ptr) @inline @private
+{
+	allocator::free(set.allocator, ptr);
+}
+
+fn void linkedhashset_create_entry(LinkedHashSet* set, uint hash, Value value, int bucket_index) @private
+{
+	LinkedEntry* entry = allocator::new(set.allocator, LinkedEntry, {
+		.hash = hash,
+		.value = value,
+		.next = set.table[bucket_index],
+		.before = set.tail,
+		.after = null
+	});
+
+	set.table[bucket_index] = entry;
+
+	// Update linked list
+	if (set.tail)
+	{
+		set.tail.after = entry;
+		entry.before = set.tail;
+	}
+	else
+	{
+		set.head = entry;
+	}
+	set.tail = entry;
+
+	set.count++;
+}
+
+fn bool linkedhashset_remove_entry_for_value(LinkedHashSet* set, Value value) @private
+{
+	if (!set.count) return false;
+
+	uint hash = rehash(value.hash());
+	uint i = index_for(hash, set.table.len);
+	LinkedEntry* prev = null;
+	LinkedEntry* e = set.table[i];
+
+	while (e)
+	{
+		if (e.hash == hash && equals(value, e.value))
+		{
+			if (prev)
+			{
+				prev.next = e.next;
+			}
+			else
+			{
+				set.table[i] = e.next;
+			}
+
+			if (e.before)
+			{
+				e.before.after = e.after;
+			}
+			else
+			{
+				set.head = e.after;
+			}
+
+			if (e.after)
+			{
+				e.after.before = e.before;
+			}
+			else
+			{
+				set.tail = e.before;
+			}
+
+			set.count--;
+			linkedhashset_free_entry(set, e);
+			return true;
+		}
+		prev = e;
+		e = e.next;
+	}
+	return false;
+}
+
+fn void linkedhashset_free_entry(LinkedHashSet* set, LinkedEntry *entry) @private
+{
+	allocator::free(set.allocator, entry);
+}
+
+struct LinkedHashSetIterator
+{
+	LinkedHashSet* set;
+	LinkedEntry* current;
+	bool started;
+}
+
+fn LinkedHashSetIterator LinkedHashSet.iter(&set) => { .set = set, .current = set.head, .started = false };
+
+fn bool LinkedHashSetIterator.next(&self)
+{
+	if (!self.started)
+	{
+		self.current = self.set.head;
+		self.started = true;
+	}
+	else if (self.current)
+	{
+		self.current = self.current.after;
+	}
+	return self.current != null;
+}
+
+fn Value*? LinkedHashSetIterator.get(&self)
+{
+	return self.current ? &self.current.value : NOT_FOUND~;
+}
+
+fn bool LinkedHashSetIterator.has_next(&self)
+{
+	if (!self.started) return self.set.head != null;
+	return self.current && self.current.after != null;
+}
+
+fn usz LinkedHashSetIterator.len(&self) @operator(len)
+{
+    return self.set.count;
+}
+
+int dummy @local;

lib/std/collections/linkedlist.c3

@@ -0,0 +1,465 @@
+// Copyright (c) 2021-2024 Christoffer Lerno. All rights reserved.
+// Use of self source code is governed by the MIT license
+// a copy of which can be found in the LICENSE_STDLIB file.
+module std::collections::linkedlist <Type>;
+import std::io;
+
+const ELEMENT_IS_EQUATABLE = types::is_equatable_type(Type);
+
+struct Node
+{
+	Node* next;
+	Node* prev;
+	Type value;
+}
+
+struct LinkedList
+{
+	Allocator allocator;
+	usz size;
+	Node* _first;
+	Node* _last;
+}
+
+fn usz? LinkedList.to_format(&self, Formatter* f) @dynamic
+{
+	usz len = f.print("{ ")!;
+	for (Node* node = self._first; node != null; node = node.next)
+	{
+		len += f.printf(node.next ? "%s, " : "%s", node.value)!;
+	}
+	return len + f.print(" }");
+}
+
+macro LinkedList @new(Allocator allocator, Type[] #default_values = {})
+{
+	LinkedList new_list;
+	new_list.init(allocator);
+	new_list.push_all(#default_values);
+	return new_list;
+}
+
+macro LinkedList @tnew(Type[] #default_values = {})
+{
+	return @new(tmem, #default_values);
+}
+
+<*
+ @param [&inout] allocator : "The allocator to use, defaults to the heap allocator"
+ @return "the initialized list"
+*>
+fn LinkedList* LinkedList.init(&self, Allocator allocator)
+{
+	*self = { .allocator = allocator };
+	return self;
+}
+
+fn LinkedList* LinkedList.tinit(&self)
+{
+	return self.init(tmem) @inline;
+}
+
+fn bool LinkedList.is_initialized(&self) @inline => self.allocator != null;
+
+<*
+ @require self.is_initialized()
+*>
+macro void LinkedList.free_node(&self, Node* node) @private
+{
+	allocator::free(self.allocator, node);
+}
+
+macro Node* LinkedList.alloc_node(&self) @private
+{
+	if (!self.allocator) self.allocator = tmem;
+	return allocator::alloc(self.allocator, Node);
+}
+
+fn void LinkedList.push_front(&self, Type value)
+{
+	Node *first = self._first;
+	Node *new_node = self.alloc_node();
+	*new_node = { .next = first, .value = value };
+	self._first = new_node;
+	if (!first)
+	{
+		self._last = new_node;
+	}
+	else
+	{
+		first.prev = new_node;
+	}
+	self.size++;
+}
+
+fn void LinkedList.push_front_all(&self, Type[] value)
+{
+	foreach_r (v : value) self.push_front(v);
+}
+
+fn void LinkedList.push(&self, Type value)
+{
+	Node *last = self._last;
+	Node *new_node = self.alloc_node();
+	*new_node = { .prev = last, .value = value };
+	self._last = new_node;
+	if (!last)
+	{
+		self._first = new_node;
+	}
+	else
+	{
+		last.next = new_node;
+	}
+	self.size++;
+}
+
+fn void LinkedList.push_all(&self, Type[] value)
+{
+	foreach (v : value) self.push(v);
+}
+
+fn Type? LinkedList.peek(&self) => self.first() @inline;
+fn Type? LinkedList.peek_last(&self) => self.last() @inline;
+
+fn Type? LinkedList.first(&self)
+{
+	if (!self._first) return NO_MORE_ELEMENT~;
+	return self._first.value;
+}
+
+fn Type? LinkedList.last(&self)
+{
+	if (!self._last) return NO_MORE_ELEMENT~;
+	return self._last.value;
+}
+
+fn void LinkedList.free(&self) => self.clear() @inline;
+
+fn void LinkedList.clear(&self)
+{
+	for (Node* node = self._first; node != null;)
+	{
+		Node* next = node.next;
+		self.free_node(node);
+		node = next;
+	}
+	self._first = null;
+	self._last = null;
+	self.size = 0;
+}
+
+fn usz LinkedList.len(&self) @inline => self.size;
+
+<*
+ @require index < self.size
+*>
+macro Node* LinkedList.node_at_index(&self, usz index)
+{
+	if (index * 2 >= self.size)
+	{
+		Node* node = self._last;
+		index = self.size - index - 1;
+		while (index--) node = node.prev;
+		return node;
+	}
+	Node* node = self._first;
+	while (index--) node = node.next;
+	return node;
+}
+
+<*
+ @require index < self.size
+*>
+fn Type LinkedList.get(&self, usz index)
+{
+	return self.node_at_index(index).value;
+}
+
+<*
+ @require index < self.size
+*>
+fn Type* LinkedList.get_ref(&self, usz index)
+{
+	return &self.node_at_index(index).value;
+}
+
+<*
+ @require index < self.size
+*>
+fn void LinkedList.set(&self, usz index, Type element)
+{
+	self.node_at_index(index).value = element;
+}
+
+fn usz? LinkedList.index_of(&self, Type t) @if(ELEMENT_IS_EQUATABLE)
+{
+	for (Node* node = self._first, usz i = 0; node != null; node = node.next, ++i)
+	{
+		if (node.value == t) return i;
+	}
+	return NOT_FOUND~;
+}
+
+fn usz? LinkedList.rindex_of(&self, Type t) @if(ELEMENT_IS_EQUATABLE)
+{
+	for (Node* node = self._last, usz i = self.size - 1; node != null; node = node.prev, --i)
+	{
+		if (node.value == t) return i;
+		if (i == 0) break;
+	}
+	return NOT_FOUND~;
+}
+
+
+<*
+ @require index < self.size
+*>
+fn void LinkedList.remove_at(&self, usz index)
+{
+	linked_list_unlink(self, self.node_at_index(index));
+}
+
+<*
+ @require index <= self.size
+*>
+fn void LinkedList.insert_at(&self, usz index, Type element)
+{
+	switch (index)
+	{
+		case 0:
+			self.push_front(element);
+		case self.size:
+			self.push(element);
+		default:
+			linked_list_link_before(self, self.node_at_index(index), element);
+	}
+}
+<*
+ @require succ != null
+*>
+fn void linked_list_link_before(LinkedList* l, Node *succ, Type value) @private
+{
+	Node* pred = succ.prev;
+	Node* new_node = l.alloc_node();
+	*new_node = { .prev = pred, .next = succ, .value = value };
+	succ.prev = new_node;
+	if (!pred)
+	{
+		l._first = new_node;
+	}
+	else
+	{
+		pred.next = new_node;
+	}
+	l.size++;
+}
+
+<*
+ @require l._first != null
+*>
+fn void linked_list_unlink_first(LinkedList* l) @private
+{
+	Node* f = l._first;
+	Node* next = f.next;
+	l.free_node(f);
+	l._first = next;
+	if (!next)
+	{
+		l._last = null;
+	}
+	else
+	{
+		next.prev = null;
+	}
+	l.size--;
+}
+
+fn usz LinkedList.remove(&self, Type t) @if(ELEMENT_IS_EQUATABLE)
+{
+	usz start = self.size;
+	Node* node = self._first;
+	while (node)
+	{
+		switch
+		{
+			case equals(node.value, t):
+				Node* next = node.next;
+				linked_list_unlink(self, node);
+				node = next;
+			default:
+				node = node.next;
+		}
+	}
+	return start - self.size;
+}
+
+fn Type? LinkedList.pop(&self)
+{
+	if (!self._last) return NO_MORE_ELEMENT~;
+	defer linked_list_unlink_last(self);
+	return self._last.value;
+}
+
+fn bool LinkedList.is_empty(&self)
+{
+	return !self._first;
+}
+
+fn Type? LinkedList.pop_front(&self)
+{
+	if (!self._first) return NO_MORE_ELEMENT~;
+	defer linked_list_unlink_first(self);
+	return self._first.value;
+}
+
+fn void? LinkedList.remove_last(&self) @maydiscard
+{
+	if (!self._first) return NO_MORE_ELEMENT~;
+	linked_list_unlink_last(self);
+}
+
+fn void? LinkedList.remove_first(&self) @maydiscard
+{
+	if (!self._first) return NO_MORE_ELEMENT~;
+	linked_list_unlink_first(self);
+}
+
+
+fn bool LinkedList.remove_first_match(&self, Type t) @if(ELEMENT_IS_EQUATABLE)
+{
+	for (Node* node = self._first; node != null; node = node.next)
+	{
+		if (node.value == t)
+		{
+			linked_list_unlink(self, node);
+			return true;
+		}
+	}
+	return false;
+}
+
+fn bool LinkedList.remove_last_match(&self, Type t)  @if(ELEMENT_IS_EQUATABLE)
+{
+	for (Node* node = self._last; node != null; node = node.prev)
+	{
+		if (node.value == t)
+		{
+			linked_list_unlink(self, node);
+			return true;
+		}
+	}
+	return false;
+}
+<*
+ @require self._last != null
+*>
+fn void linked_list_unlink_last(LinkedList* self) @inline @private
+{
+	Node* l = self._last;
+	Node* prev = l.prev;
+	self._last = prev;
+	self.free_node(l);
+	if (!prev)
+	{
+		self._first = null;
+	}
+	else
+	{
+		prev.next = null;
+	}
+	self.size--;
+}
+
+<*
+ @require x != null
+*>
+fn void linked_list_unlink(LinkedList* self, Node* x) @private
+{
+	Node* next = x.next;
+	Node* prev = x.prev;
+	if (!prev)
+	{
+		self._first = next;
+	}
+	else
+	{
+		prev.next = next;
+	}
+	if (!next)
+	{
+		self._last = prev;
+	}
+	else
+	{
+		next.prev = prev;
+	}
+	self.free_node(x);
+	self.size--;
+}
+
+
+macro bool LinkedList.eq(&self, other) @operator(==) @if(ELEMENT_IS_EQUATABLE)
+{
+	Node* node1 = self._first;
+	Node* node2 = other._first;
+	while (true)
+	{
+		if (!node1) return node2 == null;
+		if (!node2) return false;
+		if (node1.value != node2.value) return false;
+		node1 = node1.next;
+		node2 = node2.next;
+	}
+	return true;
+}
+
+fn LinkedListArrayView LinkedList.array_view(&self)
+{
+	return { .list = self, .current_node = self._first };
+}
+
+
+struct LinkedListArrayView
+{
+	LinkedList* list;
+	Node* current_node;
+	usz current_index;
+}
+
+fn usz LinkedListArrayView.len(&self) @operator(len) => self.list.size;
+
+<*
+ @require index < self.list.size
+*>
+fn Type LinkedListArrayView.get(&self, usz index) @operator([])
+{
+	return *self.get_ref(index);
+}
+
+<*
+ @require index < self.list.size
+*>
+fn Type* LinkedListArrayView.get_ref(&self, usz index) @operator(&[])
+{
+	if (index == self.list.size - 1)
+	{
+		self.current_node = self.list._last;
+		self.current_index = index;
+	}
+
+	while (self.current_index != index)
+	{
+		switch
+		{
+			case index < self.current_index:   // reverse iteration
+				self.current_node = self.current_node.prev;
+				self.current_index--;
+			case index > self.current_index:
+				self.current_node = self.current_node.next;
+				self.current_index++;
+		}
+	}
+
+	return &self.current_node.value;
+}

lib/std/collections/list.c3

@@ -0,0 +1,574 @@
+// Copyright (c) 2021-2024 Christoffer Lerno. All rights reserved.
+// Use of self source code is governed by the MIT license
+// a copy of which can be found in the LICENSE_STDLIB file.
+module std::collections::list <Type>;
+import std::io, std::math, std::collections::list_common;
+
+alias ElementPredicate = fn bool(Type *type);
+alias ElementTest = fn bool(Type *type, any context);
+const ELEMENT_IS_EQUATABLE = types::is_equatable_type(Type);
+const ELEMENT_IS_POINTER = Type.kindof == POINTER;
+
+const Allocator LIST_HEAP_ALLOCATOR = (Allocator)&dummy;
+
+const List ONHEAP = { .allocator = LIST_HEAP_ALLOCATOR };
+
+macro bool type_is_overaligned() => Type.alignof > mem::DEFAULT_MEM_ALIGNMENT;
+
+struct List (Printable)
+{
+	usz size;
+	usz capacity;
+	Allocator allocator;
+	Type *entries;
+}
+
+<*
+ @param initial_capacity : "The initial capacity to reserve"
+ @param [&inout] allocator : "The allocator to use, defaults to the heap allocator"
+*>
+fn List* List.init(&self, Allocator allocator, usz initial_capacity = 16)
+{
+	self.allocator = allocator;
+	self.size = 0;
+	self.capacity = 0;
+	self.entries = null;
+	self.reserve(initial_capacity);
+	return self;
+}
+
+
+<*
+ Initialize the list using the temp allocator.
+
+ @param initial_capacity : "The initial capacity to reserve"
+*>
+fn List* List.tinit(&self, usz initial_capacity = 16)
+{
+	return self.init(tmem, initial_capacity) @inline;
+}
+
+<*
+ Initialize a new list with an array.
+
+ @param [in] values : `The values to initialize the list with.`
+ @require self.size == 0 : "The List must be empty"
+*>
+fn List* List.init_with_array(&self, Allocator allocator, Type[] values)
+{
+	self.init(allocator, values.len) @inline;
+	self.push_all(values) @inline;
+	return self;
+}
+
+<*
+ Initialize a temporary list with an array.
+
+ @param [in] values : `The values to initialize the list with.`
+ @require self.size == 0 : "The List must be empty"
+*>
+fn List* List.tinit_with_array(&self, Type[] values)
+{
+	self.tinit(values.len) @inline;
+	self.push_all(values) @inline;
+	return self;
+}
+
+<*
+ @require !self.is_initialized() : "The List must not be allocated"
+*>
+fn void List.init_wrapping_array(&self, Allocator allocator, Type[] types)
+{
+	self.allocator = allocator;
+	self.capacity = types.len;
+	self.entries = types.ptr;
+	list_set_size(self, types.len);
+}
+
+fn bool List.is_initialized(&self) @inline => self.allocator != null && self.allocator != (Allocator)&dummy;
+
+fn usz? List.to_format(&self, Formatter* formatter) @dynamic
+{
+	switch (self.size)
+	{
+		case 0:
+			return formatter.print("[]")!;
+		case 1:
+			return formatter.printf("[%s]", self.entries[0])!;
+		default:
+			usz n = formatter.print("[")!;
+			foreach (i, element : self.entries[:self.size])
+			{
+				if (i != 0) formatter.print(", ")!;
+				n += formatter.printf("%s", element)!;
+			}
+			n += formatter.print("]")!;
+			return n;
+	}
+}
+
+fn void List.push(&self, Type element) @inline
+{
+	self.reserve(1);
+	self.entries[list_set_size(self, self.size + 1)] = element;
+}
+
+fn Type? List.pop(&self)
+{
+	if (!self.size) return NO_MORE_ELEMENT~;
+	defer list_set_size(self, self.size - 1);
+	return self.entries[self.size - 1];
+}
+
+fn void List.clear(&self)
+{
+	list_set_size(self, 0);
+}
+
+fn Type? List.pop_first(&self)
+{
+	if (!self.size) return NO_MORE_ELEMENT~;
+	defer self.remove_at(0);
+	return self.entries[0];
+}
+
+<*
+ @require index < self.size : `Removed element out of bounds`
+*>
+fn void List.remove_at(&self, usz index)
+{
+	usz new_size = self.size - 1;
+	defer list_set_size(self, new_size);
+	if (!new_size || index == new_size) return;
+	self.entries[index .. new_size - 1] = self.entries[index + 1 .. new_size];
+}
+
+fn void List.add_all(&self, List* other_list)
+{
+	if (!other_list.size) return;
+	self.reserve(other_list.size);
+	usz index = list_set_size(self, self.size + other_list.size);
+	foreach (&value : other_list)
+	{
+		self.entries[index++] = *value;
+	}
+}
+
+
+<*
+ IMPORTANT The returned array must be freed using free_aligned.
+*>
+fn Type[] List.to_aligned_array(&self, Allocator allocator)
+{
+	return list_common::list_to_aligned_array(Type, self, allocator);
+}
+
+<*
+ @require !type_is_overaligned() : "This function is not available on overaligned types"
+*>
+macro Type[] List.to_array(&self, Allocator allocator)
+{
+	return list_common::list_to_array(Type, self, allocator);
+}
+
+fn Type[] List.to_tarray(&self)
+{
+	$if type_is_overaligned():
+	return self.to_aligned_array(tmem);
+	$else
+	return self.to_array(tmem);
+	$endif;
+}
+
+<*
+ Reverse the elements in a list.
+*>
+fn void List.reverse(&self)
+{
+	list_common::list_reverse(self);
+}
+
+fn Type[] List.array_view(&self)
+{
+	return self.entries[:self.size];
+}
+
+<*
+ Add the values of an array to this list.
+
+ @param [in] array
+ @ensure self.size >= array.len
+*>
+fn void List.add_array(&self, Type[] array) @deprecated("Use push_all")
+{
+	if (!array.len) return;
+	self.reserve(array.len);
+	usz index = list_set_size(self, self.size + array.len);
+	self.entries[index : array.len] = array[..];
+}
+
+<*
+ Add the values of an array to this list.
+
+ @param [in] array
+ @ensure self.size >= array.len
+*>
+fn void List.push_all(&self, Type[] array)
+{
+	if (!array.len) return;
+	self.reserve(array.len);
+	usz index = list_set_size(self, self.size + array.len);
+	self.entries[index : array.len] = array[..];
+}
+
+fn void List.push_front(&self, Type type) @inline
+{
+	self.insert_at(0, type);
+}
+
+<*
+ @require index <= self.size : `Insert was out of bounds`
+*>
+fn void List.insert_at(&self, usz index, Type type)
+{
+	self.reserve(1);
+	list_set_size(self, self.size + 1);
+	for (isz i = self.size - 1; i > index; i--)
+	{
+		self.entries[i] = self.entries[i - 1];
+	}
+	self.entries[index] = type;
+}
+
+<*
+ @require index < self.size
+*>
+fn void List.set_at(&self, usz index, Type type)
+{
+	self.entries[index] = type;
+}
+
+fn void? List.remove_last(&self) @maydiscard
+{
+	if (!self.size) return NO_MORE_ELEMENT~;
+	list_set_size(self, self.size - 1);
+}
+
+fn void? List.remove_first(&self) @maydiscard
+{
+	if (!self.size) return NO_MORE_ELEMENT~;
+	self.remove_at(0);
+}
+
+fn Type? List.first(&self)
+{
+	if (!self.size) return NO_MORE_ELEMENT~;
+	return self.entries[0];
+}
+
+fn Type? List.last(&self)
+{
+	if (!self.size) return NO_MORE_ELEMENT~;
+	return self.entries[self.size - 1];
+}
+
+fn bool List.is_empty(&self) @inline
+{
+	return !self.size;
+}
+
+fn usz List.byte_size(&self) @inline
+{
+	return Type.sizeof * self.size;
+}
+
+fn usz List.len(&self) @operator(len) @inline
+{
+	return self.size;
+}
+
+<*
+ @require index < self.size : `Access out of bounds`
+*>
+fn Type List.get(&self, usz index) @inline
+{
+	return self.entries[index];
+}
+
+fn void List.free(&self)
+{
+	if (!self.allocator || self.allocator.ptr == &dummy || !self.capacity) return;
+
+	list_pre_free(self); // Remove sanitizer annotation
+
+	$if type_is_overaligned():
+		allocator::free_aligned(self.allocator, self.entries);
+	$else
+		allocator::free(self.allocator, self.entries);
+	$endif;
+	self.capacity = 0;
+	self.size = 0;
+	self.entries = null;
+}
+
+<*
+ @require i < self.size && j < self.size : `Access out of bounds`
+*>
+fn void List.swap(&self, usz i, usz j)
+{
+	@swap(self.entries[i], self.entries[j]);
+}
+
+<*
+ @param filter : "The function to determine if it should be removed or not"
+ @return "the number of deleted elements"
+*>
+fn usz List.remove_if(&self, ElementPredicate filter)
+{
+	return list_common::list_remove_if(self, filter, false);
+}
+
+<*
+ @param selection : "The function to determine if it should be kept or not"
+ @return "the number of deleted elements"
+*>
+fn usz List.retain_if(&self, ElementPredicate selection)
+{
+	return list_common::list_remove_if(self, selection, true);
+}
+
+fn usz List.remove_using_test(&self, ElementTest filter, any context)
+{
+	usz old_size = self.size;
+	defer
+	{
+		if (old_size != self.size) self._update_size_change(old_size, self.size);
+	}
+	return list_common::list_remove_using_test(self, filter, false, context);
+}
+
+
+
+fn usz List.retain_using_test(&self, ElementTest filter, any context)
+{
+	usz old_size = self.size;
+	defer {
+		if (old_size != self.size) self._update_size_change(old_size, self.size);
+	}
+	return list_common::list_remove_using_test(self, filter, true, context);
+}
+
+fn void list_ensure_capacity(List* self, usz min_capacity) @local
+{
+	if (!min_capacity) return;
+	if (self.capacity >= min_capacity) return;
+
+	// Get a proper allocator
+	switch (self.allocator.ptr)
+	{
+		case &dummy:
+			self.allocator = mem;
+		case null:
+			self.allocator = tmem;
+		default:
+			break;
+	}
+
+	list_pre_free(self); // Remove sanitizer annotation
+
+	min_capacity = math::next_power_of_2(min_capacity);
+	$if type_is_overaligned():
+		self.entries = allocator::realloc_aligned(self.allocator, self.entries, Type.sizeof * min_capacity, alignment: Type[1].alignof)!!;
+	$else
+		self.entries = allocator::realloc(self.allocator, self.entries, Type.sizeof * min_capacity);
+	$endif;
+	self.capacity = min_capacity;
+
+	list_post_alloc(self); // Add sanitizer annotation
+}
+
+<*
+ @require index < self.size : `Access out of bounds`
+*>
+macro Type List.@item_at(&self, usz index) @operator([])
+{
+	return self.entries[index];
+}
+
+<*
+ @require index < self.size : `Access out of bounds`
+*>
+fn Type* List.get_ref(&self, usz index) @operator(&[]) @inline
+{
+	return &self.entries[index];
+}
+
+<*
+ @require index < self.size : `Access out of bounds`
+*>
+fn void List.set(&self, usz index, Type value) @operator([]=)
+{
+	self.entries[index] = value;
+}
+
+fn void List.reserve(&self, usz added)
+{
+	usz new_size = self.size + added;
+	if (self.capacity >= new_size) return;
+
+	assert(new_size < usz.max / 2U);
+	usz new_capacity = self.capacity ? 2U * self.capacity : 16U;
+	while (new_capacity < new_size) new_capacity *= 2U;
+	list_ensure_capacity(self, new_capacity);
+}
+
+fn void List._update_size_change(&self,usz old_size, usz new_size)
+{
+	if (old_size == new_size) return;
+	$if env::ADDRESS_SANITIZER:
+		if (self.allocator.ptr != &allocator::LIBC_ALLOCATOR) return;
+		sanitizer::annotate_contiguous_container(self.entries,
+	                                         &self.entries[self.capacity],
+	                                         &self.entries[old_size],
+	                                         &self.entries[new_size]);
+	$endif
+}
+<*
+ @require new_size == 0 || self.capacity != 0
+*>
+fn usz list_set_size(List* self, usz new_size) @inline @private
+{
+	usz old_size = self.size;
+	self._update_size_change(old_size, new_size);
+	self.size = new_size;
+	return old_size;
+}
+
+macro void list_pre_free(List* self) @private
+{
+	if (!self.capacity) return;
+	self._update_size_change(self.size, self.capacity);
+}
+
+<*
+ @require self.capacity > 0
+*>
+macro void list_post_alloc(List* self) @private
+{
+	self._update_size_change(self.capacity, self.size);
+}
+
+// Functions for equatable types
+
+
+fn usz? List.index_of(&self, Type type) @if (ELEMENT_IS_EQUATABLE)
+{
+	foreach (i, v : self)
+	{
+		if (equals(v, type)) return i;
+	}
+	return NOT_FOUND~;
+}
+
+fn usz? List.rindex_of(&self, Type type) @if (ELEMENT_IS_EQUATABLE)
+{
+	foreach_r (i, v : self)
+	{
+		if (equals(v, type)) return i;
+	}
+	return NOT_FOUND~;
+}
+
+fn bool List.equals(&self, List other_list) @if(ELEMENT_IS_EQUATABLE)
+{
+	if (self.size != other_list.size) return false;
+	foreach (i, v : self)
+	{
+		if (!equals(v, other_list.entries[i])) return false;
+	}
+	return true;
+}
+
+<*
+ Check for presence of a value in a list.
+
+ @param [&in] self : "the list to find elements in"
+ @param value : "The value to search for"
+ @return "True if the value is found, false otherwise"
+*>
+fn bool List.contains(&self, Type value) @if(ELEMENT_IS_EQUATABLE)
+{
+	foreach (i, v : self)
+	{
+		if (equals(v, value)) return true;
+	}
+	return false;
+}
+
+<*
+ @param [&inout] self : "The list to remove elements from"
+ @param value : "The value to remove"
+ @return "true if the value was found"
+*>
+fn bool List.remove_last_item(&self, Type value) @if(ELEMENT_IS_EQUATABLE)
+{
+	return @ok(self.remove_at(self.rindex_of(value)));
+}
+
+<*
+ @param [&inout] self : "The list to remove elements from"
+ @param value : "The value to remove"
+ @return "true if the value was found"
+*>
+fn bool List.remove_first_item(&self, Type value) @if(ELEMENT_IS_EQUATABLE)
+{
+	return @ok(self.remove_at(self.index_of(value)));
+}
+<*
+ @param [&inout] self : "The list to remove elements from"
+ @param value : "The value to remove"
+ @return "the number of deleted elements."
+*>
+fn usz List.remove_item(&self, Type value) @if(ELEMENT_IS_EQUATABLE)
+{
+	usz old_size = self.size;
+	defer
+	{
+		if (old_size != self.size) self._update_size_change(old_size, self.size);
+	}
+	return list_common::list_remove_item(self, value);
+}
+
+
+
+fn void List.remove_all_from(&self, List* other_list) @if(ELEMENT_IS_EQUATABLE)
+{
+	if (!other_list.size) return;
+	usz old_size = self.size;
+	defer {
+		if (old_size != self.size) self._update_size_change(old_size, self.size);
+	}
+	foreach (v : other_list) self.remove_item(v);
+}
+
+<*
+ @param [&in] self
+ @return "The number non-null values in the list"
+*>
+fn usz List.compact_count(&self) @if(ELEMENT_IS_POINTER)
+{
+	usz vals = 0;
+	foreach (v : self) if (v) vals++;
+	return vals;
+}
+
+fn usz List.compact(&self) @if(ELEMENT_IS_POINTER)
+{
+	usz old_size = self.size;
+	defer {
+		if (old_size != self.size) self._update_size_change(old_size, self.size);
+	}
+	return list_common::list_compact(self);
+}
+
+int dummy @local;

lib/std/collections/list_common.c3

@@ -0,0 +1,112 @@
+module std::collections::list_common;
+
+<*
+ IMPORTANT The returned array must be freed using free_aligned.
+*>
+macro list_to_aligned_array($Type, self, Allocator allocator)
+{
+	if (!self.size) return ($Type[]){};
+	$Type[] result = allocator::alloc_array_aligned(allocator, $Type, self.size);
+	result[..] = self.entries[:self.size];
+	return result;
+}
+
+macro list_to_array($Type, self, Allocator allocator)
+{
+	if (!self.size) return ($Type[]){};
+	$Type[] result = allocator::alloc_array(allocator, $Type, self.size);
+	result[..] = self.entries[:self.size];
+	return result;
+}
+
+macro void list_reverse(self)
+{
+	if (self.size < 2) return;
+	usz half = self.size / 2U;
+	usz end = self.size - 1;
+	for (usz i = 0; i < half; i++)
+	{
+		@swap(self.entries[i], self.entries[end - i]);
+	}
+}
+
+macro usz list_remove_using_test(self, filter, bool $invert, ctx)
+{
+	usz size = self.size;
+	for (usz i = size, usz k = size; k > 0; k = i)
+	{
+		// Find last index of item to be deleted.
+		$if $invert:
+			while (i > 0 && !filter(&self.entries[i - 1], ctx)) i--;
+		$else
+			while (i > 0 && filter(&self.entries[i - 1], ctx)) i--;
+		$endif
+		// Remove the items from this index up to the one not to be deleted.
+		usz n = self.size - k;
+		self.entries[i:n] = self.entries[k:n];
+		self.size -= k - i;
+		// Find last index of item not to be deleted.
+		$if $invert:
+			while (i > 0 && filter(&self.entries[i - 1], ctx)) i--;
+		$else
+			while (i > 0 && !filter(&self.entries[i - 1], ctx)) i--;
+		$endif
+	}
+	return size - self.size;
+}
+
+macro usz list_compact(self)
+{
+	usz size = self.size;
+	for (usz i = size; i > 0; i--)
+	{
+		if (self.entries[i - 1]) continue;
+		for (usz j = i; j < size; j++)
+		{
+			self.entries[j - 1] = self.entries[j];
+		}
+		self.size--;
+	}
+	return size - self.size;
+}
+
+macro usz list_remove_item(self, value)
+{
+	usz size = self.size;
+	for (usz i = size; i > 0; i--)
+	{
+		if (!equals(self.entries[i - 1], value)) continue;
+		for (usz j = i; j < self.size; j++)
+		{
+			self.entries[j - 1] = self.entries[j];
+		}
+		self.size--;
+	}
+	return size - self.size;
+}
+
+
+macro usz list_remove_if(self, filter, bool $invert)
+{
+	usz size = self.size;
+	for (usz i = size, usz k = size; k > 0; k = i)
+	{
+		// Find last index of item to be deleted.
+		$if $invert:
+			while (i > 0 && !filter(&self.entries[i - 1])) i--;
+		$else
+			while (i > 0 && filter(&self.entries[i - 1])) i--;
+		$endif
+		// Remove the items from this index up to the one not to be deleted.
+		usz n = self.size - k;
+		self.entries[i:n] = self.entries[k:n];
+		self.size -= k - i;
+		// Find last index of item not to be deleted.
+		$if $invert:
+			while (i > 0 && filter(&self.entries[i - 1])) i--;
+		$else
+			while (i > 0 && !filter(&self.entries[i - 1])) i--;
+		$endif
+	}
+	return size - self.size;
+}

lib/std/collections/maybe.c3

@@ -0,0 +1,45 @@
+module std::collections::maybe <Type>;
+import std::io;
+
+struct Maybe (Printable)
+{
+	Type value;
+	bool has_value;
+}
+
+fn usz? Maybe.to_format(&self, Formatter* f) @dynamic
+{
+	if (self.has_value) return f.printf("[%s]", self.value);
+	return f.printf("[EMPTY]");
+}
+
+fn void Maybe.set(&self, Type val)
+{
+	*self = { .value = val, .has_value = true };
+}
+
+fn void Maybe.reset(&self)
+{
+	*self = {};
+}
+
+fn Maybe value(Type val)
+{
+	return { .value = val, .has_value = true };
+}
+
+const Maybe EMPTY = { };
+
+macro Type? Maybe.get(self)
+{
+	return self.has_value ? self.value : NOT_FOUND~;
+}
+
+fn bool Maybe.equals(self, Maybe other) @operator(==) @if(types::is_equatable_type(Type))
+{
+	if (self.has_value)
+	{
+		return other.has_value && equals(self.value, other.value);
+	}
+	return !other.has_value;
+}

lib/std/collections/object.c3

@@ -0,0 +1,467 @@
+// Copyright (c) 2023 Christoffer Lerno. All rights reserved.
+// Use of this source code is governed by the MIT license
+// a copy of which can be found in the LICENSE_STDLIB file.
+module std::collections::object;
+import std::collections::map, std::collections::list, std::io;
+
+const Object TRUE_OBJECT = { .b = true, .type = bool.typeid };
+const Object FALSE_OBJECT = { .b = false, .type = bool.typeid };
+const Object NULL_OBJECT = { .type = void*.typeid };
+
+struct Object (Printable)
+{
+	typeid type;
+	Allocator allocator;
+	union
+	{
+		uint128 i;
+		double f;
+		bool b;
+		String s;
+		void* other;
+		ObjectInternalList array;
+		ObjectInternalMap map;
+	}
+}
+
+
+fn usz? Object.to_format(&self, Formatter* formatter) @dynamic
+{
+	switch (self.type)
+	{
+		case void:
+			return formatter.printf("{}")!;
+		case void*:
+			return formatter.printf("null")!;
+		case String:
+			return formatter.printf(`"%s"`, self.s)!;
+		case bool:
+			return formatter.printf(self.b ? "true" : "false")!;
+		case ObjectInternalList:
+			usz n = formatter.printf("[")!;
+			foreach (i, ol : self.array)
+			{
+				if (i > 0) n += formatter.printf(",")!;
+				n += ol.to_format(formatter)!;
+			}
+			n += formatter.printf("]")!;
+			return n;
+		case ObjectInternalMap:
+			usz n = formatter.printf("{")!;
+			@stack_mem(1024; Allocator mem)
+			{
+				foreach (i, key : self.map.keys(mem))
+				{
+					if (i > 0) n += formatter.printf(",")!;
+					n += formatter.printf(`"%s":`, key)!;
+					n += self.map.get(key).to_format(formatter)!;
+				}
+			};
+			n += formatter.printf("}")!;
+			return n;
+		default:
+			switch (self.type.kindof)
+			{
+				case SIGNED_INT:
+					return formatter.printf("%d", (int128)self.i)!;
+				case UNSIGNED_INT:
+					return formatter.printf("%d", (uint128)self.i)!;
+				case FLOAT:
+					return formatter.printf("%g", self.f)!;
+				case ENUM:
+					return formatter.printf("%d", self.i)!;
+				default:
+					return formatter.printf("<>")!;
+			}
+	}
+}
+
+fn Object* new_obj(Allocator allocator)
+{
+	return allocator::new(allocator, Object, { .allocator = allocator, .type = void.typeid });
+}
+
+fn Object* new_null()
+{
+	return &NULL_OBJECT;
+}
+
+fn Object* new_int(int128 i, Allocator allocator)
+{
+	return allocator::new(allocator, Object, { .i = i, .allocator = allocator, .type = int128.typeid });
+}
+
+macro Object* new_enum(e, Allocator allocator)
+{
+	return allocator::new(allocator, Object, { .i = (int128)e, .allocator = allocator, .type = @typeid(e) });
+}
+
+fn Object* new_float(double f, Allocator allocator)
+{
+	return allocator::new(allocator, Object, { .f = f, .allocator = allocator, .type = double.typeid });
+}
+
+fn Object* new_string(String s, Allocator allocator)
+{
+	return allocator::new(allocator, Object, { .s = s.copy(allocator), .allocator = allocator, .type = String.typeid });
+}
+
+
+fn Object* new_bool(bool b)
+{
+	return b ? &TRUE_OBJECT : &FALSE_OBJECT;
+}
+
+fn void Object.free(&self)
+{
+	switch (self.type)
+	{
+		case void:
+			break;
+		case String:
+			allocator::free(self.allocator, self.s);
+		case ObjectInternalList:
+			foreach (ol : self.array)
+			{
+				ol.free();
+			}
+			self.array.free();
+		case ObjectInternalMap:
+			self.map.@each_entry(; ObjectInternalMapEntry* entry) {
+				entry.value.free();
+			};
+			self.map.free();
+		default:
+			break;
+	}
+	if (self.allocator) allocator::free(self.allocator, self);
+}
+
+fn bool Object.is_null(&self) @inline => self == &NULL_OBJECT;
+fn bool Object.is_empty(&self) @inline => self.type == void.typeid;
+fn bool Object.is_map(&self) @inline => self.type == ObjectInternalMap.typeid;
+fn bool Object.is_array(&self) @inline => self.type == ObjectInternalList.typeid;
+fn bool Object.is_bool(&self) @inline => self.type == bool.typeid;
+fn bool Object.is_string(&self) @inline => self.type == String.typeid;
+fn bool Object.is_float(&self) @inline => self.type == double.typeid;
+fn bool Object.is_int(&self) @inline => self.type == int128.typeid;
+fn bool Object.is_keyable(&self) => self.is_empty() || self.is_map();
+fn bool Object.is_indexable(&self) => self.is_empty() || self.is_array();
+
+<*
+ @require self.is_keyable()
+*>
+fn void object_init_map_if_needed(Object* self) @private
+{
+	if (self.is_empty())
+	{
+		self.type = ObjectInternalMap.typeid;
+		self.map.init(self.allocator);
+	}
+}
+
+<*
+ @require self.is_indexable()
+*>
+fn void object_init_array_if_needed(Object* self) @private
+{
+	if (self.is_empty())
+	{
+		self.type = ObjectInternalList.typeid;
+		self.array.init(self.allocator);
+	}
+}
+
+<*
+ @require self.is_keyable()
+*>
+fn void object_set_object(Object* self, String key, Object* new_object) @private
+{
+	object_init_map_if_needed(self);
+	Object*? val = self.map.get_entry(key).value;
+	defer (void)val.free();
+	self.map.set(key, new_object);
+}
+
+<*
+ @require self.allocator != null : "This object is not properly initialized, was it really created using 'new'"
+ @require $typeof(value) != void* ||| value == null : "void pointers cannot be stored in an object"
+*>
+macro Object* Object.object_from_value(&self, value) @private
+{
+	var $Type = $typeof(value);
+	$switch:
+		$case types::is_int($Type):
+			return new_int(value, self.allocator);
+		$case types::is_float($Type):
+			return new_float(value, self.allocator);
+		$case $Type.typeid == String.typeid:
+			return new_string(value, self.allocator);
+		$case $Type.typeid == bool.typeid:
+			return new_bool(value);
+		$case $Type.typeid == Object*.typeid:
+			return value;
+		$case $Type.typeid == void*.typeid:
+			return &NULL_OBJECT;
+		$case $defined(String x = value):
+			return new_string(value, self.allocator);
+		$default:
+			$error "Unsupported object type.";
+	$endswitch
+
+}
+
+macro Object* Object.set(&self, String key, value)
+{
+	Object* val = self.object_from_value(value);
+	object_set_object(self, key, val);
+	return val;
+}
+
+<*
+ @require self.is_indexable()
+*>
+macro Object* Object.set_at(&self, usz index, String key, value)
+{
+	Object* val = self.object_from_value(value);
+	self.set_object_at(key, index, val);
+	return val;
+}
+
+<*
+ @require self.is_indexable()
+ @ensure return != null
+*>
+macro Object* Object.push(&self, value)
+{
+	Object* val = self.object_from_value(value);
+	self.push_object(val);
+	return val;
+}
+
+<*
+ @require self.is_keyable()
+*>
+fn Object*? Object.get(&self, String key) => self.is_empty() ? NOT_FOUND~ : self.map.get(key);
+
+fn bool Object.has_key(&self, String key) => self.is_map() && self.map.has_key(key);
+
+<*
+ @require self.is_indexable()
+*>
+fn Object* Object.get_at(&self, usz index)
+{
+	return self.array.get(index);
+}
+
+<*
+ @require self.is_indexable()
+*>
+fn usz Object.get_len(&self)
+{
+	return self.array.len();
+}
+
+<*
+ @require self.is_indexable()
+*>
+fn void Object.push_object(&self, Object* to_append)
+{
+	object_init_array_if_needed(self);
+	self.array.push(to_append);
+}
+
+<*
+ @require self.is_indexable()
+*>
+fn void Object.set_object_at(&self, usz index, Object* to_set)
+{
+	object_init_array_if_needed(self);
+	while (self.array.len() < index)
+	{
+		self.array.push(&NULL_OBJECT);
+	}
+	if (self.array.len() == index)
+	{
+		self.array.push(to_set);
+		return;
+	}
+	self.array.get(index).free();
+	self.array.set_at(index, to_set);
+}
+
+<*
+ @require $Type.kindof.is_int() : "Expected an integer type."
+*>
+macro get_integer_value(Object* value, $Type)
+{
+	if (value.is_float())
+	{
+		return ($Type)value.f;
+	}
+	if (value.is_string())
+	{
+		$if $Type.kindof == TypeKind.SIGNED_INT:
+			return ($Type)value.s.to_int128();
+		$else
+			return ($Type)value.s.to_uint128();
+		$endif
+	}
+	if (!value.is_int()) return string::MALFORMED_INTEGER~;
+	return ($Type)value.i;
+}
+
+
+<*
+ @require self.is_indexable()
+ @require $Type.kindof.is_int() : "Expected an integer type"
+*>
+macro Object.get_integer_at(&self, $Type, usz index) @private
+{
+	return get_integer_value(self.get_at(index), $Type);
+}
+
+<*
+ @require self.is_keyable()
+ @require $Type.kindof.is_int() : "Expected an integer type"
+*>
+macro Object.get_integer(&self, $Type, String key) @private
+{
+	return get_integer_value(self.get(key), $Type);
+}
+
+fn ichar? Object.get_ichar(&self, String key) => self.get_integer(ichar, key);
+fn short? Object.get_short(&self, String key) => self.get_integer(short, key);
+fn int? Object.get_int(&self, String key) => self.get_integer(int, key);
+fn long? Object.get_long(&self, String key) => self.get_integer(long, key);
+fn int128? Object.get_int128(&self, String key) => self.get_integer(int128, key);
+
+fn ichar? Object.get_ichar_at(&self, usz index) => self.get_integer_at(ichar, index);
+fn short? Object.get_short_at(&self, usz index) => self.get_integer_at(short, index);
+fn int? Object.get_int_at(&self, usz index) => self.get_integer_at(int, index);
+fn long? Object.get_long_at(&self, usz index) => self.get_integer_at(long, index);
+fn int128? Object.get_int128_at(&self, usz index) => self.get_integer_at(int128, index);
+
+fn char? Object.get_char(&self, String key) => self.get_integer(ichar, key);
+fn short? Object.get_ushort(&self, String key) => self.get_integer(ushort, key);
+fn uint? Object.get_uint(&self, String key) => self.get_integer(uint, key);
+fn ulong? Object.get_ulong(&self, String key) => self.get_integer(ulong, key);
+fn uint128? Object.get_uint128(&self, String key) => self.get_integer(uint128, key);
+
+fn char? Object.get_char_at(&self, usz index) => self.get_integer_at(char, index);
+fn ushort? Object.get_ushort_at(&self, usz index) => self.get_integer_at(ushort, index);
+fn uint? Object.get_uint_at(&self, usz index) => self.get_integer_at(uint, index);
+fn ulong? Object.get_ulong_at(&self, usz index) => self.get_integer_at(ulong, index);
+fn uint128? Object.get_uint128_at(&self, usz index) => self.get_integer_at(uint128, index);
+
+<*
+ @require self.is_keyable()
+*>
+fn String? Object.get_string(&self, String key)
+{
+	Object* value = self.get(key)!;
+	if (!value.is_string()) return TYPE_MISMATCH~;
+	return value.s;
+}
+
+<*
+ @require self.is_indexable()
+*>
+fn String? Object.get_string_at(&self, usz index)
+{
+	Object* value = self.get_at(index);
+	if (!value.is_string()) return TYPE_MISMATCH~;
+	return value.s;
+}
+
+<*
+ @require self.is_keyable()
+*>
+macro String? Object.get_enum(&self, $EnumType, String key)
+{
+	Object value = self.get(key)!;
+	if ($EnumType.typeid != value.type) return TYPE_MISMATCH~;
+	return ($EnumType)value.i;
+}
+
+<*
+ @require self.is_indexable()
+*>
+macro String? Object.get_enum_at(&self, $EnumType, usz index)
+{
+	Object value = self.get_at(index);
+	if ($EnumType.typeid != value.type) return TYPE_MISMATCH~;
+	return ($EnumType)value.i;
+}
+
+<*
+ @require self.is_keyable()
+*>
+fn bool? Object.get_bool(&self, String key)
+{
+	Object* value = self.get(key)!;
+	if (!value.is_bool()) return TYPE_MISMATCH~;
+	return value.b;
+}
+
+
+<*
+ @require self.is_indexable()
+*>
+fn bool? Object.get_bool_at(&self, usz index)
+{
+	Object* value = self.get_at(index);
+	if (!value.is_bool()) return TYPE_MISMATCH~;
+	return value.b;
+}
+
+<*
+ @require self.is_keyable()
+*>
+fn double? Object.get_float(&self, String key)
+{
+	Object* value = self.get(key)!;
+	switch (value.type.kindof)
+	{
+		case SIGNED_INT:
+			return (double)value.i;
+		case UNSIGNED_INT:
+			return (double)(uint128)value.i;
+		case FLOAT:
+			return value.f;
+		default:
+			return TYPE_MISMATCH~;
+	}
+}
+
+<*
+ @require self.is_indexable()
+*>
+fn double? Object.get_float_at(&self, usz index)
+{
+	Object* value = self.get_at(index);
+	switch (value.type.kindof)
+	{
+		case SIGNED_INT:
+			return (double)value.i;
+		case UNSIGNED_INT:
+			return (double)(uint128)value.i;
+		case FLOAT:
+			return value.f;
+		default:
+			return TYPE_MISMATCH~;
+	}
+}
+
+fn Object* Object.get_or_create_obj(&self, String key)
+{
+	if (try obj = self.get(key) && !obj.is_null()) return obj;
+	Object* container = new_obj(self.allocator);
+	self.set(key, container);
+	return container;
+}
+
+alias ObjectInternalMap      @private = HashMap {String, Object*};
+alias ObjectInternalList     @private = List {Object*};
+alias ObjectInternalMapEntry @private = Entry {String, Object*};
+

lib/std/collections/priorityqueue.c3

@@ -0,0 +1,152 @@
+//  priorityqueue.c3
+//  A priority queue using a classic binary heap for C3.
+//
+//  Copyright (c) 2022-2025 David Kopec
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in all
+//  copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//  SOFTWARE.
+module std::collections::priorityqueue;
+import std::collections::list, std::io;
+
+typedef PriorityQueue <Type> = inline PrivatePriorityQueue{Type, false};
+typedef PriorityQueueMax <Type> = inline PrivatePriorityQueue{Type, true};
+
+struct PrivatePriorityQueue (Printable) <Type, MAX>
+{
+	List{Type} heap;
+}
+
+fn PrivatePriorityQueue* PrivatePriorityQueue.init(&self, Allocator allocator, usz initial_capacity = 16, ) @inline
+{
+	self.heap.init(allocator, initial_capacity);
+	return self;
+}
+
+fn PrivatePriorityQueue* PrivatePriorityQueue.tinit(&self, usz initial_capacity = 16) @inline
+{
+	self.init(tmem, initial_capacity);
+	return self;
+}
+
+
+fn void PrivatePriorityQueue.push(&self, Type element)
+{
+	self.heap.push(element);
+	usz i = self.heap.len() - 1;
+	while (i > 0)
+	{
+		usz parent = (i - 1) / 2;
+		Type item = self.heap[i];
+		Type parent_item = self.heap[parent];
+		$if MAX:
+			bool ok = greater(item, parent_item);
+		$else
+			bool ok = less(item, parent_item);
+		$endif
+		if (!ok) break;
+		self.heap.swap(i, parent);
+		i = parent;
+	}
+}
+
+<*
+ @require index < self.len() : "Index out of range"
+*>
+fn void PrivatePriorityQueue.remove_at(&self, usz index)
+{
+	if (index == 0)
+	{
+		self.pop()!!;
+		return;
+	}
+	self.heap.remove_at(index);
+}
+<*
+ @require self != null
+*>
+fn Type? PrivatePriorityQueue.pop(&self)
+{
+	usz i = 0;
+	usz len = self.heap.len();
+	if (!len) return NO_MORE_ELEMENT~;
+	usz new_count = len - 1;
+	self.heap.swap(0, new_count);
+	while OUTER: ((2 * i + 1) < new_count)
+	{
+		usz j = 2 * i + 1;
+		Type left = self.heap[j];
+		Type item = self.heap[i];
+		switch
+		{
+			case j + 1 < new_count:
+				Type right = self.heap[j + 1];
+				$if MAX:
+				if (!greater(right, left)) nextcase;
+				if (!greater(right, item)) break OUTER;
+				$else
+				if (!greater(left, right)) nextcase;
+				if (!greater(item, right)) break OUTER;
+				$endif
+				j++;
+			default:
+				$if MAX:
+				if (!greater(left, item)) break OUTER;
+				$else
+				if (!greater(item, left)) break OUTER;
+				$endif
+		}
+		self.heap.swap(i, j);
+		i = j;
+	}
+
+	return self.heap.pop();
+}
+
+fn Type? PrivatePriorityQueue.first(&self)
+{
+	return self.heap.first();
+}
+
+fn void PrivatePriorityQueue.free(&self)
+{
+	self.heap.free();
+}
+
+fn usz PrivatePriorityQueue.len(&self) @operator(len)
+{
+	return self.heap.len() @inline;
+}
+
+fn bool PrivatePriorityQueue.is_empty(&self)
+{
+	return self.heap.is_empty() @inline;
+}
+
+<*
+ @require index < self.len()
+*>
+fn Type PrivatePriorityQueue.get(&self, usz index) @operator([])
+{
+	return self.heap[index];
+}
+
+fn usz? PrivatePriorityQueue.to_format(&self, Formatter* formatter) @dynamic
+{
+	return self.heap.to_format(formatter);
+}
+

lib/std/collections/range.c3

@@ -0,0 +1,65 @@
+<*
+ @require Type.is_ordered : "The type must be ordered"
+*>
+module std::collections::range <Type>;
+import std::io;
+
+struct Range (Printable)
+{
+	Type start;
+	Type end;
+}
+
+fn usz Range.len(&self) @operator(len)
+{
+	if (self.end < self.start) return 0;
+	return (usz)(self.end - self.start) + 1;
+}
+
+fn bool Range.contains(&self, Type value) @inline
+{
+	return value >= self.start && value <= self.end;
+}
+
+<*
+ @require index < self.len() : "Can't index into an empty range"
+*>
+fn Type Range.get(&self, usz index) @operator([])
+{
+	return (Type)(self.start + (usz)index);
+}
+
+fn usz? Range.to_format(&self, Formatter* formatter) @dynamic
+{
+	return formatter.printf("[%s..%s]", self.start, self.end)!;
+}
+
+struct ExclusiveRange (Printable)
+{
+	Type start;
+	Type end;
+}
+
+fn usz ExclusiveRange.len(&self) @operator(len)
+{
+	if (self.end < self.start) return 0;
+	return (usz)(self.end - self.start);
+}
+
+fn bool ExclusiveRange.contains(&self, Type value) @inline
+{
+	return value >= self.start && value < self.end;
+}
+
+fn usz? ExclusiveRange.to_format(&self, Formatter* formatter) @dynamic
+{
+	return formatter.printf("[%s..<%s]", self.start, self.end)!;
+}
+
+<*
+ @require index < self.len() : "Can't index into an empty range"
+*>
+fn Type ExclusiveRange.get(&self, usz index) @operator([])
+{
+	return (Type)(self.start + index);
+}

lib/std/collections/ringbuffer.c3

@@ -0,0 +1,115 @@
+<*
+ @require Type.kindof == ARRAY : "Required an array type"
+*>
+module std::collections::ringbuffer <Type>;
+import std::io;
+
+alias Element = $typeof((Type){}[0]);
+
+struct RingBuffer (Printable)
+{
+	Type buf;
+	usz written;
+	usz head;
+}
+
+fn void RingBuffer.init(&self) @inline
+{
+	*self = {};
+}
+
+fn void RingBuffer.push(&self, Element c)
+{
+	if (self.written < self.buf.len)
+	{
+		self.buf[self.written] = c;
+		self.written++;
+	}
+	else
+	{
+		self.buf[self.head] = c;
+		self.head = (self.head + 1) % self.buf.len;
+	}
+}
+
+fn Element RingBuffer.get(&self, usz index) @operator([])
+{
+	index %= self.buf.len;
+	usz avail = self.buf.len - self.head;
+	if (index < avail)
+	{
+		return self.buf[self.head + index];
+	}
+	return self.buf[index - avail];
+}
+
+fn Element? RingBuffer.pop(&self)
+{
+	switch
+	{
+		case self.written == 0:
+			return NO_MORE_ELEMENT~;
+		case self.written < self.buf.len:
+			self.written--;
+			return self.buf[self.written];
+		default:
+			self.head = (self.head - 1) % self.buf.len;
+			return self.buf[self.head];
+	}
+}
+
+fn usz? RingBuffer.to_format(&self, Formatter* format) @dynamic
+{
+	// Improve this?
+	return format.printf("%s", self.buf);
+}
+
+fn usz RingBuffer.read(&self, usz index, Element[] buffer)
+{
+	index %= self.buf.len;
+	if (self.written < self.buf.len)
+	{
+		if (index >= self.written) return 0;
+		usz end = self.written - index;
+		usz n = min(end, buffer.len);
+		buffer[:n] = self.buf[index:n];
+		return n;
+	}
+	usz end = self.buf.len - self.head;
+	if (index >= end)
+	{
+		index -= end;
+		if (index >= self.head) return 0;
+		usz n = min(self.head - index, buffer.len);
+		buffer[:n] = self.buf[index:n];
+		return n;
+	}
+	if (buffer.len <= self.buf.len - index)
+	{
+		usz n = buffer.len;
+		buffer[:n] = self.buf[self.head + index:n];
+		return n;
+	}
+	usz n1 = self.buf.len - index;
+	buffer[:n1] = self.buf[self.head + index:n1];
+	buffer = buffer[n1..];
+	index -= n1;
+	usz n2 = min(self.head - index, buffer.len);
+	buffer[:n2] = self.buf[index:n2];
+	return n1 + n2;
+}
+
+fn void RingBuffer.write(&self, Element[] buffer)
+{
+	usz i;
+	while (self.written < self.buf.len && i < buffer.len)
+	{
+		self.buf[self.written] = buffer[i++];
+		self.written++;
+	}
+	foreach (c : buffer[i..])
+	{
+		self.buf[self.head] = c;
+		self.head = (self.head + 1) % self.buf.len;
+	}
+}

lib/std/collections/tuple.c3

@@ -0,0 +1,72 @@
+module std::collections::pair <Type1, Type2>;
+import std::io;
+
+struct Pair (Printable)
+{
+	Type1 first;
+	Type2 second;
+}
+
+fn usz? Pair.to_format(&self, Formatter* f) @dynamic
+{
+	return f.printf("{ %s, %s }", self.first, self.second);
+}
+
+<*
+ @param [&out] a
+ @param [&out] b
+ @require $defined(*a = self.first) : "You cannot assign the first value to a"
+ @require $defined(*b = self.second) : "You cannot assign the second value to b"
+*>
+macro void Pair.unpack(&self, a, b)
+{
+	*a = self.first;
+	*b = self.second;
+}
+
+fn bool Pair.equal(self, Pair other) @operator(==) @if (types::has_equals(Type1) &&& types::has_equals(Type2))
+{
+	return self.first == other.first && self.second == other.second;
+}
+
+module std::collections::triple <Type1, Type2, Type3>;
+import std::io;
+
+struct Triple (Printable)
+{
+	Type1 first;
+	Type2 second;
+	Type3 third;
+}
+
+fn usz? Triple.to_format(&self, Formatter* f) @dynamic
+{
+	return f.printf("{ %s, %s, %s }", self.first, self.second, self.third);
+}
+<*
+ @param [&out] a
+ @param [&out] b
+ @param [&out] c
+ @require $defined(*a = self.first) : "You cannot assign the first value to a"
+ @require $defined(*b = self.second) : "You cannot assign the second value to b"
+ @require $defined(*c = self.third) : "You cannot assign the second value to c"
+*>
+macro void Triple.unpack(&self, a, b, c)
+{
+	*a = self.first;
+	*b = self.second;
+	*c = self.third;
+}
+
+fn bool Triple.equal(self, Triple other) @operator(==) @if (types::has_equals(Type1) &&& types::has_equals(Type2) &&& types::has_equals(Type3))
+{
+	return self.first == other.first && self.second == other.second && self.third == other.third;
+}
+
+module std::collections::tuple <Type1, Type2>;
+
+struct Tuple @deprecated("Use 'Pair' instead")
+{
+	Type1 first;
+	Type2 second;
+}

lib/std/compression/qoi.c3

@@ -0,0 +1,466 @@
+module std::compression::qoi;
+
+const uint PIXELS_MAX = 400000000;
+
+<*
+ Colorspace.
+ Purely informative. It will be saved to the file header,
+ but does not affect how chunks are en-/decoded.
+*>
+constdef QOIColorspace : char
+{
+	<* sRGB with linear alpha *>
+	SRGB = 0,
+	<* all channels linear *>
+	LINEAR = 1
+}
+
+<*
+ Channels.
+ The channels used in an image.
+ AUTO can be used when decoding to automatically determine
+ the channels from the file's header.
+*>
+constdef QOIChannels : inline char
+{
+	AUTO = 0,
+	RGB = 3,
+	RGBA = 4
+}
+
+<*
+ Descriptor.
+ Contains information about an image.
+*>
+struct QOIDesc
+{
+	uint width;
+	uint height;
+	QOIChannels channels;
+	QOIColorspace colorspace;
+}
+<*
+ QOI Errors.
+ These are all the possible bad outcomes.
+*>
+faultdef INVALID_PARAMETERS, FILE_OPEN_FAILED, FILE_WRITE_FAILED, INVALID_DATA, TOO_MANY_PIXELS;
+
+
+// Let the user decide if they want to use std::io
+module std::compression::qoi @if(!$feature(QOI_NO_STDIO));
+import std::io;
+
+<*
+ Encode raw RGB or RGBA pixels into a QOI image and write it to the
+ file system.
+
+ The desc struct must be filled with the image width, height, the
+ used channels (QOIChannels.RGB or RGBA) and the colorspace
+ (QOIColorspace.SRGB or LINEAR).
+
+ The function returns an optional, which can either be a QOIError
+ or the number of bytes written on success.
+
+ @param [in] filename : `The file's name to write the image to`
+ @param [in] input : `The raw RGB or RGBA pixels to encode`
+ @param [&in] desc : `The descriptor of the image`
+*>
+fn usz? write(String filename, char[] input, QOIDesc* desc) => @pool()
+{
+	// encode data
+	char[] output = encode(tmem, input, desc)!;
+
+	file::save(filename, output)!;
+	return output.len;
+}
+
+
+<*
+ Read and decode a QOI image from the file system.
+
+ If channels is set to QOIChannels.AUTO, the function will
+ automatically determine the channels from the file's header.
+ However, if channels is RGB or RGBA, the output format will be
+ forced into this number of channels.
+
+ The desc struct will be filled with the width, height,
+ channels and colorspace of the image.
+
+ The function returns an optional, which can either be a QOIError
+ or a char[] pointing to the decoded pixels on success.
+
+ The returned pixel data should be free()d after use, or the decoding
+ and use of the data should be wrapped in a @pool() { ... }; block.
+
+ @param [in] filename : `The file's name to read the image from`
+ @param [&out] desc : `The descriptor to fill with the image's info`
+ @param channels : `The channels to be used`
+ @return? FILE_OPEN_FAILED, INVALID_DATA, TOO_MANY_PIXELS
+*>
+fn char[]? read(Allocator allocator, String filename, QOIDesc* desc, QOIChannels channels = AUTO) => @pool()
+{
+	// read file
+	char[] data = file::load_temp(filename) ?? FILE_OPEN_FAILED~!;
+	// pass data to decode function
+	return decode(allocator, data, desc, channels);
+}
+
+
+
+// Back to basic non-stdio mode
+module std::compression::qoi;
+import std::bits;
+
+<*
+ Encode raw RGB or RGBA pixels into a QOI image in memory.
+
+ The function returns an optional, which can either be a QOIError
+ or a char[] pointing to the encoded data on success.
+
+ The returned qoi data should be free()d after use, or the encoding
+ and use of the data should be wrapped in a @pool() { ... }; block.
+ See the write() function for an example.
+
+ @param [in] input : `The raw RGB or RGBA pixels to encode`
+ @param [&in] desc : `The descriptor of the image`
+ @return? INVALID_PARAMETERS, TOO_MANY_PIXELS, INVALID_DATA
+*>
+fn char[]? encode(Allocator allocator, char[] input, QOIDesc* desc) @nodiscard
+{
+	// check info in desc
+	if (desc.width == 0 || desc.height == 0) return INVALID_PARAMETERS~;
+	if (desc.channels == AUTO) return INVALID_PARAMETERS~;
+	uint pixels = desc.width * desc.height;
+	if (pixels > PIXELS_MAX) return TOO_MANY_PIXELS~;
+	
+	// check input data size
+	uint image_size = pixels * desc.channels;
+	if (image_size != input.len) return INVALID_DATA~;
+
+	// allocate memory for encoded data (output)
+	// header + chunk tag and RGB(A) data for each pixel + end of stream
+	uint max_size = Header.sizeof + pixels + image_size + END_OF_STREAM.len;
+	char[] output = allocator::alloc_array(allocator, char, max_size); // no need to init
+	defer catch allocator::free(allocator, output);
+
+	// write header
+	*(Header*)output.ptr = {
+		.be_magic = bswap('qoif'),
+		.be_width = bswap(desc.width),
+		.be_height = bswap(desc.height),
+		.channels = desc.channels,
+		.colorspace = desc.colorspace
+	};
+
+	uint pos = Header.sizeof; 	// Current position in output
+	uint loc;					// Current position in image (top-left corner)
+	uint loc_end = image_size - desc.channels; // End of image data
+	char run_length = 0; 		// Length of the current run
+	
+	Pixel[64] palette; // Zero-initialized by default
+	Pixel prev = { 0, 0, 0, 255 };
+	Pixel p = { 0, 0, 0, 255 };
+
+	ichar[<3>] diff; // pre-allocate for diff
+	ichar[<3>] luma; // ...and luma
+
+	// write chunks
+	for (loc = 0; loc < image_size; loc += desc.channels)
+	{
+		// set previous pixel
+		prev = p;
+
+		// get current pixel
+		p[:3] = input[loc:3]; // cutesy slices :3
+		if (desc.channels == RGBA) p.a = input[loc + 3];
+
+		// check if we can run the previous pixel
+		if (prev == p)
+		{
+			run_length++;
+			if (run_length == 62 || loc == loc_end)
+			{
+				*@extract(OpRun, output, &pos) = { OP_RUN, run_length - 1 };
+				run_length = 0;
+			}
+			continue;
+		}
+		// end last run if there was one
+		if (run_length > 0)
+		{
+			*@extract(OpRun, output, &pos) = { OP_RUN, run_length - 1 };
+			run_length = 0;
+		}
+
+		switch
+		{
+			// check if we can index the palette
+			case (palette[p.hash()] == p):
+				*@extract(OpIndex, output, &pos) = {
+					OP_INDEX,
+					p.hash()
+				};
+
+			// check if we can use diff or luma
+			case (prev != p && prev.a == p.a):
+				// diff the pixels
+				diff = p.rgb - prev.rgb;
+				if (diff.r > -3 && diff.r < 2
+					&& diff.g > -3 && diff.g < 2
+					&& diff.b > -3 && diff.b < 2)
+				{
+					*@extract(OpDiff, output, &pos) = {
+						OP_DIFF,
+						(char)diff.r + 2,
+						(char)diff.g + 2,
+						(char)diff.b + 2
+					};
+					palette[p.hash()] = p;
+					break;
+				}
+				// check luma eligibility
+				luma = { diff.r - diff.g, diff.g, diff.b - diff.g };
+				if (luma.r >= -8 && luma.r <= 7
+					&& luma.g >= -32 && luma.g <= 31
+					&& luma.b >= -8 && luma.b <= 7)
+				{
+					*@extract(OpLuma, output, &pos) = {
+						OP_LUMA,
+						(char)luma.g + 32,
+						(char)luma.r + 8,
+						(char)luma.b + 8
+					};
+					palette[p.hash()] = p;
+					break;
+				}
+				nextcase;
+
+			// worst case scenario: just encode the raw pixel
+			default:
+				if (prev.a != p.a)
+				{
+					*@extract(OpRGBA, output, &pos) = { OP_RGBA, p.r, p.g, p.b, p.a };
+				}
+				else
+				{
+					*@extract(OpRGB, output, &pos) = { OP_RGB, p.r, p.g, p.b };
+				}
+				palette[p.hash()] = p;
+		}
+	}
+
+	// write end of stream
+	output[pos:END_OF_STREAM.len] = END_OF_STREAM[..];
+	pos += END_OF_STREAM.len;
+	
+	return output[:pos];
+}
+
+
+
+<*
+ Decode a QOI image from memory.
+
+ If channels is set to QOIChannels.AUTO, the function will
+ automatically determine the channels from the file's header.
+ However, if channels is RGB or RGBA, the output format will be
+ forced into this number of channels.
+
+ The desc struct will be filled with the width, height,
+ channels and colorspace of the image.
+
+ The function returns an optional, which can either be a QOIError
+ or a char[] pointing to the decoded pixels on success.
+
+ The returned pixel data should be free()d after use, or the decoding
+ and use of the data should be wrapped in a @pool() { ... }; block.
+
+ @param [in] data : `The QOI image data to decode`
+ @param [&out] desc : `The descriptor to fill with the image's info`
+ @param channels : `The channels to be used`
+ @return? INVALID_DATA, TOO_MANY_PIXELS
+*>
+fn char[]? decode(Allocator allocator, char[] data, QOIDesc* desc, QOIChannels channels = AUTO) @nodiscard
+{
+	// check input data
+	if (data.len < Header.sizeof + END_OF_STREAM.len) return INVALID_DATA~;
+
+	// get header
+	Header* header = (Header*)data.ptr;
+
+	// check magic bytes (FourCC)
+	if (bswap(header.be_magic) != 'qoif') return INVALID_DATA~;
+
+	// copy header data to desc
+	uint width = desc.width = bswap(header.be_width);
+	uint height = desc.height = bswap(header.be_height);
+	QOIChannels desc_channels = desc.channels = header.channels;
+	desc.colorspace = header.colorspace;
+	if (desc_channels == AUTO) return INVALID_DATA~; // Channels must be specified in the header
+
+	// check width and height
+	if (width == 0 || height == 0) return INVALID_DATA~;
+
+	// check pixel count
+	ulong pixels = (ulong)width * (ulong)height;
+	if (pixels > PIXELS_MAX) return TOO_MANY_PIXELS~;
+
+	uint pos = Header.sizeof; 	// Current position in data
+	uint loc;					// Current position in image (top-left corner)
+	char run_length = 0; 		// Length of the current run
+	char tag;					// Current chunk tag
+
+	Pixel[64] palette; // Zero-initialized by default
+	Pixel p = { 0, 0, 0, 255 };
+
+	if (channels == AUTO) channels = desc_channels;
+	
+	// allocate memory for image data
+	usz image_size = (usz)pixels * channels;
+	char[] image = allocator::alloc_array(allocator, char, image_size);
+	defer catch allocator::free(allocator, image);
+
+	for (loc = 0; loc < image_size; loc += channels)
+	{
+		// get chunk tag
+		tag = data[pos];
+
+		// check for chunk type
+		switch
+		{
+			case run_length > 0:
+				run_length--;
+
+			case tag == OP_RGB:
+				OpRGB* op = @extract(OpRGB, data, &pos);
+				p = { op.red, op.green, op.blue, p.a };
+				palette[p.hash()] = p;
+
+			case tag == OP_RGBA:
+				OpRGBA* op = @extract(OpRGBA, data, &pos);
+				p = { op.red, op.green, op.blue, op.alpha };
+				palette[p.hash()] = p;
+				
+			case tag >> 6 == OP_INDEX:
+				OpIndex* op = @extract(OpIndex, data, &pos);
+				p = palette[op.index];
+
+			case tag >> 6 == OP_DIFF:
+				OpDiff* op = @extract(OpDiff, data, &pos);
+				p.r += op.diff_red - 2;
+				p.g += op.diff_green - 2;
+				p.b += op.diff_blue - 2;
+				palette[p.hash()] = p;
+
+			case tag >> 6 == OP_LUMA:
+				OpLuma* op = @extract(OpLuma, data, &pos);
+				int diff_green = op.diff_green - 32;
+				p.r += (char)(op.diff_red_minus_green - 8 + diff_green);
+				p.g += (char)(diff_green);
+				p.b += (char)(op.diff_blue_minus_green - 8 + diff_green);
+				palette[p.hash()] = p;
+
+			case tag >> 6 == OP_RUN:
+				OpRun* op = @extract(OpRun, data, &pos);
+				run_length = op.run;
+		}
+
+		// draw the pixel
+		if (channels == RGBA) { image[loc:4] = p.rgba[..]; } else { image[loc:3] = p.rgb[..]; }
+	}
+	
+	return image;
+}
+
+
+
+// ***************************************************************************
+// ***                                                                     ***
+// ***    Main functions are at the top to make the file more readable.    ***
+// ***        From here on, helper functions and types are defined.        ***
+// ***                                                                     ***
+// ***************************************************************************
+module std::compression::qoi @private;
+
+// 8-bit opcodes
+const OP_RGB = 0b11111110;
+const OP_RGBA = 0b11111111;
+// 2-bit opcodes
+const OP_INDEX = 0b00;
+const OP_DIFF = 0b01;
+const OP_LUMA = 0b10;
+const OP_RUN = 0b11;
+
+struct Header @packed
+{
+	<* magic bytes "qoif" *>
+	uint be_magic;
+	<* image width in pixels (BE) *>
+	uint be_width;
+	<* image height in pixels (BE) *>
+	uint be_height;
+
+	// informative fields
+	<* 3 = RGB, 4 = RGB *>
+	QOIChannels channels;
+	<* 0 = sRGB with linear alpha, 1 = all channels linear *>
+	QOIColorspace colorspace;
+}
+
+const char[*] END_OF_STREAM = {0, 0, 0, 0, 0, 0, 0, 1};
+
+typedef Pixel = inline char[<4>];
+macro char Pixel.hash(Pixel p)
+{
+	return (p.r * 3 + p.g * 5 + p.b * 7 + p.a * 11) % 64;
+}
+
+struct OpRGB // No need to use @packed here, the alignment is 1 anyways.
+{
+	char tag;
+	char red;
+	char green;
+	char blue;
+}
+struct OpRGBA @packed
+{
+	char tag;
+	char red;
+	char green;
+	char blue;
+	char alpha;
+}
+bitstruct OpIndex : char
+{
+	char tag : 6..7;
+	char index : 0..5;
+}
+bitstruct OpDiff : char
+{
+	char tag : 6..7;
+	char diff_red : 4..5;
+	char diff_green : 2..3;
+	char diff_blue : 0..1;
+}
+bitstruct OpLuma : ushort @align(1)
+{
+	char tag : 6..7;
+	char diff_green : 0..5;
+	char diff_red_minus_green : 12..15;
+	char diff_blue_minus_green : 8..11;
+}
+bitstruct OpRun : char
+{
+	char tag : 6..7;
+	char run : 0..5;
+}
+
+// Macro used to locate chunks in data buffers.
+// Can be used both for reading and writing.
+macro @extract($Type, char[] data, uint* pos)
+{
+	// slice data, then double cast
+	$Type* chunk = ($Type*)data[*pos : $Type.sizeof].ptr;
+	*pos += $Type.sizeof;
+	return chunk;
+}

lib/std/core/allocators/arena_allocator.c3

@@ -0,0 +1,151 @@
+// Copyright (c) 2023-2025 Christoffer Lerno. All rights reserved.
+// Use of this source code is governed by the MIT license
+// a copy of which can be found in the LICENSE_STDLIB file.
+module std::core::mem::allocator;
+import std::math;
+
+// The arena allocator allocates up to its maximum data
+// and then fails to allocate more, returning out of memory.
+// It supports mark and reset to mark.
+
+struct ArenaAllocator (Allocator)
+{
+	char[] data;
+	usz used;
+}
+
+<*
+ Initialize a memory arena for use using the provided bytes.
+
+ @param [inout] data : "The memory to use for the arena."
+*>
+fn ArenaAllocator* ArenaAllocator.init(&self, char[] data)
+{
+	self.data = data;
+	self.used = 0;
+	return self;
+}
+
+<*
+ Reset the usage completely.
+*>
+fn void ArenaAllocator.clear(&self)
+{
+	self.used = 0;
+}
+
+<*
+ Given some memory, create an arena allocator on the stack for it.
+
+ @param [inout] bytes : `The bytes to use, may be empty.`
+
+ @return `An arena allocator using the bytes`
+*>
+macro ArenaAllocator* wrap(char[] bytes)
+{
+	return (ArenaAllocator){}.init(bytes);
+}
+
+<*
+ "Mark" the current state of the arena allocator by returning the use count.
+
+ @return `The value to pass to 'reset' in order to reset to the current use.`
+*>
+fn usz ArenaAllocator.mark(&self) => self.used;
+
+<*
+ Reset to a previous mark.
+
+ @param mark : `The previous mark.`
+ @require mark <= self.used : "Invalid mark - out of range"
+*>
+fn void ArenaAllocator.reset(&self, usz mark) => self.used = mark;
+
+<*
+ Implements the Allocator interface method.
+
+ @require ptr != null
+*>
+fn void ArenaAllocator.release(&self, void* ptr, bool) @dynamic
+{
+	assert((uptr)ptr >= (uptr)self.data.ptr, "Pointer originates from a different allocator.");
+	ArenaAllocatorHeader* header = ptr - ArenaAllocatorHeader.sizeof;
+	// Reclaim memory if it's the last element.
+	if (ptr + header.size == &self.data[self.used])
+	{
+		self.used -= header.size + ArenaAllocatorHeader.sizeof;
+	}
+}
+
+
+<*
+ Implements the Allocator interface method.
+
+ @require !alignment || math::is_power_of_2(alignment)
+ @require alignment <= mem::MAX_MEMORY_ALIGNMENT : `alignment too big`
+ @require size > 0
+ @return? mem::INVALID_ALLOC_SIZE, mem::OUT_OF_MEMORY
+*>
+fn void*? ArenaAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic
+{
+	alignment = alignment_for_allocation(alignment);
+	usz total_len = self.data.len;
+	if (size > total_len) return mem::INVALID_ALLOC_SIZE~;
+	void* start_mem = self.data.ptr;
+	void* unaligned_pointer_to_offset = start_mem + self.used + ArenaAllocatorHeader.sizeof;
+	void* mem = mem::aligned_pointer(unaligned_pointer_to_offset, alignment);
+	usz end = (usz)(mem - self.data.ptr) + size;
+	if (end > total_len) return mem::OUT_OF_MEMORY~;
+	self.used = end;
+	ArenaAllocatorHeader* header = mem - ArenaAllocatorHeader.sizeof;
+	header.size = size;
+	if (init_type == ZERO) mem::clear(mem, size, mem::DEFAULT_MEM_ALIGNMENT);
+	return mem;
+}
+
+<*
+ Implements the Allocator interface method.
+
+ @require !alignment || math::is_power_of_2(alignment)
+ @require alignment <= mem::MAX_MEMORY_ALIGNMENT : `alignment too big`
+ @require old_pointer != null
+ @require size > 0
+ @return? mem::INVALID_ALLOC_SIZE, mem::OUT_OF_MEMORY
+*>
+fn void*? ArenaAllocator.resize(&self, void *old_pointer, usz size, usz alignment) @dynamic
+{
+	alignment = alignment_for_allocation(alignment);
+	assert(old_pointer >= self.data.ptr, "Pointer originates from a different allocator.");
+	usz total_len = self.data.len;
+	if (size > total_len) return mem::INVALID_ALLOC_SIZE~;
+	ArenaAllocatorHeader* header = old_pointer - ArenaAllocatorHeader.sizeof;
+	usz old_size = header.size;
+	// Do last allocation and alignment match?
+	if (&self.data[self.used] == old_pointer + old_size && mem::ptr_is_aligned(old_pointer, alignment))
+	{
+		if (old_size >= size)
+		{
+			self.used -= old_size - size;
+		}
+		else
+		{
+			usz new_used = self.used + size - old_size;
+			if (new_used > total_len) return mem::OUT_OF_MEMORY~;
+			self.used = new_used;
+		}
+		header.size = size;
+		return old_pointer;
+	}
+	// Otherwise just allocate new memory.
+	void* mem = self.acquire(size, NO_ZERO, alignment)!;
+	mem::copy(mem, old_pointer, math::min(size, old_size), mem::DEFAULT_MEM_ALIGNMENT, mem::DEFAULT_MEM_ALIGNMENT);
+	return mem;
+}
+
+// Internal data
+
+struct ArenaAllocatorHeader @local
+{
+	usz size;
+	char[*] data;
+}

lib/std/core/allocators/backed_arena_allocator.c3

@@ -0,0 +1,219 @@
+module std::core::mem::allocator;
+import std::io, std::math;
+
+<*
+ The backed arena allocator provides an allocator that will allocate from a pre-allocated chunk of memory
+ provided by it's backing allocator. The allocator supports mark / reset operations, so it can be used
+ as a stack (push-pop) allocator. If the initial memory is used up, it will fall back to regular allocations,
+ that will be safely freed on `reset`.
+
+ While this allocator is similar to the dynamic arena, it supports multiple "save points", which the dynamic arena
+ doesn't.
+*>
+struct BackedArenaAllocator (Allocator)
+{
+	Allocator backing_allocator;
+	ExtraPage* last_page;
+	usz used;
+	usz capacity;
+	char[*] data;
+}
+
+struct AllocChunk @local
+{
+	usz size;
+	char[*] data;
+}
+
+const usz PAGE_IS_ALIGNED @local = (usz)isz.max + 1u;
+
+struct ExtraPage @local
+{
+	ExtraPage* prev_page;
+	void* start;
+	usz mark;
+	usz size;
+	usz ident;
+	char[*] data;
+}
+
+macro usz ExtraPage.pagesize(&self) => self.size & ~PAGE_IS_ALIGNED;
+macro bool ExtraPage.is_aligned(&self) => self.size & PAGE_IS_ALIGNED == PAGE_IS_ALIGNED;
+
+<*
+ @require size >= 16
+*>
+fn BackedArenaAllocator*? new_backed_allocator(usz size, Allocator allocator)
+{
+	BackedArenaAllocator* temp = allocator::alloc_with_padding(allocator, BackedArenaAllocator, size)!;
+	temp.last_page = null;
+	temp.backing_allocator = allocator;
+	temp.used = 0;
+	temp.capacity = size;
+	return temp;
+}
+
+fn void BackedArenaAllocator.destroy(&self)
+{
+	self.reset(0);
+	if (self.last_page) (void)_free_page(self, self.last_page);
+	allocator::free(self.backing_allocator, self);
+}
+
+fn usz BackedArenaAllocator.mark(&self) => self.used;
+
+fn void BackedArenaAllocator.release(&self, void* old_pointer, bool) @dynamic
+{
+	usz old_size = *(usz*)(old_pointer - DEFAULT_SIZE_PREFIX);
+	if (old_pointer + old_size == &self.data[self.used])
+	{
+		self.used -= old_size;
+		asan::poison_memory_region(&self.data[self.used], old_size);
+	}
+}
+fn void BackedArenaAllocator.reset(&self, usz mark)
+{
+	ExtraPage *last_page = self.last_page;
+	while (last_page && last_page.mark > mark)
+	{
+		self.used = last_page.mark;
+		ExtraPage *to_free = last_page;
+		last_page = last_page.prev_page;
+		_free_page(self, to_free)!!;
+	}
+	self.last_page = last_page;
+	$if env::COMPILER_SAFE_MODE || env::ADDRESS_SANITIZER:
+		if (!last_page)
+		{
+			usz cleaned = self.used - mark;
+			if (cleaned > 0)
+			{
+				$if env::COMPILER_SAFE_MODE && !env::ADDRESS_SANITIZER:
+					self.data[mark : cleaned] = 0xAA;
+				$endif
+				asan::poison_memory_region(&self.data[mark], cleaned);
+			}
+		}
+	$endif
+	self.used = mark;
+}
+
+fn void? _free_page(BackedArenaAllocator* self, ExtraPage* page) @inline @local
+{
+	void* mem = page.start;
+	return self.backing_allocator.release(mem, page.is_aligned());
+}
+
+fn void*? _realloc_page(BackedArenaAllocator* self, ExtraPage* page, usz size, usz alignment) @inline @local
+{
+	// Then the actual start pointer:
+	void* real_pointer = page.start;
+
+	// Walk backwards to find the pointer to this page.
+	ExtraPage **pointer_to_prev = &self.last_page;
+	// Remove the page from the list
+	while (*pointer_to_prev != page)
+	{
+		pointer_to_prev = &((*pointer_to_prev).prev_page);
+	}
+	*pointer_to_prev = page.prev_page;
+	usz page_size = page.pagesize();
+	// Clear on size > original size.
+	void* data = self.acquire(size, NO_ZERO, alignment)!;
+	mem::copy(data, &page.data[0], page_size, mem::DEFAULT_MEM_ALIGNMENT, mem::DEFAULT_MEM_ALIGNMENT);
+	self.backing_allocator.release(real_pointer, page.is_aligned());
+	return data;
+}
+
+fn void*? BackedArenaAllocator.resize(&self, void* pointer, usz size, usz alignment) @dynamic
+{
+	AllocChunk *chunk = pointer - AllocChunk.sizeof;
+	if (chunk.size == (usz)-1)
+	{
+		assert(self.last_page, "Realloc of unrelated pointer");
+		// First grab the page
+		ExtraPage *page = pointer - ExtraPage.sizeof;
+		return _realloc_page(self, page, size, alignment);
+	}
+
+	AllocChunk* data = self.acquire(size, NO_ZERO, alignment)!;
+	mem::copy(data, pointer, math::min(size, chunk.size), mem::DEFAULT_MEM_ALIGNMENT, mem::DEFAULT_MEM_ALIGNMENT);
+
+	return data;
+}
+
+<*
+ @require size > 0
+ @require !alignment || math::is_power_of_2(alignment)
+ @require alignment <= mem::MAX_MEMORY_ALIGNMENT : `alignment too big`
+*>
+fn void*? BackedArenaAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic
+{
+	alignment = alignment_for_allocation(alignment);
+	void* start_mem = &self.data;
+	void* starting_ptr = start_mem + self.used;
+	void* aligned_header_start = mem::aligned_pointer(starting_ptr, AllocChunk.alignof);
+	void* mem = aligned_header_start + AllocChunk.sizeof;
+	if (alignment > AllocChunk.alignof)
+	{
+		mem = mem::aligned_pointer(mem, alignment);
+	}
+	usz new_usage = (usz)(mem - start_mem) + size;
+
+	// Arena allocation, simple!
+	if (new_usage <= self.capacity)
+	{
+		asan::unpoison_memory_region(starting_ptr, new_usage - self.used);
+		AllocChunk* chunk_start = mem - AllocChunk.sizeof;
+		chunk_start.size = size;
+		self.used = new_usage;
+		if (init_type == ZERO) mem::clear(mem, size, mem::DEFAULT_MEM_ALIGNMENT);
+		return mem;
+	}
+
+	// Fallback to backing allocator
+	ExtraPage* page;
+
+	// We have something we need to align.
+	if (alignment > mem::DEFAULT_MEM_ALIGNMENT)
+	{
+		// This is actually simpler, since it will create the offset for us.
+		usz total_alloc_size = mem::aligned_offset(ExtraPage.sizeof + size, alignment);
+		if (init_type == ZERO)
+		{
+			mem = allocator::calloc_aligned(self.backing_allocator, total_alloc_size, alignment)!;
+		}
+		else
+		{
+			mem = allocator::malloc_aligned(self.backing_allocator, total_alloc_size, alignment)!;
+		}
+		void* start = mem;
+		mem += mem::aligned_offset(ExtraPage.sizeof, alignment);
+		page = (ExtraPage*)mem - 1;
+		page.start = start;
+		page.size = size | PAGE_IS_ALIGNED;
+	}
+	else
+	{
+		// Here we might need to pad
+		usz padded_header_size = mem::aligned_offset(ExtraPage.sizeof, mem::DEFAULT_MEM_ALIGNMENT);
+		usz total_alloc_size = padded_header_size + size;
+		void* alloc = self.backing_allocator.acquire(total_alloc_size, init_type, 0)!;
+
+		// Find the page.
+		page = alloc + padded_header_size - ExtraPage.sizeof;
+		assert(mem::ptr_is_aligned(page, BackedArenaAllocator.alignof));
+		assert(mem::ptr_is_aligned(&page.data[0], mem::DEFAULT_MEM_ALIGNMENT));
+		page.start = alloc;
+		page.size = size;
+	}
+
+	// Mark it as a page
+	page.ident = ~(usz)0;
+	// Store when it was created
+	page.mark = ++self.used;
+	// Hook up the page.
+	page.prev_page = self.last_page;
+	self.last_page = page;
+	return &page.data[0];
+}

lib/std/core/allocators/dynamic_arena.c3

@@ -1,182 +1,224 @@
+// Copyright (c) 2021-2024 Christoffer Lerno. All rights reserved.
+// Use of this source code is governed by the MIT license
+// a copy of which can be found in the LICENSE_STDLIB file.
 module std::core::mem::allocator;
+import std::math;
 
-private struct DynamicArenaPage
+<*
+ The dynamic arena allocator is an arena allocator that can grow by adding additional arena "pages".
+ It only supports reset, at which point all pages except the first one is released to the backing
+ allocator.
+
+ If you want multiple save points, use the BackedArenaAllocator instead.
+
+ The advantage over the BackedArenaAllocator, is that when allocating beyond the first "page", it will
+ retain the characteristics of an arena allocator (allocating a large piece of memory then handing off
+ memory from that memory), whereas the BackedArenaAllocator will have heap allocator characteristics.
+*>
+struct DynamicArenaAllocator (Allocator)
+{
+	Allocator backing_allocator;
+	DynamicArenaPage* page;
+	DynamicArenaPage* unused_page;
+	usz page_size;
+}
+
+<*
+ @param [&inout] allocator
+ @require page_size >= 128
+*>
+fn void DynamicArenaAllocator.init(&self, Allocator allocator, usz page_size)
+{
+	self.page = null;
+	self.unused_page = null;
+	self.page_size = page_size;
+	self.backing_allocator = allocator;
+}
+
+fn void DynamicArenaAllocator.free(&self)
+{
+	DynamicArenaPage* page = self.page;
+	while (page)
+	{
+		DynamicArenaPage* next_page = page.prev_arena;
+		allocator::free(self.backing_allocator, page.memory);
+		allocator::free(self.backing_allocator, page);
+		page = next_page;
+	}
+	page = self.unused_page;
+	while (page)
+	{
+		DynamicArenaPage* next_page = page.prev_arena;
+		allocator::free(self.backing_allocator, page.memory);
+		allocator::free(self.backing_allocator, page);
+		page = next_page;
+	}
+	self.page = null;
+	self.unused_page = null;
+}
+
+struct DynamicArenaPage @local
 {
 	void* memory;
 	void* prev_arena;
-	usize total;
-	usize used;
-	void* last_ptr;
+	usz total;
+	usz used;
+	void* current_stack_ptr;
 }
 
-
-/**
- * @require ptr && this
- * @require this.page `tried to free pointer on invalid allocator`
- */
-private fn void DynamicArenaAllocator.free(DynamicArenaAllocator* this, void* ptr)
+struct DynamicArenaChunk @local
 {
-	DynamicArenaPage* current_page = this.page;
-	if (ptr == current_page.last_ptr)
+	usz size;
+}
+
+<*
+ @require ptr != null
+ @require self.page != null  : `tried to free pointer on invalid allocator`
+*>
+fn void DynamicArenaAllocator.release(&self, void* ptr, bool) @dynamic
+{
+	DynamicArenaPage* current_page = self.page;
+	if (ptr == current_page.current_stack_ptr)
 	{
-		current_page.used = (usize)((ptr - DEFAULT_SIZE_PREFIX) - current_page.memory);
+		current_page.used = (usz)((ptr - DEFAULT_SIZE_PREFIX) - current_page.memory);
 	}
-	current_page.last_ptr = null;
+	current_page.current_stack_ptr = null;
 }
 
-/**
- * @require old_pointer && size > 0
- * @require this.page `tried to realloc pointer on invalid allocator`
- */
-private fn void*! DynamicArenaAllocator.realloc(DynamicArenaAllocator* this, void* old_pointer, usize size, usize alignment)
+<*
+ @require size > 0 : `Resize doesn't support zeroing`
+ @require old_pointer != null : `Resize doesn't handle null pointers`
+ @require self.page != null  : `tried to realloc pointer on invalid allocator`
+ @return? mem::INVALID_ALLOC_SIZE, mem::OUT_OF_MEMORY
+*>
+fn void*? DynamicArenaAllocator.resize(&self, void* old_pointer, usz size, usz alignment) @dynamic
 {
-	DynamicArenaPage* current_page = this.page;
+	DynamicArenaPage* current_page = self.page;
 	alignment = alignment_for_allocation(alignment);
-	usize* old_size_ptr = old_pointer - DEFAULT_SIZE_PREFIX;
-	usize old_size = *old_size_ptr;
+	usz* old_size_ptr = old_pointer - DEFAULT_SIZE_PREFIX;
+	usz old_size = *old_size_ptr;
 	// We have the old pointer and it's correctly aligned.
 	if (old_size >= size && mem::ptr_is_aligned(old_pointer, alignment))
 	{
 		*old_size_ptr = size;
-		if (current_page.last_ptr == old_pointer)
+		if (current_page.current_stack_ptr == old_pointer)
 		{
-			current_page.used = (usize)((old_pointer - DEFAULT_SIZE_PREFIX) - current_page.memory);
+			current_page.used = (usz)((old_pointer - DEFAULT_SIZE_PREFIX) - current_page.memory);
 		}
 		return old_pointer;
 	}
-	if REUSE: (current_page.last_ptr == old_pointer && mem::ptr_is_aligned(old_pointer, alignment))
+	if REUSE: (current_page.current_stack_ptr == old_pointer && mem::ptr_is_aligned(old_pointer, alignment))
 	{
 		assert(size > old_size);
-		usize add_size = size - old_size;
+		usz add_size = size - old_size;
 		if (add_size + current_page.used > current_page.total) break REUSE;
 		*old_size_ptr = size;
 		current_page.used += add_size;
 		return old_pointer;
 	}
-	void* new_mem = this.alloc(size, alignment)?;
-	mem::copy(new_mem, old_pointer, old_size);
+	void* new_mem = self.acquire(size, NO_ZERO, alignment)!;
+	mem::copy(new_mem, old_pointer, math::min(old_size, size), mem::DEFAULT_MEM_ALIGNMENT);
 	return new_mem;
 }
 
-private fn void DynamicArenaAllocator.reset(DynamicArenaAllocator* this)
+fn void DynamicArenaAllocator.reset(&self)
 {
-	DynamicArenaPage* page = this.page;
-	DynamicArenaPage** unused_page_ptr = &this.unused_page;
-    while (page)
-    {
-        DynamicArenaPage* next_page = page.prev_arena;
-        page.used = 0;
-        DynamicArenaPage* prev_unused = *unused_page_ptr;
-        *unused_page_ptr = page;
-        page.prev_arena = prev_unused;
-        page = next_page;
-    }
-    this.page = page;
-}
-
-/**
- * @require math::is_power_of_2(alignment)
- * @require size > 0
- */
-private fn void*! DynamicArenaAllocator.alloc_new(DynamicArenaAllocator* this, usize size, usize alignment)
-{
-	usize page_size = max(this.page_size, size + DEFAULT_SIZE_PREFIX + alignment);
-	void* mem = this.backing_allocator.alloc(page_size)?;
-	DynamicArenaPage*! page = this.backing_allocator.alloc(DynamicArenaPage.sizeof);
-	if (catch err = page)
+	DynamicArenaPage* page = self.page;
+	DynamicArenaPage** unused_page_ptr = &self.unused_page;
+	while (page)
 	{
-		this.backing_allocator.free(mem)?;
-		return err!;
+		DynamicArenaPage* next_page = page.prev_arena;
+		page.used = 0;
+		DynamicArenaPage* prev_unused = *unused_page_ptr;
+		*unused_page_ptr = page;
+		page.prev_arena = prev_unused;
+		page = next_page;
 	}
-    page.memory = mem;
-    usize offset = mem::aligned_offset((usize)mem + DEFAULT_SIZE_PREFIX, alignment) - (usize)mem;
-    usize* size_ptr = mem + offset - DEFAULT_SIZE_PREFIX;
-    *size_ptr = size;
-	page.prev_arena = this.page;
-	page.total = page_size;
-	page.used = size + offset;
-	this.page = page;
-
-	return page.last_ptr = page.memory + offset;
+	self.page = page;
 }
 
-/**
- * @require !alignment || math::is_power_of_2(alignment)
- * @require size > 0
- * @require this
- */
-private fn void*! DynamicArenaAllocator.alloc(DynamicArenaAllocator* this, usize size, usize alignment)
+
+
+<*
+ @require size > 0 : `acquire expects size > 0`
+ @require !alignment || math::is_power_of_2(alignment)
+ @return? mem::INVALID_ALLOC_SIZE, mem::OUT_OF_MEMORY
+*>
+fn void*? DynamicArenaAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic
 {
 	alignment = alignment_for_allocation(alignment);
-	DynamicArenaPage* page = this.page;
-	if (!page && this.unused_page)
+	DynamicArenaPage* page = self.page;
+
+	void* ptr @noinit;
+	do SET_DONE:
 	{
-		this.page = page = this.unused_page;
-		this.unused_page = page.prev_arena;
-		page.prev_arena = null;
-	}
-    if (!page) return this.alloc_new(size, alignment);
-    usize start = mem::aligned_offset((uptr)page.memory + page.used + DEFAULT_SIZE_PREFIX, alignment) - (usize)page.memory;
-    usize new_used = start + size;
-    if ALLOCATE_NEW: (new_used > page.total)
-    {
-        if ((page = this.unused_page))
-        {
-            start = mem::aligned_offset((uptr)page.memory + DEFAULT_SIZE_PREFIX, alignment) - (usize)page.memory;
-            new_used = start + size;
-            if (page.total >= new_used)
-            {
-	    		this.unused_page = page.prev_arena;
-    	    	page.prev_arena = this.page;
-    		    this.page = page;
-    		    break ALLOCATE_NEW;
-            }
-        }
- 	    return this.alloc_new(size, alignment);
-    }
-    page.used = new_used;
-    void* mem = page.memory + start;
-    usize* size_offset = mem - DEFAULT_SIZE_PREFIX;
-    *size_offset = size;
-    return mem;
+		if (!page && self.unused_page)
+		{
+			self.page = page = self.unused_page;
+			self.unused_page = page.prev_arena;
+			page.prev_arena = null;
+		}
+		if (!page)
+		{
+			ptr = _alloc_new(self, size, alignment)!;
+			break SET_DONE;
+		}
+		void* start = mem::aligned_pointer(page.memory + page.used + DynamicArenaChunk.sizeof, alignment);
+		usz new_used = start - page.memory + size;
+		if ALLOCATE_NEW: (new_used > page.total)
+		{
+			if ((page = self.unused_page))
+			{
+				start = mem::aligned_pointer(page.memory + page.used + DynamicArenaChunk.sizeof, alignment);
+				new_used = start + size - page.memory;
+				if (page.total >= new_used)
+				{
+					self.unused_page = page.prev_arena;
+					page.prev_arena = self.page;
+					self.page = page;
+					break ALLOCATE_NEW;
+				}
+			}
+			ptr = _alloc_new(self, size, alignment)!;
+			break SET_DONE;
+		}
+		page.used = new_used;
+		assert(start + size == page.memory + page.used);
+		ptr = start;
+		DynamicArenaChunk* chunk = (DynamicArenaChunk*)ptr - 1;
+		chunk.size = size;
+	};
+	if (init_type == ZERO) mem::clear(ptr, size, mem::DEFAULT_MEM_ALIGNMENT);
+	return ptr;
 }
 
-/**
- * @require !alignment || math::is_power_of_2(alignment)
- * @require data `unexpectedly missing the allocator`
- */
-private fn void*! dynamic_arena_allocator_function(Allocator* data, usize size, usize alignment, void* old_pointer, AllocationKind kind)
+<*
+ @require math::is_power_of_2(alignment)
+ @require size > 0
+ @return? mem::INVALID_ALLOC_SIZE, mem::OUT_OF_MEMORY
+*>
+fn void*? _alloc_new(DynamicArenaAllocator* self, usz size, usz alignment) @local
 {
-	DynamicArenaAllocator* allocator = (DynamicArenaAllocator*)data;
-	switch (kind)
+	// First, make sure that we can align it, extending the page size if needed.
+	usz page_size = max(self.page_size, mem::aligned_offset(size + DynamicArenaChunk.sizeof + alignment, alignment));
+	assert(page_size > size + DynamicArenaChunk.sizeof);
+	// Grab the page without alignment (we do it ourselves)
+	void* mem = allocator::malloc_try(self.backing_allocator, page_size)!;
+	DynamicArenaPage*? page = allocator::new_try(self.backing_allocator, DynamicArenaPage);
+	if (catch err = page)
 	{
-		case CALLOC:
-			assert(!old_pointer, "Unexpected no old pointer for calloc.");
-			if (!size) return null;
-			void* mem = allocator.alloc(size, alignment)?;
-			mem::set(mem, 0, size);
-			return mem;
-		case ALLOC:
-			assert(!old_pointer, "Unexpected no old pointer for alloc.");
-			if (!size) return null;
-			return allocator.alloc(size, alignment);
-		case REALLOC:
-			if (!size)
-			{
-				if (!old_pointer) return null;
-				allocator.free(old_pointer);
-				return null;
-			}
-			if (!old_pointer) return allocator.alloc(size, alignment);
-			void* mem = allocator.realloc(old_pointer, size, alignment)?;
-			return mem;
-		case FREE:
-			if (!old_pointer) return null;
-			allocator.free(old_pointer);
-			return null;
-		case RESET:
-			allocator.reset();
-			return null;
+		allocator::free(self.backing_allocator, mem);
+		return err~;
 	}
-	unreachable();
-}
+	page.memory = mem;
+	void* mem_start = mem::aligned_pointer(mem + DynamicArenaChunk.sizeof, alignment);
+	assert(mem_start + size < mem + page_size);
+	DynamicArenaChunk* chunk = (DynamicArenaChunk*)mem_start - 1;
+	chunk.size = size;
+	page.prev_arena = self.page;
+	page.total = page_size;
+	page.used = mem_start + size - page.memory;
+	self.page = page;
+	page.current_stack_ptr = mem_start;
+	return mem_start;
+}

lib/std/core/allocators/heap_allocator.c3

@@ -0,0 +1,216 @@
+// Copyright (c) 2021-2025 Christoffer Lerno. All rights reserved.
+// Use of this source code is governed by the MIT license
+// a copy of which can be found in the LICENSE_STDLIB file.
+
+module std::core::mem::allocator;
+import std::math;
+
+<*
+ The SimpleHeapAllocator implements a simple heap allocator on top of an allocator function.
+
+ It uses the given allocator function to allocate memory from some source, but never frees it.
+ This allocator is intended to be used in environments where there isn't any native libc malloc,
+ and it has to be emulated from a memory region, or wrapping linear memory as is the case for plain WASM.
+*>
+struct SimpleHeapAllocator (Allocator)
+{
+	MemoryAllocFn alloc_fn;
+	Header* free_list;
+}
+
+<*
+ @require allocator != null  : "An underlying memory provider must be given"
+ @require !self.free_list : "The allocator may not be already initialized"
+*>
+fn void SimpleHeapAllocator.init(&self, MemoryAllocFn allocator)
+{
+	self.alloc_fn = allocator;
+	self.free_list = null;
+}
+
+fn void*? SimpleHeapAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic
+{
+	if (init_type == ZERO)
+	{
+		return alignment > 0 ? @aligned_alloc_fn(self, simple_alloc_calloc, size, alignment) : simple_alloc_calloc(self, size);
+	}
+	return alignment > 0 ? @aligned_alloc_fn(self, simple_alloc_alloc, size, alignment) : simple_alloc_alloc(self, size);
+}
+
+fn void*? SimpleHeapAllocator.resize(&self, void* old_pointer, usz size, usz alignment) @dynamic
+{
+	return alignment > 0
+		? @aligned_realloc_fn(self, simple_alloc_calloc, simple_alloc_free, old_pointer, size, alignment)
+		:  simple_alloc_realloc(self, old_pointer, size);
+}
+
+fn void SimpleHeapAllocator.release(&self, void* old_pointer, bool aligned) @dynamic
+{
+	if (aligned)
+	{
+		@aligned_free_fn(self, simple_alloc_free, old_pointer)!!;
+	}
+	else
+	{
+		simple_alloc_free(self, old_pointer);
+	}
+}
+
+<*
+ @require old_pointer && bytes > 0
+*>
+fn void*? simple_alloc_realloc(SimpleHeapAllocator* self, void* old_pointer, usz bytes) @local
+{
+	// Find the block header.
+	Header* block = (Header*)old_pointer - 1;
+	if (block.size >= bytes) return old_pointer;
+	void* new = simple_alloc_alloc(self, bytes)!;
+	usz max_to_copy = math::min(block.size, bytes);
+	mem::copy(new, old_pointer, max_to_copy);
+	simple_alloc_free(self, old_pointer);
+	return new;
+}
+
+fn void*? simple_alloc_calloc(SimpleHeapAllocator* self, usz bytes) @local
+{
+	void* data = simple_alloc_alloc(self, bytes)!;
+	mem::clear(data, bytes, mem::DEFAULT_MEM_ALIGNMENT);
+	return data;
+}
+
+fn void*? simple_alloc_alloc(SimpleHeapAllocator* self, usz bytes) @local
+{
+	usz aligned_bytes = mem::aligned_offset(bytes, mem::DEFAULT_MEM_ALIGNMENT);
+	if (!self.free_list)
+	{
+		simple_alloc_add_block(self, aligned_bytes)!;
+	}
+
+	Header* current = self.free_list;
+	Header* previous = current;
+	while (current)
+	{
+		switch
+		{
+			case current.size >= aligned_bytes && current.size <= aligned_bytes + Header.sizeof + 64:
+				if (current == previous)
+				{
+					self.free_list = current.next;
+				}
+				else
+				{
+					previous.next = current.next;
+				}
+				current.next = null;
+				return current + 1;
+			case current.size > aligned_bytes:
+				Header* unallocated = (Header*)((char*)current + aligned_bytes + Header.sizeof);
+				unallocated.size = current.size - aligned_bytes - Header.sizeof;
+				unallocated.next = current.next;
+				if (current == self.free_list)
+				{
+					self.free_list = unallocated;
+				}
+				else
+				{
+					previous.next = unallocated;
+				}
+				current.size = aligned_bytes;
+				current.next = null;
+				return current + 1;
+			default:
+				previous = current;
+				current = current.next;
+		}
+	}
+	simple_alloc_add_block(self, aligned_bytes)!;
+	return simple_alloc_alloc(self, aligned_bytes);
+}
+
+fn void? simple_alloc_add_block(SimpleHeapAllocator* self, usz aligned_bytes) @local
+{
+	assert(mem::aligned_offset(aligned_bytes, mem::DEFAULT_MEM_ALIGNMENT) == aligned_bytes);
+	char[] result = self.alloc_fn(aligned_bytes + Header.sizeof)!;
+	Header* new_block = (Header*)result.ptr;
+	new_block.size = result.len - Header.sizeof;
+	new_block.next = null;
+	simple_alloc_free(self, new_block + 1);
+}
+
+
+fn void simple_alloc_free(SimpleHeapAllocator* self, void* ptr) @local
+{
+	// Empty ptr -> do nothing.
+	if (!ptr) return;
+
+	// Find the block header.
+	Header* block = (Header*)ptr - 1;
+
+	// No free list? Then just return self.
+	if (!self.free_list)
+	{
+		self.free_list = block;
+		return;
+	}
+
+	// Find where in the list it should be inserted.
+	Header* current = self.free_list;
+	Header* prev = current;
+	while (current)
+	{
+		if (block < current)
+		{
+			// Between prev and current
+			if (block > prev) break;
+			// Before current
+			if (current == prev) break;
+		}
+		prev = current;
+		current = prev.next;
+	}
+	if (current)
+	{
+		// Insert after the current block.
+		// Are the blocks adjacent?
+		if (current == (Header*)((char*)(block + 1) + block.size))
+		{
+			// Merge
+			block.size += current.size + Header.sizeof;
+			block.next = current.next;
+		}
+		else
+		{
+			// Chain to current
+			block.next = current;
+		}
+	}
+	if (prev == current)
+	{
+		// Swap new start of free list
+		self.free_list = block;
+	}
+	else
+	{
+		// Prev adjacent?
+		if (block == (Header*)((char*)(prev + 1) + prev.size))
+		{
+			prev.size += block.size + Header.sizeof;
+			prev.next = block.next;
+		}
+		else
+		{
+			// Link prev to block
+			prev.next = block;
+		}
+	}
+}
+
+union Header @local
+{
+	struct
+	{
+		Header* next;
+		usz size;
+	}
+	usz align;
+}

lib/std/core/allocators/libc_allocator.c3

@@ -0,0 +1,166 @@
+// Copyright (c) 2021-2025 Christoffer Lerno. All rights reserved.
+// Use of this source code is governed by the MIT license
+// a copy of which can be found in the LICENSE_STDLIB file.
+module std::core::mem::allocator @if(env::LIBC);
+import std::io;
+import libc;
+
+<*
+ The LibcAllocator is a wrapper around malloc to conform to the Allocator interface.
+*>
+typedef LibcAllocator (Allocator) = uptr;
+const LibcAllocator LIBC_ALLOCATOR = {};
+
+module std::core::mem::allocator @if(env::POSIX);
+import std::os;
+import libc;
+
+fn void*? LibcAllocator.acquire(&self, usz bytes, AllocInitType init_type, usz alignment) @dynamic
+{
+	if (init_type == ZERO)
+	{
+		void* data @noinit;
+		if (alignment > mem::DEFAULT_MEM_ALIGNMENT)
+		{
+			if (posix::posix_memalign(&data, alignment, bytes)) return mem::OUT_OF_MEMORY~;
+			mem::clear(data, bytes, mem::DEFAULT_MEM_ALIGNMENT);
+			return data;
+		}
+		return libc::calloc(1, bytes) ?: mem::OUT_OF_MEMORY~;
+	}
+	else
+	{
+		void* data @noinit;
+		if (alignment > mem::DEFAULT_MEM_ALIGNMENT)
+		{
+			if (posix::posix_memalign(&data, alignment, bytes)) return mem::OUT_OF_MEMORY~;
+		}
+		else
+		{
+			if (!(data = libc::malloc(bytes))) return mem::OUT_OF_MEMORY~;
+		}
+		$if env::TESTING:
+			for (usz i = 0; i < bytes; i++) ((char*)data)[i] = 0xAA;
+		$endif
+		return data;
+	}
+}
+
+fn void*? LibcAllocator.resize(&self, void* old_ptr, usz new_bytes, usz alignment) @dynamic
+{
+ 	if (alignment <= mem::DEFAULT_MEM_ALIGNMENT) return libc::realloc(old_ptr, new_bytes) ?: mem::OUT_OF_MEMORY~;
+
+	// Try realloc, even though it might be unaligned.
+	void* new_ptr = libc::realloc(old_ptr, new_bytes) ?: mem::OUT_OF_MEMORY~!;
+
+	// If it's aligned then we're done!
+	uptr ptr_val = (uptr)new_ptr;
+	if (ptr_val & (alignment - 1) == 0) return new_ptr;
+
+	// We failed, so we need to use memalign
+	// We will free new_ptr before we exit.
+	defer libc::free(new_ptr);
+
+	// Create a pointer which is sure to be aligned.
+	void* aligned_ptr;
+	if (posix::posix_memalign(&aligned_ptr, alignment, new_bytes))
+	{
+		return mem::OUT_OF_MEMORY~;
+	}
+	// Now it is safe to copy the full range of data.
+	mem::copy(aligned_ptr, new_ptr, new_bytes, mem::DEFAULT_MEM_ALIGNMENT, mem::DEFAULT_MEM_ALIGNMENT);
+	return aligned_ptr;
+
+}
+
+
+fn void LibcAllocator.release(&self, void* old_ptr, bool aligned) @dynamic
+{
+	libc::free(old_ptr);
+}
+
+module std::core::mem::allocator @if(env::WIN32);
+import std::os::win32;
+import libc;
+
+fn void*? LibcAllocator.acquire(&self, usz bytes, AllocInitType init_type, usz alignment) @dynamic
+{
+	if (init_type == ZERO)
+	{
+		if (alignment > 0)
+		{
+			return win32::_aligned_recalloc(null, 1, bytes, alignment) ?: mem::OUT_OF_MEMORY~;
+		}
+		return libc::calloc(1, bytes) ?: mem::OUT_OF_MEMORY~;
+	}
+	void* data = alignment > 0 ? win32::_aligned_malloc(bytes, alignment) : libc::malloc(bytes);
+	if (!data) return mem::OUT_OF_MEMORY~;
+	$if env::TESTING:
+		for (usz i = 0; i < bytes; i++) ((char*)data)[i] = 0xAA;
+	$endif
+	return data;
+}
+
+fn void*? LibcAllocator.resize(&self, void* old_ptr, usz new_bytes, usz alignment) @dynamic
+{
+	if (alignment)
+	{
+		return win32::_aligned_realloc(old_ptr, new_bytes, alignment) ?: mem::OUT_OF_MEMORY~;
+	}
+	return libc::realloc(old_ptr, new_bytes) ?: mem::OUT_OF_MEMORY~;
+}
+
+fn void LibcAllocator.release(&self, void* old_ptr, bool aligned) @dynamic
+{
+	if (aligned)
+	{
+		win32::_aligned_free(old_ptr);
+		return;
+	}
+	libc::free(old_ptr);
+}
+
+module std::core::mem::allocator @if(!env::WIN32 && !env::POSIX && env::LIBC);
+import libc;
+
+fn void*? LibcAllocator.acquire(&self, usz bytes, AllocInitType init_type, usz alignment) @dynamic
+{
+	if (init_type == ZERO)
+	{
+		void* data = alignment ? @aligned_alloc(fn void*(usz bytes) => libc::calloc(bytes, 1), bytes, alignment)!! : libc::calloc(bytes, 1);
+		return data ?: mem::OUT_OF_MEMORY~;
+	}
+	else
+	{
+		void* data = alignment ? @aligned_alloc(libc::malloc, bytes, alignment)!! : libc::malloc(bytes);
+		if (!data) return mem::OUT_OF_MEMORY~;
+		$if env::TESTING:
+			for (usz i = 0; i < bytes; i++) ((char*)data)[i] = 0xAA;
+		$endif
+		return data;
+	}
+}
+
+
+fn void*? LibcAllocator.resize(&self, void* old_ptr, usz new_bytes, usz alignment) @dynamic
+{
+	if (alignment)
+	{
+		void* data = @aligned_realloc(fn void*(usz bytes) => libc::malloc(bytes), libc::free, old_ptr, new_bytes, alignment)!!;
+		return data ?: mem::OUT_OF_MEMORY~;
+	}
+	return libc::realloc(old_ptr, new_bytes) ?: mem::OUT_OF_MEMORY~;
+}
+
+
+fn void LibcAllocator.release(&self, void* old_ptr, bool aligned) @dynamic
+{
+	if (aligned)
+	{
+		@aligned_free(libc::free, old_ptr)!!;
+	}
+	else
+	{
+		libc::free(old_ptr);
+	}
+}

lib/std/core/allocators/mem_allocator_fn.c3

@@ -1,68 +0,0 @@
-module std::core::mem::allocator;
-import libc;
-
-private const Allocator _NULL_ALLOCATOR = { &null_allocator_fn };
-private const Allocator _SYSTEM_ALLOCATOR = { &libc_allocator_fn };
-
-private fn void*! null_allocator_fn(Allocator* this, usize bytes, usize alignment, void* old_pointer, AllocationKind kind)
-{
-	switch (kind)
-	{
-		case ALLOC:
-        case CALLOC:
-        case REALLOC:
-			return AllocationFailure.OUT_OF_MEMORY!;
-		default:
-			return null;
-	}
-}
-
-fn void*! libc_allocator_fn(Allocator* unused, usize bytes, usize alignment, void* old_pointer, AllocationKind kind) @inline
-{
-	if (!alignment) alignment = DEFAULT_MEM_ALIGNMENT;
-	assert(math::is_power_of_2(alignment), "Alignment was not a power of 2");
-
-    void* data;
-    switch (kind)
-    {
-        case ALLOC:
-            if (alignment > DEFAULT_MEM_ALIGNMENT)
-            {
-	            data = (void*)mem::aligned_offset((iptr)libc::malloc(bytes + alignment), alignment);
-            }
-            else
-            {
-                data = libc::malloc(bytes);
-            }
-            if (!data) return AllocationFailure.OUT_OF_MEMORY!;
-            return data;
-        case CALLOC:
-            if (alignment > DEFAULT_MEM_ALIGNMENT)
-            {
-	            data = (void*)mem::aligned_offset((iptr)libc::calloc(bytes + alignment, 1), alignment);
-            }
-            else
-            {
-                data = libc::malloc(bytes);
-            }
-            if (!data) return AllocationFailure.OUT_OF_MEMORY!;
-            return data;
-        case REALLOC:
-            if (alignment > DEFAULT_MEM_ALIGNMENT)
-            {
-	            data = (void*)mem::aligned_offset((iptr)libc::realloc(old_pointer, bytes + alignment), alignment);
-            }
-            else
-            {
-                data = libc::realloc(old_pointer, bytes);
-            }
-            if (!data) return AllocationFailure.OUT_OF_MEMORY!;
-            return data;
-        case RESET:
-            return AllocationFailure.UNSUPPORTED_OPERATION!;
-        case FREE:
-            libc::free(old_pointer);
-            return null;
-    }
-    unreachable();
-}

lib/std/core/allocators/memory_arena.c3

@@ -1,82 +0,0 @@
-module std::core::mem::allocator;
-
-/**
- * @require !alignment || math::is_power_of_2(alignment)
- * @require data `unexpectedly missing the allocator`
- */
-private fn void*! arena_allocator_function(Allocator* data, usize size, usize alignment, void* old_pointer, AllocationKind kind)
-{
-	MemoryArena* arena = (MemoryArena*)data;
-	switch (kind)
-	{
-		case CALLOC:
-		case ALLOC:
-			assert(!old_pointer, "Unexpected old pointer for alloc.");
-			if (!size) return null;
-			alignment = alignment_for_allocation(alignment);
-			void* mem = arena.alloc(size, alignment, DEFAULT_SIZE_PREFIX)?;
-			*(usize*)(mem - DEFAULT_SIZE_PREFIX) = size;
-			if (kind == AllocationKind.CALLOC) mem::set(mem, 0, size);
-        	return mem;
-		case REALLOC:
-			if (!size) nextcase FREE;
-			if (!old_pointer) nextcase ALLOC;
-			assert((uptr)old_pointer >= (uptr)arena.memory, "Pointer originates from a different allocator.");
-			if (size > arena.total) return AllocationFailure.OUT_OF_MEMORY!;
-			alignment = alignment_for_allocation(alignment);
-			usize* old_size_ptr = (usize*)(old_pointer - DEFAULT_SIZE_PREFIX);
-			usize old_size = *old_size_ptr;
-			// Do last allocation and alignment match?
-			if (arena.memory + arena.used  == old_pointer + old_size && mem::ptr_is_aligned(old_pointer, alignment))
-			{
-				if (old_size >= size)
-				{
-					*old_size_ptr = size;
-					arena.used -= old_size - size;
-					return old_pointer;
-				}
-				usize new_used = arena.used + size - old_size;
-				if (new_used > arena.total) return AllocationFailure.OUT_OF_MEMORY!;
-				arena.used = new_used;
-				*old_size_ptr = size;
-				return old_pointer;
-			}
-			// Otherwise just allocate new memory.
-			void* mem = arena.alloc(size, alignment, DEFAULT_SIZE_PREFIX)?;
-			*(usize*)(mem - DEFAULT_SIZE_PREFIX) = size;
-			mem::copy(mem, old_pointer, old_size);
-			return mem;
-		case FREE:
-			if (!old_pointer) return null;
-			assert((uptr)old_pointer >= (uptr)arena.memory, "Pointer originates from a different allocator.");
-			usize old_size = *(usize*)(old_pointer - DEFAULT_SIZE_PREFIX);
-			if (old_pointer + old_size == arena.memory + arena.used)
-        	{
-        		arena.used -= old_size;
-        	}
-        	return null;
-		case RESET:
-			arena.used = 0;
-			return null;
-	}
-	unreachable();
-}
-
-/**
- * @require alignment > 0 `alignment must be non zero`
- * @require math::is_power_of_2(alignment)
- * @require size > 0
- * @require alignment <= MAX_MEMORY_ALIGNMENT `alignment too big`
- * @require this != null
- **/
-private fn void*! MemoryArena.alloc(MemoryArena* this, usize size, usize alignment, usize prefixed_bytes = 0)
-{
-	void* start_mem = this.memory;
-	void* unaligned_pointer = start_mem + this.used + prefixed_bytes;
-	if ((uptr)unaligned_pointer < (uptr)start_mem) return AllocationFailure.OUT_OF_MEMORY!;
-	usize offset_start = mem::aligned_offset((usize)(uptr)unaligned_pointer, alignment) - (usize)(uptr)start_mem;
-	usize end = offset_start + size;
-	if (end > this.total || end < offset_start) return AllocationFailure.OUT_OF_MEMORY!;
-	this.used = end;
-	return start_mem + offset_start;
-}

lib/std/core/allocators/on_stack_allocator.c3

@@ -0,0 +1,158 @@
+module std::core::mem::allocator;
+import std::math;
+<*
+ The OnStackAllocator is similar to the ArenaAllocator: it allocates from a chunk of memory
+ given to it.
+
+ The difference is that when it runs out of memory it will go directly to its backing allocator
+ rather than failing.
+
+ It is utilized by the @stack_mem macro as an alternative to the temp allocator.
+*>
+struct OnStackAllocator (Allocator)
+{
+	Allocator backing_allocator;
+	char[] data;
+	usz used;
+	OnStackAllocatorExtraChunk* chunk;
+}
+
+struct OnStackAllocatorExtraChunk @local
+{
+	bool is_aligned;
+	OnStackAllocatorExtraChunk* prev;
+	void* data;
+}
+
+<*
+ Initialize a memory arena for use using the provided bytes.
+
+ @param [&inout] allocator
+*>
+fn void OnStackAllocator.init(&self, char[] data, Allocator allocator)
+{
+	self.data = data;
+	self.backing_allocator = allocator;
+	self.used = 0;
+}
+
+fn void OnStackAllocator.free(&self)
+{
+	OnStackAllocatorExtraChunk* chunk = self.chunk;
+	while (chunk)
+	{
+		if (chunk.is_aligned)
+		{
+			allocator::free_aligned(self.backing_allocator, chunk.data);
+		}
+		else
+		{
+			allocator::free(self.backing_allocator, chunk.data);
+		}
+		void* old = chunk;
+		chunk = chunk.prev;
+		allocator::free(self.backing_allocator, old);
+	}
+	self.chunk = null;
+	self.used = 0;
+}
+
+struct OnStackAllocatorHeader
+{
+	usz size;
+	char[*] data;
+}
+
+<*
+ @require old_pointer != null
+*>
+fn void OnStackAllocator.release(&self, void* old_pointer, bool aligned) @dynamic
+{
+	if (allocation_in_stack_mem(self, old_pointer)) return;
+	on_stack_allocator_remove_chunk(self, old_pointer);
+	self.backing_allocator.release(old_pointer, aligned);
+}
+
+fn bool allocation_in_stack_mem(OnStackAllocator* a, void* ptr) @local
+{
+	return ptr >= a.data.ptr && ptr <= &a.data[^1];
+}
+
+fn void on_stack_allocator_remove_chunk(OnStackAllocator* a, void* ptr) @local
+{
+	OnStackAllocatorExtraChunk* chunk = a.chunk;
+	OnStackAllocatorExtraChunk** addr = &a.chunk;
+	while (chunk)
+	{
+		if (chunk.data == ptr)
+		{
+			*addr = chunk.prev;
+			allocator::free(a.backing_allocator, chunk);
+			return;
+		}
+		addr = &chunk.prev;
+		chunk = *addr;
+	}
+	unreachable("Missing chunk");
+}
+
+fn OnStackAllocatorExtraChunk* on_stack_allocator_find_chunk(OnStackAllocator* a, void* ptr) @local
+{
+	OnStackAllocatorExtraChunk* chunk = a.chunk;
+	while (chunk)
+	{
+		if (chunk.data == ptr) return chunk;
+		chunk = chunk.prev;
+	}
+	return null;
+}
+
+<*
+ @require size > 0
+ @require old_pointer != null
+ @require alignment <= mem::MAX_MEMORY_ALIGNMENT : `alignment too big`
+*>
+fn void*? OnStackAllocator.resize(&self, void* old_pointer, usz size, usz alignment) @dynamic
+{
+	if (!allocation_in_stack_mem(self, old_pointer))
+	{
+		OnStackAllocatorExtraChunk* chunk = on_stack_allocator_find_chunk(self, old_pointer);
+		assert(chunk, "Tried to realloc pointer not belonging to the allocator");
+		return chunk.data = self.backing_allocator.resize(old_pointer, size, alignment)!;
+	}
+
+	OnStackAllocatorHeader* header = old_pointer - OnStackAllocatorHeader.sizeof;
+	usz old_size = header.size;
+	void* mem = self.acquire(size, NO_ZERO, alignment)!;
+	mem::copy(mem, old_pointer, math::min(old_size, size), mem::DEFAULT_MEM_ALIGNMENT, mem::DEFAULT_MEM_ALIGNMENT);
+	return mem;
+}
+
+<*
+ @require alignment <= mem::MAX_MEMORY_ALIGNMENT : `alignment too big`
+ @require size > 0
+*>
+fn void*? OnStackAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic
+{
+	bool aligned = alignment > 0;
+	alignment = alignment_for_allocation(alignment);
+	usz total_len = self.data.len;
+	void* start_mem = self.data.ptr;
+	void* unaligned_pointer_to_offset = start_mem + self.used + OnStackAllocatorHeader.sizeof ;
+	void* mem = mem::aligned_pointer(unaligned_pointer_to_offset, alignment);
+	usz end = (usz)(mem - self.data.ptr) + size;
+	Allocator backing_allocator = self.backing_allocator;
+
+	if (end > total_len)
+	{
+		OnStackAllocatorExtraChunk* chunk = allocator::alloc_try(backing_allocator, OnStackAllocatorExtraChunk)!;
+		defer catch allocator::free(backing_allocator, chunk);
+		defer try self.chunk = chunk;
+		*chunk = { .prev = self.chunk, .is_aligned = aligned };
+		return chunk.data = backing_allocator.acquire(size, init_type, aligned ? alignment : 0)!;
+	}
+	self.used = end;
+	OnStackAllocatorHeader* header = mem - OnStackAllocatorHeader.sizeof;
+	header.size = size;
+	return mem;
+}

lib/std/core/allocators/temp_allocator.c3

@@ -0,0 +1,409 @@
+module std::core::mem::allocator @if(!(env::POSIX || env::WIN32) || !$feature(VMEM_TEMP));
+import std::io, std::math;
+
+// This implements the temp allocator.
+// The temp allocator is a specialized allocator only intended for use where
+// the allocation is strictly stack-like.
+//
+// It is *not* thread-safe: you cannot safely use the
+// temp allocator on a thread and pass it to another thread.
+//
+// Fundamentally the temp allocator is a thread local arena allocator
+// but the stack-like behaviour puts additional constraints to it.
+//
+// It works great for allocating temporary data in a scope then dropping
+// that data, however you should not be storing temporary data in globals
+// or locals that have a lifetime outside of the current temp allocator scope.
+//
+// Furthermore, note that the temp allocator is bounded, with additional
+// allocations on top of that causing heap allocations. Such heap allocations
+// will be cleaned up but is undesirable from a performance standpoint.
+//
+// If you want customizable behaviour similar to the temp allocator, consider
+// the ArenaAllocator, BackedArenaAllocator or the DynamicArenaAllocator.
+//
+// Experimenting with the temp allocator to make it work outside of its
+// standard usage patterns will invariably end in tears and frustrated
+// hair pulling.
+//
+// Use one of the ArenaAllocators instead.
+
+struct TempAllocator (Allocator)
+{
+	Allocator backing_allocator;
+	TempAllocatorPage* last_page;
+	TempAllocator* derived;
+	bool allocated;
+	usz reserve_size;
+	usz realloc_size;
+	usz min_size;
+	usz used;
+	usz capacity;
+	usz original_capacity;
+	char[*] data;
+}
+
+struct TempAllocatorChunk @local
+{
+	usz size;
+	char[*] data;
+}
+
+const usz PAGE_IS_ALIGNED @local = (usz)isz.max + 1u;
+
+struct TempAllocatorPage
+{
+	TempAllocatorPage* prev_page;
+	void* start;
+	usz size;
+	usz ident;
+	char[*] data;
+}
+
+macro usz TempAllocatorPage.pagesize(&self) => self.size & ~PAGE_IS_ALIGNED;
+macro bool TempAllocatorPage.is_aligned(&self) => self.size & PAGE_IS_ALIGNED == PAGE_IS_ALIGNED;
+
+<*
+ @require size >= 64
+ @require realloc_size >= 64
+ @require allocator.type != TempAllocator.typeid : "You may not create a temp allocator with a TempAllocator as the backing allocator."
+ @require min_size > TempAllocator.sizeof + 64 : "Min size must meaningfully hold the data + some bytes"
+*>
+fn TempAllocator*? new_temp_allocator(Allocator allocator, usz size, usz reserve = temp_allocator_reserve_size, usz min_size = temp_allocator_min_size, usz realloc_size = temp_allocator_realloc_size)
+{
+	TempAllocator* temp = allocator::alloc_with_padding(allocator, TempAllocator, size)!;
+	temp.last_page = null;
+	temp.backing_allocator = allocator;
+	temp.used = 0;
+	temp.min_size = min_size;
+	temp.realloc_size = realloc_size;
+	temp.reserve_size = reserve;
+	temp.allocated = true;
+	temp.derived = null;
+	temp.original_capacity = temp.capacity = size;
+	return temp;
+}
+<*
+ @require !self.derived
+*>
+fn TempAllocator*? TempAllocator.derive_allocator(&self, usz reserve = 0)
+{
+	if (!reserve) reserve = self.reserve_size;
+	usz remaining = self.capacity - self.used;
+	void* mem @noinit;
+	usz size @noinit;
+	if (self.min_size + reserve > remaining)
+	{
+		return self.derived = new_temp_allocator(self.backing_allocator, self.realloc_size, self.reserve_size, self.min_size, self.realloc_size)!;
+	}
+	usz start = mem::aligned_offset(self.used + reserve, mem::DEFAULT_MEM_ALIGNMENT);
+	void* ptr = &self.data[start];
+	TempAllocator* temp = (TempAllocator*)ptr;
+	$if env::ADDRESS_SANITIZER:
+        asan::unpoison_memory_region(ptr, TempAllocator.sizeof);
+	$endif
+	temp.last_page = null;
+    temp.backing_allocator = self.backing_allocator;
+    temp.used = 0;
+    temp.min_size = self.min_size;
+    temp.reserve_size = self.reserve_size;
+    temp.realloc_size = self.realloc_size;
+    temp.allocated = false;
+    temp.derived = null;
+    temp.original_capacity = temp.capacity = self.capacity - start - TempAllocator.sizeof;
+    self.capacity = start;
+	self.derived = temp;
+    return temp;
+}
+
+<*
+ Reset the entire temp allocator, which will merge all the children into it.
+*>
+fn void TempAllocator.reset(&self)
+{
+	TempAllocator* child = self.derived;
+	if (!child) return;
+	while (child)
+	{
+		TempAllocator* old = child;
+		child = old.derived;
+		temp_allocator_destroy(old);
+	}
+	self.capacity = self.original_capacity;
+	$if env::ADDRESS_SANITIZER:
+		asan::poison_memory_region(&self.data[self.used], self.capacity - self.used);
+	$endif
+	self.derived = null;
+}
+
+<*
+ @require self.allocated : "Only a top level allocator should be freed."
+*>
+fn void TempAllocator.free(&self)
+{
+	self.reset();
+	temp_allocator_destroy(self);
+}
+
+fn void temp_allocator_destroy(TempAllocator* self)
+{
+	TempAllocatorPage *last_page = self.last_page;
+	while (last_page)
+	{
+		TempAllocatorPage *to_free = last_page;
+		last_page = last_page.prev_page;
+		_free_page(self, to_free)!!;
+	}
+	if (self.allocated)
+	{
+		allocator::free(self.backing_allocator, self);
+		return;
+	}
+	$if env::COMPILER_SAFE_MODE || env::ADDRESS_SANITIZER:
+    	$if env::COMPILER_SAFE_MODE && !env::ADDRESS_SANITIZER:
+    		self.data[0 : self.used] = 0xAA;
+		$else
+            asan::poison_memory_region(&self.data[0], self.used);
+    	$endif
+    $endif
+}
+
+fn void TempAllocator.release(&self, void* old_pointer, bool) @dynamic
+{
+	usz old_size = *(usz*)(old_pointer - DEFAULT_SIZE_PREFIX);
+	if (old_pointer + old_size == &self.data[self.used])
+	{
+		self.used -= old_size;
+		asan::poison_memory_region(&self.data[self.used], old_size);
+	}
+}
+
+
+
+fn void*? TempAllocator.resize(&self, void* pointer, usz size, usz alignment) @dynamic
+{
+	TempAllocatorChunk *chunk = pointer - TempAllocatorChunk.sizeof;
+	if (chunk.size == (usz)-1)
+	{
+		assert(self.last_page, "Realloc of non temp pointer");
+		// First grab the page
+		TempAllocatorPage *page = pointer - TempAllocatorPage.sizeof;
+		return _realloc_page(self, page, size, alignment);
+	}
+	bool is_realloc_of_last = chunk.size + pointer == &self.data[self.used];
+	if (is_realloc_of_last)
+	{
+		isz diff = size - chunk.size;
+		if (diff == 0) return pointer;
+		if (self.capacity - self.used > diff)
+		{
+			chunk.size += diff;
+			self.used += diff;
+			$if env::ADDRESS_SANITIZER:
+				if (diff < 0)
+				{
+					asan::poison_memory_region(pointer + chunk.size, -diff);
+				}
+				else
+				{
+					asan::unpoison_memory_region(pointer, chunk.size);
+				}
+			$endif
+			return pointer;
+		}
+	}
+	void* data = self.acquire(size, NO_ZERO, alignment)!;
+	usz len_to_copy = chunk.size > size ? size : chunk.size;
+	mem::copy(data, pointer, len_to_copy, mem::DEFAULT_MEM_ALIGNMENT, mem::DEFAULT_MEM_ALIGNMENT);
+	if (is_realloc_of_last)
+	{
+		self.used = (uptr)chunk - (uptr)&self.data;
+		$if env::ADDRESS_SANITIZER:
+			asan::poison_memory_region(chunk, TempAllocatorChunk.sizeof + chunk.size);
+		$endif
+	}
+	return data;
+}
+
+<*
+ @require size > 0
+ @require !alignment || math::is_power_of_2(alignment)
+ @require alignment <= mem::MAX_MEMORY_ALIGNMENT : `alignment too big`
+*>
+fn void*? TempAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic
+{
+	alignment = alignment_for_allocation(alignment);
+	void* start_mem = &self.data;
+	void* starting_ptr = start_mem + self.used;
+	void* aligned_header_start = mem::aligned_pointer(starting_ptr, TempAllocatorChunk.alignof);
+	void* mem = aligned_header_start + TempAllocatorChunk.sizeof;
+	if (alignment > TempAllocatorChunk.alignof)
+	{
+		mem = mem::aligned_pointer(mem, alignment);
+	}
+	usz new_usage = (usz)(mem - start_mem) + size;
+
+	// Arena allocation, simple!
+	if (new_usage <= self.capacity)
+	{
+		asan::unpoison_memory_region(starting_ptr, new_usage - self.used);
+		TempAllocatorChunk* chunk_start = mem - TempAllocatorChunk.sizeof;
+		chunk_start.size = size;
+		self.used = new_usage;
+		if (init_type == ZERO) mem::clear(mem, size, mem::DEFAULT_MEM_ALIGNMENT);
+		return mem;
+	}
+
+	// Fallback to backing allocator
+	TempAllocatorPage* page;
+
+	// We have something we need to align.
+	if (alignment > mem::DEFAULT_MEM_ALIGNMENT)
+	{
+		// This is actually simpler, since it will create the offset for us.
+		usz total_alloc_size = mem::aligned_offset(TempAllocatorPage.sizeof + size, alignment);
+		if (init_type == ZERO)
+		{
+			mem = allocator::calloc_aligned(self.backing_allocator, total_alloc_size, alignment)!;
+		}
+		else
+		{
+			mem = allocator::malloc_aligned(self.backing_allocator, total_alloc_size, alignment)!;
+		}
+		void* start = mem;
+		mem += mem::aligned_offset(TempAllocatorPage.sizeof, alignment);
+		page = (TempAllocatorPage*)mem - 1;
+		page.start = start;
+		page.size = size | PAGE_IS_ALIGNED;
+	}
+	else
+	{
+		// Here we might need to pad
+		usz padded_header_size = mem::aligned_offset(TempAllocatorPage.sizeof, mem::DEFAULT_MEM_ALIGNMENT);
+		usz total_alloc_size = padded_header_size + size;
+		void* alloc = self.backing_allocator.acquire(total_alloc_size, init_type, 0)!;
+
+		// Find the page.
+		page = alloc + padded_header_size - TempAllocatorPage.sizeof;
+		assert(mem::ptr_is_aligned(page, TempAllocator.alignof));
+		assert(mem::ptr_is_aligned(&page.data[0], mem::DEFAULT_MEM_ALIGNMENT));
+		page.start = alloc;
+		page.size = size;
+	}
+
+	// Mark it as a page
+	page.ident = ~(usz)0;
+	// Hook up the page.
+	page.prev_page = self.last_page;
+	self.last_page = page;
+	return &page.data[0];
+}
+
+
+fn void? _free_page(TempAllocator* self, TempAllocatorPage* page) @inline @local
+{
+	void* mem = page.start;
+	return self.backing_allocator.release(mem, page.is_aligned());
+}
+
+fn void*? _realloc_page(TempAllocator* self, TempAllocatorPage* page, usz size, usz alignment) @inline @local
+{
+	// Then the actual start pointer:
+	void* real_pointer = page.start;
+
+	// Walk backwards to find the pointer to this page.
+	TempAllocatorPage **pointer_to_prev = &self.last_page;
+	// Remove the page from the list
+	while (*pointer_to_prev != page)
+	{
+		pointer_to_prev = &((*pointer_to_prev).prev_page);
+	}
+	*pointer_to_prev = page.prev_page;
+	usz page_size = page.pagesize();
+	// Clear on size > original size.
+	void* data = self.acquire(size, NO_ZERO, alignment)!;
+	if (page_size > size) page_size = size;
+	mem::copy(data, &page.data[0], page_size, mem::DEFAULT_MEM_ALIGNMENT, mem::DEFAULT_MEM_ALIGNMENT);
+	self.backing_allocator.release(real_pointer, page.is_aligned());
+	return data;
+}
+
+module std::core::mem::allocator @if((env::POSIX || env::WIN32) && $feature(VMEM_TEMP));
+import std::math;
+
+
+tlocal VmemOptions temp_allocator_default_options = {
+	.shrink_on_reset = env::MEMORY_ENV != NORMAL,
+	.protect_unused_pages = env::COMPILER_OPT_LEVEL <= O1 || env::COMPILER_SAFE_MODE,
+	.scratch_released_data = env::COMPILER_SAFE_MODE
+};
+
+
+fn TempAllocator*? new_temp_allocator(Allocator allocator, usz size, usz reserve = temp_allocator_reserve_size, usz min_size = temp_allocator_min_size, usz realloc_size = temp_allocator_realloc_size)
+{
+	Vmem mem;
+	TempAllocator* t = allocator::new(allocator, TempAllocator);
+	defer catch allocator::free(allocator, t);
+	t.vmem.init(preferred_size: isz.sizeof > 4 ? 4 * mem::GB : 512 * mem::MB,
+	            reserve_page_size: isz.sizeof > 4 ? 256 * mem::KB : 0,
+	            options: temp_allocator_default_options)!;
+	t.allocator = allocator;
+	return t;
+}
+
+struct TempAllocator (Allocator)
+{
+	Vmem vmem;
+	TempAllocator* derived;
+	Allocator allocator;
+}
+
+<*
+ @require size > 0
+ @require !alignment || math::is_power_of_2(alignment)
+ @require alignment <= mem::MAX_MEMORY_ALIGNMENT : `alignment too big`
+*>
+fn void*? TempAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic
+{
+	return self.vmem.acquire(size, init_type, alignment) @inline;
+}
+
+fn TempAllocator*? TempAllocator.derive_allocator(&self, usz reserve = 0)
+{
+	if (self.derived) return self.derived;
+	return self.derived = new_temp_allocator(self.allocator, 0)!;
+}
+
+<*
+ Reset the entire temp allocator, destroying all children
+*>
+fn void TempAllocator.reset(&self)
+{
+	TempAllocator* child = self.derived;
+	if (!child) return;
+	child.reset();
+	child.vmem.reset(0);
+}
+fn void TempAllocator.free(&self)
+{
+	_destroy(self);
+}
+
+fn void _destroy(TempAllocator* self) @local
+{
+	TempAllocator* child = self.derived;
+	if (!child) return;
+	child.destroy();
+	self.vmem.free() @inline;
+	allocator::free(self.allocator, self) @inline;
+}
+
+fn void*? TempAllocator.resize(&self, void* pointer, usz size, usz alignment) @dynamic
+{
+	return self.vmem.resize(pointer, size, alignment) @inline;
+}
+
+fn void TempAllocator.release(&self, void* old_pointer, bool b) @dynamic
+{
+	self.vmem.release(old_pointer, b) @inline;
+}

lib/std/core/allocators/tracking_allocator.c3

@@ -0,0 +1,234 @@
+// Copyright (c) 2021-2025 Christoffer Lerno. All rights reserved.
+// Use of this source code is governed by the MIT license
+// a copy of which can be found in the LICENSE_STDLIB file.
+
+module std::core::mem::allocator;
+import std::collections, std::io, std::os::backtrace;
+
+const MAX_BACKTRACE = 16;
+struct Allocation
+{
+	void* ptr;
+	usz size;
+	void*[MAX_BACKTRACE] backtrace;
+}
+
+alias AllocMap = HashMap { uptr, Allocation };
+
+// A simple tracking allocator.
+// It tracks allocations using a hash map but
+// is not compatible with allocators that uses mark()
+//
+// It is also embarrassingly single-threaded, so
+// do not use it to track allocations that cross threads.
+
+struct TrackingAllocator (Allocator)
+{
+	Allocator inner_allocator;
+	AllocMap map;
+	usz mem_total;
+	usz allocs_total;
+	usz usage;
+	usz max_usage;
+}
+
+<*
+ Initialize a tracking allocator to wrap (and track) another allocator.
+
+ @param [&inout] allocator : "The allocator to track"
+*>
+fn void TrackingAllocator.init(&self, Allocator allocator)
+{
+	*self = { .inner_allocator = allocator };
+	self.map.init(allocator);
+}
+
+<*
+ Free this tracking allocator.
+*>
+fn void TrackingAllocator.free(&self)
+{
+	self.map.free();
+	*self = {};
+}
+
+<*
+ @return "the total allocated memory not yet freed."
+*>
+fn usz TrackingAllocator.allocated(&self) => @pool()
+{
+	usz allocated = 0;
+	foreach (&allocation : self.map.tvalues()) allocated += allocation.size;
+	return allocated;
+}
+
+<*
+ @return "the total memory allocated (freed or not)."
+*>
+fn usz TrackingAllocator.total_allocated(&self) => self.mem_total;
+
+<*
+ @return "the total number of allocations (freed or not)."
+*>
+fn usz TrackingAllocator.total_allocation_count(&self) => self.allocs_total;
+
+<*
+ @return "the maximum amount of memory allocated"
+*>
+fn usz TrackingAllocator.max_allocated(&self) => self.max_usage;
+
+fn Allocation[] TrackingAllocator.allocations_tlist(&self, Allocator allocator)
+{
+	return self.map.tvalues();
+}
+
+<*
+ @return "the number of non-freed allocations."
+*>
+fn usz TrackingAllocator.allocation_count(&self) => self.map.count;
+
+fn void*? TrackingAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic
+{
+	void* data = self.inner_allocator.acquire(size, init_type, alignment)!;
+	self.allocs_total++;
+	void*[MAX_BACKTRACE] bt;
+	backtrace::capture_current(&bt);
+	self.map.set((uptr)data, { data, size, bt });
+	self.mem_total += size;
+	self.usage += size;
+	if (self.usage > self.max_usage) self.max_usage = self.usage;
+	return data;
+}
+
+fn void*? TrackingAllocator.resize(&self, void* old_pointer, usz size, usz alignment) @dynamic
+{
+	void* data = self.inner_allocator.resize(old_pointer, size, alignment)!;
+	self.usage -= self.map[(uptr)old_pointer]!!.size;
+	self.map.remove((uptr)old_pointer);
+	void*[MAX_BACKTRACE] bt;
+	backtrace::capture_current(&bt);
+	self.map.set((uptr)data, { data, size, bt });
+	self.mem_total += size;
+	self.usage += size;
+	if (self.usage > self.max_usage) self.max_usage = self.usage;
+	self.allocs_total++;
+	return data;
+}
+
+fn void TrackingAllocator.release(&self, void* old_pointer, bool is_aligned) @dynamic
+{
+	usz? old_size = self.map[(uptr)old_pointer].size;
+	if (catch self.map.remove((uptr)old_pointer))
+	{
+		unreachable("Attempt to release untracked pointer %p, this is likely a bug.", old_pointer);
+	}
+	self.usage -= old_size!!;
+	self.inner_allocator.release(old_pointer, is_aligned);
+}
+
+fn void TrackingAllocator.clear(&self)
+{
+	self.map.clear();
+}
+
+fn bool TrackingAllocator.has_leaks(&self)
+{
+	return self.map.len() > 0;
+}
+
+fn void TrackingAllocator.print_report(&self) => self.fprint_report(io::stdout())!!;
+
+
+fn void? TrackingAllocator.fprint_report(&self, OutStream out) => @pool()
+{
+	usz total = 0;
+	usz entries = 0;
+	bool leaks = false;
+
+	Allocation[] allocs = self.map.tvalues();
+	if (allocs.len)
+	{
+		if (!allocs[0].backtrace[0])
+		{
+			io::fprintn(out, "======== Memory Report ========")!;
+			io::fprintn(out, "Size in bytes   Address")!;
+			foreach (i, &allocation : allocs)
+			{
+				entries++;
+				total += allocation.size;
+				io::fprintfn(out, "%13s   %p", allocation.size, allocation.ptr)!;
+			}
+			io::fprintn(out, "===============================")!;
+
+		}
+		else
+		{
+			io::fprintn(out, "================================== Memory Report ==================================")!;
+			io::fprintn(out, "Size in bytes   Address          Function                       ")!;
+			foreach (i, &allocation : allocs)
+			{
+				entries++;
+				total += allocation.size;
+				BacktraceList backtraces = {};
+				Backtrace trace = backtrace::BACKTRACE_UNKNOWN;
+				if (allocation.backtrace[3])
+				{
+					trace = backtrace::symbolize_backtrace(tmem, allocation.backtrace[3:1]).get(0) ?? backtrace::BACKTRACE_UNKNOWN;
+				}
+				if (trace.function.len)	leaks = true;
+				io::fprintfn(out, "%13s   %p   %s:%d", allocation.size,
+					allocation.ptr, trace.function.len ? trace.function : "???",
+					trace.line ? trace.line : 0)!;
+			}
+			io::fprintn(out, "===================================================================================")!;
+		}
+	}
+	else
+	{
+		io::fprintn(out, "* NO ALLOCATIONS FOUND *")!;
+	}
+	io::fprintfn(out, "- Total currently allocated memory:            %d", total)!;
+	io::fprintfn(out, "- Total current allocations:                   %d", entries)!;
+	io::fprintfn(out, "- Total allocations (freed and retained):      %d", self.allocs_total)!;
+	io::fprintfn(out, "- Total allocated memory (freed and retained): %d", self.mem_total)!;
+	io::fprintfn(out, "- Maximum memory usage:                        %d", self.max_usage)!;
+	if (leaks)
+	{
+		io::fprintn(out)!;
+		io::fprintn(out, "Full leak report:")!;
+		foreach (i, &allocation : allocs)
+		{
+			if (!allocation.backtrace[3])
+			{
+				io::fprintfn(out, "Allocation %d (%d bytes) - no backtrace available.", i + 1, allocation.size)!;
+				continue;
+			}
+			BacktraceList backtraces = {};
+			usz end = MAX_BACKTRACE;
+			foreach (j, val : allocation.backtrace)
+			{
+				if (!val)
+				{
+					end = j;
+					break;
+				}
+			}
+			BacktraceList list = backtrace::symbolize_backtrace(tmem, allocation.backtrace[3..(end - 1)])!;
+			io::fprintfn(out, "Allocation %d (%d bytes): ", i + 1, allocation.size)!;
+			foreach (trace : list)
+			{
+				if (trace.has_file())
+				{
+					io::fprintfn(out, "   %s (in %s:%d)", trace.function, trace.file, trace.line);
+					continue;
+				}
+				if (trace.is_unknown())
+				{
+					io::fprintfn(out, "   ??? (in unknown)");
+					continue;
+				}
+				io::fprintfn(out, "   %s (source unavailable)", trace.function);
+			}
+		}
+	}
+}

lib/std/core/allocators/vmem.c3

@@ -0,0 +1,255 @@
+module std::core::mem::allocator @if(env::POSIX || env::WIN32);
+import std::math, std::os::posix, libc, std::bits;
+import std::core::mem;
+import std::core::env;
+
+
+
+// Virtual Memory allocator
+
+faultdef VMEM_RESERVE_FAILED;
+
+struct Vmem (Allocator)
+{
+	VirtualMemory memory;
+	usz allocated;
+	usz pagesize;
+	usz page_pot;
+	usz last_page;
+	usz high_water;
+	VmemOptions options;
+}
+
+bitstruct VmemOptions : int
+{
+	<* Release memory on reset *>
+	bool shrink_on_reset;
+	<* Protect unused pages on reset *>
+	bool protect_unused_pages;
+	<* Overwrite released data with 0xAA *>
+	bool scratch_released_data;
+}
+
+<*
+ Implements the Allocator interface method.
+
+ @require !reserve_page_size || math::is_power_of_2(reserve_page_size)
+ @require reserve_page_size <= preferred_size : "The min reserve_page_size size must be less or equal to the preferred size"
+ @require preferred_size >= 1 * mem::KB : "The preferred size must exceed 1 KB"
+ @return? mem::INVALID_ALLOC_SIZE, mem::OUT_OF_MEMORY, VMEM_RESERVE_FAILED
+*>
+fn void? Vmem.init(&self, usz preferred_size, usz reserve_page_size = 0, VmemOptions options = { true, true, env::COMPILER_SAFE_MODE }, usz min_size = 0)
+{
+	static usz page_size = 0;
+	if (!page_size) page_size = mem::os_pagesize();
+	if (page_size < reserve_page_size) page_size = reserve_page_size;
+	preferred_size = mem::aligned_offset(preferred_size, page_size);
+	if (!min_size) min_size = max(preferred_size / 1024, 1);
+	VirtualMemory? memory = mem::OUT_OF_MEMORY~;
+	while (preferred_size >= min_size)
+	{
+		memory = vm::virtual_alloc(preferred_size, PROTECTED);
+		// It worked?
+		if (try memory) break;
+		switch (@catch(memory))
+		{
+			case mem::OUT_OF_MEMORY:
+			case vm::RANGE_OVERFLOW:
+				// Try a smaller size.
+				preferred_size /= 2;
+				continue;
+			default:
+				break;
+		}
+	}
+	if (catch memory) return VMEM_RESERVE_FAILED~;
+	if (page_size > preferred_size) page_size = preferred_size;
+	$if env::ADDRESS_SANITIZER:
+		asan::poison_memory_region(memory.ptr, memory.size);
+	$endif
+	*self = { .memory = memory,
+	          .high_water = 0,
+			  .pagesize = page_size,
+			  .page_pot = page_size.ctz(),
+			  .options  = options,
+	        };
+}
+
+<*
+ Implements the Allocator interface method.
+
+ @require !alignment || math::is_power_of_2(alignment)
+ @require alignment <= mem::MAX_MEMORY_ALIGNMENT : `alignment too big`
+ @require size > 0
+ @return? mem::INVALID_ALLOC_SIZE, mem::OUT_OF_MEMORY
+*>
+fn void*? Vmem.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic
+{
+	alignment = alignment_for_allocation(alignment);
+	usz total_len = self.memory.size;
+	if (size > total_len) return mem::INVALID_ALLOC_SIZE~;
+	void* start_mem = self.memory.ptr;
+	void* unaligned_pointer_to_offset = start_mem + self.allocated + VmemHeader.sizeof;
+	void* mem = mem::aligned_pointer(unaligned_pointer_to_offset, alignment);
+	usz after = (usz)(mem - start_mem) + size;
+	if (after > total_len) return mem::OUT_OF_MEMORY~;
+	if (init_type == ZERO && self.high_water <= self.allocated)
+	{
+		init_type = NO_ZERO;
+	}
+	protect(self, after)!;
+	VmemHeader* header = mem - VmemHeader.sizeof;
+	header.size = size;
+	if (init_type == ZERO) mem::clear(mem, size, mem::DEFAULT_MEM_ALIGNMENT);
+	return mem;
+}
+
+fn bool Vmem.owns_pointer(&self, void* ptr) @inline
+{
+	return (uptr)ptr >= (uptr)self.memory.ptr && (uptr)ptr < (uptr)self.memory.ptr + self.memory.size;
+}
+<*
+ Implements the Allocator interface method.
+
+ @require !alignment || math::is_power_of_2(alignment)
+ @require alignment <= mem::MAX_MEMORY_ALIGNMENT : `alignment too big`
+ @require old_pointer != null
+ @require size > 0
+ @return? mem::INVALID_ALLOC_SIZE, mem::OUT_OF_MEMORY
+*>
+fn void*? Vmem.resize(&self, void *old_pointer, usz size, usz alignment) @dynamic
+{
+	if (size > self.memory.size) return mem::INVALID_ALLOC_SIZE~;
+	alignment = alignment_for_allocation(alignment);
+	assert(self.owns_pointer(old_pointer), "Pointer originates from a different allocator: %p, not in %p - %p", old_pointer, self.memory.ptr, self.memory.ptr + self.allocated);
+	VmemHeader* header = old_pointer - VmemHeader.sizeof;
+    usz old_size = header.size;
+    if (old_size == size) return old_pointer;
+    // Do last allocation and alignment match?
+    if (self.memory.ptr + self.allocated == old_pointer + old_size && mem::ptr_is_aligned(old_pointer, alignment))
+    {
+    	if (old_size > size)
+    	{
+    		unprotect(self, self.allocated + size - old_size);
+    	}
+    	else
+    	{
+    		usz allocated = self.allocated + size - old_size;
+    		if (allocated > self.memory.size) return mem::OUT_OF_MEMORY~;
+    		protect(self, allocated)!;
+    	}
+    	header.size = size;
+    	return old_pointer;
+    }
+    if (old_size > size)
+    {
+        $if env::ADDRESS_SANITIZER:
+    	    asan::poison_memory_region(old_pointer + size, old_size - size);
+    	$endif
+    	header.size = size;
+    	return old_pointer;
+    }
+    // Otherwise just allocate new memory.
+    void* mem = self.acquire(size, NO_ZERO, alignment)!;
+    assert(size > old_size);
+    mem::copy(mem, old_pointer, old_size, mem::DEFAULT_MEM_ALIGNMENT, mem::DEFAULT_MEM_ALIGNMENT);
+    return mem;
+}
+
+<*
+ Implements the Allocator interface method.
+
+ @require ptr != null
+*>
+fn void Vmem.release(&self, void* ptr, bool) @dynamic
+{
+	assert(self.owns_pointer(ptr), "Pointer originates from a different allocator %p.", ptr);
+	VmemHeader* header = ptr - VmemHeader.sizeof;
+	// Reclaim memory if it's the last element.
+	if (ptr + header.size == self.memory.ptr + self.allocated)
+	{
+		unprotect(self, self.allocated - header.size - VmemHeader.sizeof);
+	}
+}
+
+fn usz Vmem.mark(&self)
+{
+	return self.allocated;
+}
+
+<*
+ @require mark <= self.allocated : "Invalid mark"
+*>
+fn void Vmem.reset(&self, usz mark)
+{
+	if (mark == self.allocated) return;
+	unprotect(self, mark);
+}
+
+fn void Vmem.free(&self)
+{
+	if (!self.memory.ptr) return;
+	$switch:
+		$case env::ADDRESS_SANITIZER:
+			asan::poison_memory_region(self.memory.ptr, self.memory.size);
+		$case env::COMPILER_SAFE_MODE:
+    	    ((char*)self.memory.ptr)[0:self.allocated] = 0xAA;
+	$endswitch
+	(void)self.memory.destroy();
+	*self = {};
+}
+
+// Internal data
+
+struct VmemHeader @local
+{
+	usz size;
+	char[*] data;
+}
+
+macro void? protect(Vmem* mem, usz after) @local
+{
+	usz shift = mem.page_pot;
+	usz page_after = (after + mem.pagesize - 1) >> shift;
+	usz last_page = mem.last_page;
+	bool over_high_water = mem.high_water < after;
+	if (page_after > last_page)
+	{
+		usz page_start = last_page << shift;
+		usz page_len = (page_after - last_page) << shift;
+		mem.memory.commit(page_start, page_len)!;
+		if (mem.options.protect_unused_pages || over_high_water)
+		{
+			mem.memory.protect(page_start, page_len, READWRITE)!;
+		}
+		mem.last_page = page_after;
+	}
+	$if env::ADDRESS_SANITIZER:
+		asan::unpoison_memory_region(mem.memory.ptr + mem.allocated, after - mem.allocated);
+	$endif
+	mem.allocated = after;
+	if (over_high_water) mem.high_water = after;
+}
+
+macro void unprotect(Vmem* mem, usz after) @local
+{
+	usz shift = mem.page_pot;
+	usz last_page = mem.last_page;
+	usz page_after = mem.last_page = (after + mem.pagesize - 1) >> shift;
+	$if env::ADDRESS_SANITIZER:
+		asan::poison_memory_region(mem.memory.ptr + after, mem.allocated - after);
+	$else
+		if (mem.options.scratch_released_data)
+		{
+			mem::set(mem.memory.ptr + after, 0xAA, mem.allocated - after);
+		}
+	$endif
+	if ((mem.options.shrink_on_reset || mem.options.protect_unused_pages) && page_after < last_page)
+	{
+		usz start = page_after << shift;
+		usz len = (last_page - page_after) << shift;
+		if (mem.options.shrink_on_reset) (void)mem.memory.decommit(start, len, false);
+		if (mem.options.protect_unused_pages) (void)mem.memory.protect(start, len, PROTECTED);
+	}
+	mem.allocated = after;
+}

lib/std/core/ansi.c3

@@ -0,0 +1,165 @@
+module std::core::string::ansi;
+import std::io;
+
+constdef Ansi : inline String
+{
+	RESET              = "\e[0m",
+	BOLD               = "\e[1m",
+	DIM                = "\e[2m",
+	ITALIC             = "\e[3m",
+	UNDERLINE          = "\e[4m",
+	BLINK              = "\e[5m",
+	BLINK_FAST         = "\e[6m",
+	INVERT             = "\e[7m",
+	HIDDEN             = "\e[8m",
+	STRIKETHROUGH      = "\e[9m",
+	DOUBLE_UNDER       = "\e[21m",
+	NO_DIM             = "\e[22m",
+	NO_ITALIC          = "\e[23m",
+	NO_UNDERLINE       = "\e[24m",
+	NO_BLINK           = "\e[25m",
+	NO_INVERT          = "\e[27m",
+	NO_HIDDEN          = "\e[28m",
+	NO_STRIKETHROUGH   = "\e[29m",
+	BLACK              = "\e[30m",
+	RED                = "\e[31m",
+	GREEN              = "\e[32m",
+	YELLOW             = "\e[33m",
+	BLUE               = "\e[34m",
+	MAGENTA            = "\e[35m",
+	CYAN               = "\e[36m",
+	WHITE              = "\e[37m",
+	DEFAULT            = "\e[39m",
+	BRIGHT_BLACK       = "\e[90m",
+	BRIGHT_RED         = "\e[91m",
+	BRIGHT_GREEN       = "\e[92m",
+	BRIGHT_YELLOW      = "\e[93m",
+	BRIGHT_BLUE        = "\e[94m",
+	BRIGHT_MAGENTA     = "\e[95m",
+	BRIGHT_CYAN        = "\e[96m",
+	BRIGHT_WHITE       = "\e[97m",
+	BG_BLACK           = "\e[40m",
+	BG_RED             = "\e[41m",
+	BG_GREEN           = "\e[42m",
+	BG_YELLOW          = "\e[43m",
+	BG_BLUE            = "\e[44m",
+	BG_MAGENTA         = "\e[45m",
+	BG_CYAN            = "\e[46m",
+	BG_WHITE           = "\e[47m",
+	BG_DEFAULT         = "\e[49m",
+	BG_BRIGHT_BLACK    = "\e[100m",
+	BG_BRIGHT_RED      = "\e[101m",
+	BG_BRIGHT_GREEN    = "\e[102m",
+	BG_BRIGHT_YELLOW   = "\e[103m",
+	BG_BRIGHT_BLUE     = "\e[104m",
+	BG_BRIGHT_MAGENTA  = "\e[105m",
+	BG_BRIGHT_CYAN     = "\e[106m",
+	BG_BRIGHT_WHITE    = "\e[107m",
+}
+
+struct AnsiColor (Printable)
+{
+	char r, g, b;
+	bool bg;
+}
+
+fn usz? AnsiColor.to_format(&self, Formatter* fmt) @dynamic
+{
+	return fmt.printf("\e[%s8;2;%s;%s;%sm", self.bg ? 4 : 3, self.r, self.g, self.b);
+}
+
+<*
+ 24-bit color code
+
+ @return `A struct that, when formatted with '%s', sets the foreground or background colour to the specified rgb value`
+*>
+fn AnsiColor get_color_rgb(char r, char g, char b, bool bg = false)
+{
+	return {r, g, b, bg};
+}
+
+<*
+ 24-bit color code
+
+ @return `A struct that, when formatted with '%s', sets the foreground or background colour of printed text to the specified rgb value`
+*>
+fn AnsiColor get_color(uint rgb, bool bg = false)
+{
+	return {(char)(rgb >> 16), (char)((rgb & 0x00FF00) >> 8), (char)rgb, bg};
+}
+
+<*
+ 8-bit color code
+
+ @return `the formatting char for the given background color`
+*>
+macro String color_8bit(char $index, bool $bg = false) @const
+{
+	int $mode = $bg ? 4 : 3;
+	return @sprintf("\e[%s8;5;%sm", $mode, $index);
+}
+
+<*
+ 24-bit color code
+
+ @return `the string for the given foreground color`
+*>
+macro String color_rgb(char $r, char $g, char $b, bool $bg = false) @const
+{
+	int $mode = $bg ? 4 : 3;
+	return @sprintf("\e[%s8;2;%s;%s;%sm", $mode, $r, $g, $b);
+}
+
+<*
+ 24-bit color code rgb
+
+ @require $rgb <= 0xFF_FF_FF : `Expected a 24 bit RGB value`
+ @return `the string char for the given foreground color`
+*>
+macro String color(uint $rgb, bool $bg = false) @const
+{
+	int $mode = $bg ? 4 : 3;
+	return @sprintf("\e[%s8;2;%s;%s;%sm", $mode, $rgb >> 16, ($rgb & 0xFF00) >> 8, $rgb & 0xFF);
+}
+
+<*
+ 24-bit color code rgb
+
+ @require rgb <= 0xFF_FF_FF : `Expected a 24 bit RGB value`
+ @return `the string char for the given foreground color`
+*>
+fn String make_color(Allocator mem, uint rgb, bool bg = false) @deprecated("use get_color instead")
+{
+	return make_color_rgb(mem, (char)(rgb >> 16), (char)((rgb & 0xFF00) >> 8), (char)rgb, bg);
+}
+
+<*
+ 24-bit color code rgb
+
+ @require rgb <= 0xFF_FF_FF : `Expected a 24 bit RGB value`
+ @return `the string char for the given foreground color`
+*>
+fn String make_tcolor(uint rgb, bool bg = false) @deprecated("use get_color instead")
+{
+	return make_color_rgb(tmem, (char)(rgb >> 16), (char)((rgb & 0xFF00) >> 8), (char)rgb, bg);
+}
+
+<*
+ 24-bit color code rgb
+
+ @return `the string char for the given foreground color`
+*>
+fn String make_color_rgb(Allocator mem, char r, char g, char b, bool bg = false) @deprecated("use get_color_rgb instead")
+{
+	return string::format(mem, "\e[%s8;2;%s;%s;%sm", bg ? 4 : 3, r, g, b);
+}
+
+<*
+ 24-bit color code rgb
+
+ @return `the string char for the given foreground color`
+*>
+fn String make_tcolor_rgb(char r, char g, char b, bool bg = false) @deprecated("use get_color_rgb instead")
+{
+	return string::format(tmem, "\e[%s8;2;%s;%s;%sm", bg ? 4 : 3, r, g, b);
+}

lib/std/core/array.c3

@@ -0,0 +1,619 @@
+module std::core::array;
+import std::collections::pair, std::io;
+
+<*
+ Returns true if the array contains at least one element, else false
+
+ @param [in] array
+ @param [in] element
+ @require $kindof(array) == SLICE || $kindof(array) == ARRAY
+ @require @typematch(array[0], element) : "array and element must have the same type"
+*>
+macro bool contains(array, element)
+{
+	foreach (&item : array)
+	{
+		if (*item == element) return true;
+	}
+	return false;
+}
+
+
+<*
+ Return the first index of element found in the array, searching from the start.
+
+ @param [in] array
+ @param [in] element
+ @require $kindof(array) == SLICE || $kindof(array) == ARRAY
+ @require @typematch(array[0], element) : "array and element must have the same type"
+ @return "the first index of the element"
+ @return? NOT_FOUND
+*>
+macro usz? index_of(array, element)
+{
+	foreach (i, &e : array)
+	{
+		if (*e == element) return i;
+	}
+	return NOT_FOUND~;
+}
+
+
+<*
+ Slice a 2d array and create a Slice2d from it.
+
+ @param array_ptr : "the pointer to create a slice from"
+ @param x : "The starting position of the slice x, optional"
+ @param y : "The starting position of the slice y, optional"
+ @param xlen : "The length of the slice in x, defaults to the length of the array"
+ @param ylen : "The length of the slice in y, defaults to the length of the array"
+ @return "A Slice2d from the array"
+ @require $kindof(array_ptr) == POINTER
+ @require $kindof(*array_ptr) == VECTOR || $kindof(*array_ptr) == ARRAY
+ @require $kindof((*array_ptr)[0]) == VECTOR || $kindof((*array_ptr)[0]) == ARRAY
+*>
+macro slice2d(array_ptr, x = 0, xlen = 0, y = 0, ylen = 0)
+{
+	if (xlen < 1) xlen = $typeof((*array_ptr)[0]).len + xlen;
+	if (ylen < 1) ylen = $typeof((*array_ptr)).len + ylen;
+	var $ElementType = $typeof((*array_ptr)[0][0]);
+	return (Slice2d{$ElementType}) { ($ElementType*)array_ptr, $typeof((*array_ptr)[0]).len, y, ylen, x, xlen };
+}
+
+
+<*
+ Return the first index of element found in the array, searching in reverse from the end.
+
+ @param [in] array
+ @param [in] element
+ @return "the last index of the element"
+ @return? NOT_FOUND
+*>
+macro usz? rindex_of(array, element)
+{
+	foreach_r (i, &e : array)
+	{
+		if (*e == element) return i;
+	}
+	return NOT_FOUND~;
+}
+
+
+<*
+ Concatenate two arrays or slices, returning a slice containing the concatenation of them.
+
+ @param [in] arr1
+ @param [in] arr2
+ @param [&inout] allocator : "The allocator to use, default is the heap allocator"
+ @require $kindof(arr1) == SLICE || $kindof(arr1) == ARRAY
+ @require $kindof(arr2) == SLICE || $kindof(arr2) == ARRAY
+ @require @typematch(arr1[0], arr2[0]) : "Arrays must have the same type"
+ @ensure result.len == arr1.len + arr2.len
+*>
+macro concat(Allocator allocator, arr1, arr2) @nodiscard
+{
+	var $Type = $typeof(arr1[0]);
+	$Type[] result = allocator::alloc_array(allocator, $Type, arr1.len + arr2.len);
+	if (arr1.len > 0)
+	{
+		mem::copy(result.ptr, &arr1[0], arr1.len * $Type.sizeof, $Type.alignof, $Type.alignof);
+	}
+	if (arr2.len > 0)
+	{
+		mem::copy(&result[arr1.len], &arr2[0], arr2.len * $Type.sizeof, $Type.alignof, $Type.alignof);
+	}
+	return result;
+}
+
+<*
+ Concatenate two arrays or slices, returning a slice containing the concatenation of them,
+ allocated using the temp allocator.
+
+ @param [in] arr1
+ @param [in] arr2
+ @require $kindof(arr1) == SLICE || $kindof(arr1) == ARRAY
+ @require $kindof(arr2) == SLICE || $kindof(arr2) == ARRAY
+ @require @typematch(arr1[0], arr2[0]) : "Arrays must have the same type"
+ @ensure return.len == arr1.len + arr2.len
+*>
+macro tconcat(arr1, arr2) @nodiscard => concat(tmem, arr1, arr2);
+
+
+<*
+ Apply a reduction/folding operation to an iterable type. This walks along the input array
+ and applies an `#operation` to each value, returning it to the `identity` (or "accumulator")
+ base value.
+
+ For example:
+ ```c3
+ int[] my_slice = { 1, 8, 12 };
+ int folded = array::@reduce(my_slice, 2, fn (i, e) => i * e);
+ assert(folded == (2 * 1 * 8 * 12));
+ ```
+
+ Notice how the given `identity` value started the multiplication chain at 2. When enumerating
+ `my_slice`, each element is accumulated onto the `identity` value with each sequential iteration.
+ ```
+ i = 2;   // identity value
+ i *= 1;   // my_slice[0]
+ i *= 8;   // my_slice[1]
+ i *= 12;   // my_slice[2]
+ ```
+
+ @param [in] array
+ @param identity
+ @param #operation : "The reduction/folding lambda function or function pointer to apply."
+
+ @require @is_valid_list(array) : "Expected a valid list"
+ @require $defined($typefrom(@reduce_fn(array, identity)) $func = #operation) : "Invalid lambda or function pointer type"
+*>
+macro @reduce(array, identity, #operation)
+{
+	$typefrom(@reduce_fn(array, identity)) $func = #operation;
+	foreach (index, element : array) identity = $func(identity, element, index);
+	return identity;
+}
+
+<*
+ Apply a summation operator (+) to an identity value across a span of array elements
+ and return the final accumulated result.
+
+ @pure
+
+ @param [in] array
+ @param identity_value : "The base accumulator value to use for the sum"
+
+ @require @is_valid_list(array) : "Expected a valid list"
+ @require $defined(array[0] + array[0]) : "Array element type must implement the '+' operator"
+ @require $defined($typeof(array[0]) t = identity_value) : "The identity type must be assignable to the array element type"
+*>
+macro @sum(array, identity_value = 0)
+{
+	return @reduce(array, ($typeof(array[0]))identity_value, fn (acc, e, u) => acc + e);
+}
+
+<*
+ Apply a product operator (*) to an identity value across a span of array elements
+ and return the final accumulated result.
+
+ @pure
+
+ @param [in] array
+ @param identity_value : "The base accumulator value to use for the product"
+
+ @require @is_valid_list(array) : "Expected a valid list"
+ @require $defined(array[0] * array[0]) : "Array element type must implement the '*' operator"
+ @require $defined($typeof(array[0]) t = identity_value) : "The identity type must be assignable to the array element type"
+*>
+macro @product(array, identity_value = 1)
+{
+	return @reduce(array, ($typeof(array[0]))identity_value, fn (acc, e, u) => acc * e);
+}
+
+<*
+ Applies a given predicate function to each element of an array and returns a new
+ array of `usz` values, each element representing an index within the original array
+ where the predicate returned `true`.
+
+ The `.len` value of the returned array can also be used to quickly identify how many
+ input array elements matched the predicate.
+
+ For example:
+ ```c3
+ int[] arr = { 0, 20, 4, 30 };
+ int[] matched_indices = array::@indices_of(mem, arr, fn (u, a) => a > 10);
+ ```
+
+ The `matched_indices` variable should contain a dynamically-allocated array of `[1, 3]`,
+ and thus its count indicates that 2 of the 4 elements matched the predicate condition.
+
+ @param [&inout] allocator
+ @param [in] array
+ @param #predicate
+
+ @require @is_valid_list(array) : "Expected a valid list"
+ @require $defined($typefrom(@predicate_fn(array)) p = #predicate)
+*>
+macro usz[] @indices_of(Allocator allocator, array, #predicate)
+{
+	usz[] results = allocator::new_array(allocator, usz, lengthof(array));
+	usz matches;
+
+	$typefrom(@predicate_fn(array)) $predicate = #predicate;
+	foreach (index, element : array)
+	{
+		if ($predicate(element, index)) results[matches++] = index;
+	}
+
+	return results[:matches];
+}
+
+<*
+ Array `@indices_of` using the temp allocator.
+
+ @param [in] array
+ @param #predicate
+
+ @require @is_valid_list(array) : "Expected a valid list"
+ @require $defined($typefrom(@predicate_fn(array)) p = #predicate)
+*>
+macro usz[] @tindices_of(array, #predicate)
+{
+	return @indices_of(tmem, array, #predicate);
+}
+
+
+<*
+ Applies a predicate function to each element of an input array and returns a new array
+ containing shallow copies of _only_ the elements for which the predicate function returned
+ a `true` value.
+
+ For example:
+ ```c3
+ int[] my_arr = { 1, 2, 4, 10, 11, 45 };
+ int[] evens = array::@filter(mem, my_arr, fn (e, u) => !(e % 2));
+ assert(evens == (int[]){2, 4, 10 });
+ ```
+
+ @param [&inout] allocator
+ @param [in] array
+ @param #predicate
+
+ @require @is_valid_list(array) : "Expected a valid list"
+ @require $defined($typefrom(@predicate_fn(array)) p = #predicate)
+*>
+macro @filter(Allocator allocator, array, #predicate) @nodiscard
+{
+	var $InnerType = $typeof(array[0]);
+
+	usz[] matched_indices = @indices_of(allocator, array, #predicate);
+	defer allocator::free(allocator, matched_indices.ptr);   // can free this upon leaving this call
+
+	if (!matched_indices.len) return ($InnerType[]){};
+
+	$InnerType[] result = allocator::new_array(allocator, $InnerType, matched_indices.len);
+
+	foreach (i, index : matched_indices) result[i] = array[index];
+
+	return result;
+}
+
+<*
+ Array `@filter` using the temp allocator.
+
+ @param [in] array
+ @param #predicate
+
+ @require @is_valid_list(array) : "Expected a valid list"
+ @require $defined($typefrom(@predicate_fn(array)) p = #predicate)
+*>
+macro @tfilter(array, #predicate) @nodiscard
+{
+	return @filter(tmem, array, #predicate);
+}
+
+
+<*
+ Returns `true` if _any_ element of the input array returns `true` when
+ the `#predicate` function is applied.
+
+ @param [in] array
+ @param #predicate
+
+ @require @is_valid_list(array) : "Expected a valid list"
+ @require $defined($typefrom(@predicate_fn(array)) p = #predicate)
+*>
+macro bool @any(array, #predicate)
+{
+	$typefrom(@predicate_fn(array)) $predicate = #predicate;
+	foreach (index, element : array) if ($predicate(element, index)) return true;
+	return false;
+}
+
+
+<*
+ Returns `true` if _all_ elements of the input array return `true` when
+ the `#predicate` function is applied.
+
+ @param [in] array
+ @param #predicate
+
+ @require @is_valid_list(array) : "Expected a valid list"
+ @require $defined($typefrom(@predicate_fn(array)) p = #predicate)
+*>
+macro bool @all(array, #predicate)
+{
+	$typefrom(@predicate_fn(array)) $predicate = #predicate;
+	foreach (index, element : array) if (!$predicate(element, index)) return false;
+	return true;
+}
+
+
+<*
+ Extract a copy of all even-index elements from an input array.
+
+ @param [&inout] allocator : "The allocator used to create the return array."
+ @param [in] array : "The array from which to extract all even elements."
+
+ @require @is_valid_list(array) : "Expected a valid list"
+ @require $defined(array[:lengthof(array)]) : "Expected a sliceable list"
+*>
+macro even(Allocator allocator, array)
+{
+	return unlace_impl{$typeof(array[0])}(allocator, array[:lengthof(array)]);
+}
+
+
+<*
+ Extract a copy of all odd-index elements from an input array.
+
+ @param [&inout] allocator : "The allocator used to create the return array."
+ @param [in] array : "The array from which to extract all odd elements."
+
+ @require @is_valid_list(array) : "Expected a valid list"
+ @require $defined(array[:lengthof(array)]) : "Expected a sliceable list"
+*>
+macro odd(Allocator allocator, array)
+{
+	return unlace_impl{$typeof(array[0])}(allocator, lengthof(array) > 1 ? array[1..] : ($typeof(array[0])[]){});
+}
+
+<*
+ Private implementation of `even` and `odd` macros, expecting a slice and returning one as well.
+ This function always extracts the even elements of the input slice.
+
+ @param [&inout] allocator : "The allocator used to create the return array."
+ @param [in] array : "The array from which to extract all odd elements."
+*>
+fn Type[] unlace_impl(Allocator allocator, Type[] array) <Type> @private
+{
+	usz new_len = array.len / 2 + (array.len % 2 == 0 ? 0 : 1);
+	if (new_len == 0) return (Type[]){};
+	Type[] new_array = allocator::new_array(allocator, Type, new_len);
+	foreach (x, &new : new_array) *new = types::implements_copy(Type) ??? array[x * 2].copy(allocator) : array[x * 2];
+	return new_array[:new_len];
+}
+
+<*
+ Unlace or partition an input list into its component parts such that `[a, b, c, d, e]` becomes
+ `[a, c, e]` and `[b, d]`. Returned arrays are allocated by the given allocator and are returned
+ via two `out` parameters, `left` and `right`.
+
+ @param [&inout] allocator : "The allocator used to create the returned arrays."
+ @param [in] array : "The input array to unlace."
+ @param [out] left : "Stores a copy of all even-index array elements."
+ @param [out] right : "Stores a copy of all odd-index array elements."
+
+ @require @is_valid_list(array) : "Expected a valid list"
+ @require $typeof(left) == $typeof(array[0])[]*
+ @require $typeof(right) == $typeof(array[0])[]*
+*>
+macro unlace(Allocator allocator, array, left, right)
+{
+	if (left) *left = even(allocator, array);
+	if (right) *right = odd(allocator, array);
+}
+
+
+<*
+ Zip together two separate arrays/slices into a single array of Pairs or return values. Values will
+ be collected up to the length of the shorter array if `fill_with` is left undefined; otherwise, they
+ will be collected up to the length of the LONGER array, with missing values in the shorter array being
+ assigned to the value of `fill_with`. Return array elements do not have to be of the same type.
+
+ For example:
+ ```c3
+ uint[] chosen_session_ids = server::get_random_sessions(instance)[:128];
+ String[200] refreshed_session_keys = prng::new_keys_batch();
+
+ Pair { uint, String }[] sessions_meta = array::zip(mem, chosen_session_ids, refreshed_session_keys);
+ // The resulting Pair{}[] slice is then length of the shortest of the two arrays, so 128.
+
+ foreach (i, &sess : sessions:meta) {
+     // distribute new session keys to associated instance IDs
+ }
+ ```
+
+ Or:
+ ```c3
+ String[] client_names = server::online_usernames(instance);
+ uint128[] session_ids = server::user_keys();
+
+ // in this example, we 'know' ahead of time that 'session_ids' can only ever be SHORTER
+ //   than 'client_names', but never longer, because it's possible new users have logged
+ //   in without getting whatever this 'session ID' is delegated to them.
+ Pair { String, uint128 }[] zipped = array::tzip(client_names, session_ids, fill_with: uint128.max);
+
+ server::refresh_session_keys_by_pair(zipped)!;
+ ```
+
+ ### When an `operation` is supplied...
+ Apply an operation to each element of two slices or arrays and return the results of
+ each operation into a newly allocated array.
+
+ This essentially combines Iterable1 with Iterable2 using the `operation` functor.
+
+ See the functional `zipWith` construct, which has a more appropriate name than, e.g., `map`;
+   a la: https://hackage.haskell.org/package/base-4.21.0.0/docs/Prelude.html#v:zipWith
+
+ Similar to "normal" `zip`, this macro pads the shorter input array with a given `fill_with`, or
+ an empty value if one isn't supplied. This `fill_with` is supplied to the `operation` functor
+ _BEFORE_ calculating its result while zipping.
+
+ For example: a functor of `fn char (char a, char b) => a + b` with a `fill_with` of 7,
+ where the `left` array is the shorter iterable, will put 7 into that lambda in each place
+ where `left` is being filled in during the zip operation.
+
+ @param [&inout] allocator : "The allocator to use; default is the heap allocator."
+ @param [in] left : "The left-side array. These items will be placed as the First in each Pair"
+ @param [in] right : "The right-side array. These items will be placed as the Second in each Pair"
+ @param #operation : "The function to apply. Must have a signature of `$typeof(a) (a, b)`, where the type of 'a' and 'b' is the element type of left/right respectively."
+ @param fill_with : "The value used to fill or pad the shorter iterable to the length of the longer one while zipping."
+
+ @require @is_valid_list(left) &&& @is_valid_list(right) : "Left and right sides must be integer indexable"
+ @require @is_valid_operation(left, right, ...#operation) : "The operator must take two parameters matching the elements of the left and right side"
+ @require @is_valid_fill(left, right, ...fill_with) : "The specified fill value does not match either the left or the right array's underlying type."
+*>
+macro @zip(Allocator allocator, left, right, #operation = ..., fill_with = ...) @nodiscard
+{
+	var $LeftType = $typeof(left[0]);
+	var $RightType = $typeof(right[0]);
+
+	var $Type = Pair { $LeftType, $RightType };
+	bool $is_op = $defined(#operation);
+	$if $is_op:
+		$Type = $typeof(#operation).returns;
+	$endif
+
+	usz left_len = lengthof(left);
+	usz right_len = lengthof(right);
+
+	$LeftType left_fill;
+	$RightType right_fill;
+	usz result_len = min(left_len, right_len);
+	$if $defined(fill_with):
+		switch
+		{
+			case left_len > right_len:
+				$if !$defined(($RightType)fill_with):
+					unreachable();
+				$else
+					right_fill = ($RightType)fill_with;
+					result_len = left_len;
+				$endif
+			case left_len < right_len:
+				$if !$defined(($LeftType)fill_with):
+					unreachable();
+				$else
+					left_fill = ($LeftType)fill_with;
+					result_len = right_len;
+				$endif
+		}
+	$endif
+
+	if (result_len == 0) return ($Type[]){};
+
+	$Type[] result = allocator::alloc_array(allocator, $Type, result_len);
+
+	foreach (idx, &item : result)
+	{
+		$if $is_op:
+			var $LambdaType = $typeof(fn $Type ($LeftType a, $RightType b) => ($Type){});
+			$LambdaType $operation = ($LambdaType)#operation;
+			$LeftType lval = idx >= left_len ? left_fill : left[idx];
+			$RightType rval = idx >= right_len ? right_fill : right[idx];
+			*item = $operation(lval, rval);
+		$else
+			*item = {
+				idx >= left_len ? left_fill : left[idx],
+				idx >= right_len ? right_fill : right[idx]
+			};
+		$endif
+	}
+
+	return result;
+}
+
+<*
+ Array 'zip' using the temp allocator.
+
+ @param [in] left : "The left-side array. These items will be placed as the First in each Pair"
+ @param [in] right : "The right-side array. These items will be placed as the Second in each Pair"
+ @param #operation : "The function to apply. Must have a signature of `$typeof(a) (a, b)`, where the type of 'a' and 'b' is the element type of left/right respectively."
+ @param fill_with : "The value used to fill or pad the shorter iterable to the length of the longer one while zipping."
+
+ @require @is_valid_list(left) &&& @is_valid_list(right) : "Left and right sides must be integer indexable"
+ @require @is_valid_operation(left, right, ...#operation) : "The operator must take two parameters matching the elements of the left and right side"
+ @require @is_valid_fill(left, right, ...fill_with) : "The specified fill value does not match either the left or the right array's underlying type."
+*>
+macro @tzip(left, right, #operation = ..., fill_with = ...) @nodiscard
+{
+	return @zip(tmem, left, right, #operation: ...#operation, fill_with: ...fill_with);
+}
+
+
+<*
+ Apply an operation to each element of two slices or arrays and store the results of
+ each operation into the 'left' value.
+
+ This is useful because no memory allocations are required in order to perform the operation.
+
+ A good example of using this might be using algorithmic transformations on data in-place:
+ ```
+ char[] partial_cipher = get_next_plaintext_block();
+
+ array::@zip_into(
+     partial_cipher[ENCRYPT_OFFSET:BASE_KEY.len],
+	 BASE_KEY,
+	 fn char (char a, char b) => a ^ (b * 5) % 37
+ );
+ ```
+
+ This parameterizes the lambda function with left (`partial_cipher`) and right (`BASE_KEY`) slice
+ elements and stores the end result in-place within the left slice. This is in contrast to a
+ regular `zip_with` which will create a cloned final result and return it.
+
+ @param [inout] left : `Slice to store results of applied functor/operation.`
+ @param [in] right : `Slice to apply in the functor/operation.`
+ @param #operation : "The function to apply. Must have a signature of `$typeof(a) (a, b)`, where the type of 'a' and 'b' is the element type of left/right respectively."
+
+ @require @is_valid_list(left) : "Expected a valid list"
+ @require @is_valid_list(right) : "Expected a valid list"
+ @require lengthof(right) >= lengthof(left) : `Right side length must be >= the destination (left) side length; consider using a sub-array of data for the assignment.`
+ @require $defined($typefrom(@zip_into_fn(left, right)) x = #operation) : "The functor must use the same types as the `left` and `right` inputs, and return a value of the `left` type."
+*>
+macro @zip_into(left, right, #operation)
+{
+	$typefrom(@zip_into_fn(left, right)) $operation = #operation;
+
+	foreach (i, &v : left) *v = $operation(left[i], right[i]);
+}
+
+
+// --- helper functions
+module std::core::array @private;
+
+
+macro typeid @predicate_fn(#array) @const
+{
+	return $typeof(fn bool ($typeof(#array[0]) a, usz index = 0) => true).typeid;
+}
+
+macro typeid @reduce_fn(#array, #identity) @const
+{
+	return @typeid(fn $typeof(#identity) ($typeof(#identity) i, $typeof(#array[0]) a, usz index = 0) => i);
+}
+
+macro typeid @zip_into_fn(#left, #right) @const
+{
+	return @typeid(fn $typeof(#left[0]) ($typeof(#left[0]) l, $typeof(#right[0]) r) => l);
+}
+
+macro bool @is_valid_operation(#left, #right, #operation = ...) @const
+{
+	$switch:
+		$case !$defined(#operation):
+			return true;
+		$case $kindof(#operation) != FUNC:
+			return false;
+		$default:
+			return $defined(#operation(#left[0], #right[0]));
+	$endswitch
+}
+
+macro bool @is_valid_list(#expr) @const
+{
+	return $defined(#expr[0], lengthof(#expr));
+}
+
+macro bool @is_valid_fill(left, right, fill_with = ...)
+{
+	$if !$defined(fill_with):
+		return true;
+	$else
+		usz left_len = lengthof(left);
+		usz right_len = lengthof(right);
+		if (left_len == right_len) return true;
+		return left_len > right_len ? $defined(($typeof(right[0]))fill_with) : $defined(($typeof(left[0]))fill_with);
+	$endif
+}

lib/std/core/ascii.c3

@@ -0,0 +1,156 @@
+<*
+ This module contains utils for handling ASCII characters. They only operate on
+ characters corresponding to 0-127.
+*>
+module std::core::ascii;
+
+macro bool @is_lower(c)  => ASCII_LOOKUP[c].lower;      // Is a-z
+macro bool @is_upper(c)  => ASCII_LOOKUP[c].upper;      // Is A-Z
+macro bool @is_digit(c)  => ASCII_LOOKUP[c].digit;      // Is 0-9
+macro bool @is_bdigit(c) => ASCII_LOOKUP[c].bin_digit;  // Is 0-1
+macro bool @is_odigit(c) => ASCII_LOOKUP[c].oct_digit;  // Is 0-7
+macro bool @is_xdigit(c) => ASCII_LOOKUP[c].hex_digit;  // Is 0-9 or a-f or A-F
+macro bool @is_alpha(c)  => ASCII_LOOKUP[c].alpha;      // Is a-z or A-Z
+macro bool @is_print(c)  => ASCII_LOOKUP[c].printable;  // Is a printable character (space or higher and < 127
+macro bool @is_graph(c)  => ASCII_LOOKUP[c].graph;      // Does it show any graphics (printable but not space)
+macro bool @is_space(c)  => ASCII_LOOKUP[c].space;      // Is it a space character: space, tab, linefeed etc
+macro bool @is_alnum(c)  => ASCII_LOOKUP[c].alphanum;   // Is it alpha or digit
+macro bool @is_punct(c)  => ASCII_LOOKUP[c].punct;      // Is it "graph" but not digit or letter
+macro bool @is_blank(c)  => ASCII_LOOKUP[c].blank;      // Is it a blank space: space or tab
+macro bool @is_cntrl(c)  => ASCII_LOOKUP[c].control;    // Is it a control character: before space or 127
+macro char @to_lower(c)  => c + TO_LOWER[c];            // Convert A-Z to a-z if found
+macro char @to_upper(c)  => c - TO_UPPER[c];            // Convert a-z to A-Z if found
+
+fn bool is_lower(char c)  => @is_lower(c);  // Is a-z
+fn bool is_upper(char c)  => @is_upper(c);  // Is A-Z
+fn bool is_digit(char c)  => @is_digit(c);  // Is 0-9
+fn bool is_bdigit(char c) => @is_bdigit(c); // Is 0-1
+fn bool is_odigit(char c) => @is_odigit(c); // Is 0-7
+fn bool is_xdigit(char c) => @is_xdigit(c); // Is 0-9 or a-f or A-F
+fn bool is_alpha(char c)  => @is_alpha(c);  // Is a-z or A-Z
+fn bool is_print(char c)  => @is_print(c);  // Is a printable character (space or higher and < 127
+fn bool is_graph(char c)  => @is_graph(c);  // Does it show any graphics (printable but not space)
+fn bool is_space(char c)  => @is_space(c);  // Is it a space character: space, tab, linefeed etc
+fn bool is_alnum(char c)  => @is_alnum(c);  // Is it alpha or digit
+fn bool is_punct(char c)  => @is_punct(c);  // Is it "graph" but not digit or letter
+fn bool is_blank(char c)  => @is_blank(c);  // Is it a blank space: space or tab
+fn bool is_cntrl(char c)  => @is_cntrl(c);  // Is it a control character: before space or 127
+fn char to_lower(char c)  => @to_lower(c);  // Convert A-Z to a-z if found
+fn char to_upper(char c)  => @to_upper(c);  // Convert a-z to A-Z if found
+
+// The following methods are macro methods for the same functions
+macro bool char.is_lower(char c)  => @is_lower(c);
+macro bool char.is_upper(char c)  => @is_upper(c);
+macro bool char.is_digit(char c)  => @is_digit(c);
+macro bool char.is_bdigit(char c) => @is_bdigit(c);
+macro bool char.is_odigit(char c) => @is_odigit(c);
+macro bool char.is_xdigit(char c) => @is_xdigit(c);
+macro bool char.is_alpha(char c)  => @is_alpha(c);
+macro bool char.is_print(char c)  => @is_print(c);
+macro bool char.is_graph(char c)  => @is_graph(c);
+macro bool char.is_space(char c)  => @is_space(c);
+macro bool char.is_alnum(char c)  => @is_alnum(c);
+macro bool char.is_punct(char c)  => @is_punct(c);
+macro bool char.is_blank(char c)  => @is_blank(c);
+macro bool char.is_cntrl(char c)  => @is_cntrl(c);
+macro char char.to_lower(char c)  => @to_lower(c);
+macro char char.to_upper(char c)  => @to_upper(c);
+
+<*
+ Convert a-f/A-F/0-9 to the appropriate hex value.
+
+ @require c.is_xdigit()
+ @ensure return >= 0 && return <= 15
+*>
+macro char char.from_hex(char c) => HEX_VALUE[c];
+
+<*
+ Bitstruct containing the different properties of a character
+*>
+bitstruct CharType : ushort @private
+{
+	bool lower;
+	bool upper;
+	bool digit;
+	bool bin_digit;
+	bool hex_digit;
+	bool oct_digit;
+	bool alpha;
+	bool alphanum;
+	bool space;
+	bool printable;
+	bool blank;
+	bool punct;
+	bool control;
+	bool graph;
+}
+
+const CharType[256] ASCII_LOOKUP @private = {
+	[0..31]    = { .control },
+	[9..13]    = { .control, .space },
+	['\t']     = { .control, .space, .blank },
+	[' ']      = { .space, .printable, .blank },
+	[33..126]  = { .printable, .graph, .punct },
+	['0'..'9'] = { .printable, .graph, .alphanum, .hex_digit, .digit },
+	['2'..'7'] = { .printable, .graph, .alphanum, .hex_digit, .digit, .oct_digit },
+	['0'..'1'] = { .printable, .graph, .alphanum, .hex_digit, .digit, .oct_digit, .bin_digit },
+	['A'..'Z'] = { .printable, .graph, .alphanum, .alpha, .upper },
+	['A'..'F'] = { .printable, .graph, .alphanum, .alpha, .upper, .hex_digit },
+	['a'..'z'] = { .printable, .graph, .alphanum, .alpha, .lower },
+	['a'..'f'] = { .printable, .graph, .alphanum, .alpha, .lower, .hex_digit },
+	[127]      = { .control },
+};
+
+const char[256] HEX_VALUE = {
+	['0'] =  0, ['1'] =  1, ['2'] =  2, ['3'] =  3, ['4'] =  4,
+	['5'] =  5, ['6'] =  6, ['7'] =  7, ['8'] =  8, ['9'] =  9,
+	['A'] = 10, ['B'] = 11, ['C'] = 12, ['D'] = 13, ['E'] = 14,
+	['F'] = 15, ['a'] = 10, ['b'] = 11, ['c'] = 12, ['d'] = 13,
+	['e'] = 14, ['f'] = 15
+};
+
+const char[256] TO_UPPER @private = { ['a'..'z'] = 'a' - 'A' };
+const char[256] TO_LOWER @private  = { ['A'..'Z'] = 'a' - 'A' };
+
+typedef AsciiCharset = uint128;
+
+macro AsciiCharset @create_set(String $string) @const
+{
+	AsciiCharset $set;
+	$foreach $c : $string:
+		$set |= 1ULL << $c;
+	$endforeach
+	return $set;
+}
+
+fn AsciiCharset create_set(String string)
+{
+	AsciiCharset set;
+	foreach (c : string) set |= (AsciiCharset)1ULL << c;
+	return set;
+}
+
+macro bool AsciiCharset.@contains($set, char $c) @const => !!($c < 128) & !!($set & (AsciiCharset)(1ULL << $c));
+
+macro AsciiCharset @combine_sets(AsciiCharset $first, AsciiCharset... $sets) @const
+{
+	var $res = $first;
+	$foreach $c : $sets:
+		$res |= $c;
+	$endforeach
+	return $res;
+}
+fn AsciiCharset combine_sets(AsciiCharset first, AsciiCharset... sets)
+{
+	foreach (c : sets) first |= c;
+	return first;
+}
+
+macro bool AsciiCharset.contains(set, char c) => !!(c < 128) & !!(set & (AsciiCharset)(1ULL << c));
+
+const AsciiCharset WHITESPACE_SET = @create_set("\t\n\v\f\r ");
+const AsciiCharset NUMBER_SET = @create_set("0123456789");
+const AsciiCharset ALPHA_UPPER_SET = @create_set("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
+const AsciiCharset ALPHA_LOWER_SET = @create_set("abcdefghijklmnopqrstuvwxyz");
+const AsciiCharset ALPHA_SET = @combine_sets(ALPHA_UPPER_SET, ALPHA_LOWER_SET);
+const AsciiCharset ALPHANUMERIC_SET = @combine_sets(ALPHA_SET, NUMBER_SET);

lib/std/core/bitorder.c3

@@ -0,0 +1,236 @@
+// Copyright (c) 2023-2025 Christoffer Lerno and contributors. All rights reserved.
+// Use of this source code is governed by the MIT license
+// a copy of which can be found in the LICENSE_STDLIB file.
+module std::core::bitorder;
+import std::bits;
+// This module contains types of different endianness.
+// *BE types represent big-endian types
+// *LE types represent little-endian types.
+
+bitstruct ShortBE : short @bigendian
+{
+	short val : 0..15;
+}
+
+bitstruct UShortBE : ushort @bigendian
+{
+	ushort val : 0..15;
+}
+
+bitstruct IntBE : int @bigendian
+{
+	int val : 0..31;
+}
+
+bitstruct UIntBE : int @bigendian
+{
+	uint val : 0..31;
+}
+
+bitstruct LongBE : long @bigendian
+{
+	long val : 0..63;
+}
+
+bitstruct ULongBE : ulong @bigendian
+{
+	ulong val : 0..63;
+}
+
+bitstruct Int128BE : int128 @bigendian
+{
+	int128 val : 0..127;
+}
+
+bitstruct UInt128BE : uint128 @bigendian
+{
+	uint128 val : 0..127;
+}
+
+bitstruct ShortLE : short @littleendian
+{
+	short val : 0..15;
+}
+
+bitstruct UShortLE : ushort @littleendian
+{
+	ushort val : 0..15;
+}
+
+bitstruct IntLE : int @littleendian
+{
+	int val : 0..31;
+}
+
+bitstruct UIntLE : int @littleendian
+{
+	uint val : 0..31;
+}
+
+bitstruct LongLE : long @littleendian
+{
+	long val : 0..63;
+}
+
+bitstruct ULongLE : ulong @littleendian
+{
+	ulong val : 0..63;
+}
+
+bitstruct Int128LE : int128 @littleendian
+{
+	int128 val : 0..127;
+}
+
+bitstruct UInt128LE : uint128 @littleendian
+{
+	uint128 val : 0..127;
+}
+
+<*
+ @require $defined(*bytes) : "Pointer must be possible to dereference"
+ @require types::is_intlike($typeof(*bytes)) : "Type must be an integer or int vector"
+*>
+macro load_be(bytes)
+{
+	$if env::BIG_ENDIAN:
+		return mem::load(bytes, $align: 1);
+	$else
+		return bswap(mem::load(bytes, $align: 1));
+	$endif
+}
+
+<*
+ @require $defined(*bytes) : "Pointer must be possible to dereference"
+ @require types::is_intlike($typeof(*bytes)) : "Type must be an integer or int vector"
+*>
+macro load_le(bytes)
+{
+	$if env::BIG_ENDIAN:
+		return bswap(mem::load(bytes, $align: 1));
+	$else
+		return mem::load(bytes, $align: 1);
+	$endif
+}
+
+<*
+ @require types::is_intlike($typeof(value)) : "Type must be an integer or int vector"
+*>
+macro void store_be(void* dst, value)
+{
+	$if env::BIG_ENDIAN:
+		mem::store(($typeof(value)*)dst, value, $align: 1);
+	$else
+		mem::store(($typeof(value)*)dst, bswap(value), $align: 1);
+	$endif
+}
+
+<*
+ @require types::is_intlike($typeof(value)) : "Type must be an integer or int vector"
+*>
+macro void store_le(void* dst, value)
+{
+	$if env::BIG_ENDIAN:
+		mem::store(($typeof(value)*)dst, bswap(value), $align: 1);
+	$else
+		mem::store(($typeof(value)*)dst, value, $align: 1);
+	$endif
+}
+
+<*
+ @require @is_array_or_slice_of_char(bytes) : "argument must be an array, a pointer to an array or a slice of char"
+ @require is_bitorder($Type) : "type must be a bitorder integer"
+ @require $defined(*bytes) ||| $defined(bytes[:$Type.sizeof]) : "Data is too short to contain value"
+*>
+macro read(bytes, $Type)
+{
+	char *ptr;
+	$switch $kindof(bytes):
+		$case POINTER:
+			ptr = bytes;
+		$default:
+			ptr = bytes[..].ptr;
+	$endswitch
+	return bitcast(mem::load((char[$Type.sizeof]*)ptr, $align: 1), $Type).val;
+}
+
+<*
+ @require @is_arrayptr_or_slice_of_char(bytes) : "argument must be a pointer to an array or a slice of char"
+ @require is_bitorder($Type) : "type must be a bitorder integer"
+ @require $defined(*bytes) ||| $defined(bytes[:$Type.sizeof]) : "Data is not sufficent to hold value"
+*>
+macro write(x, bytes, $Type)
+{
+	char *ptr;
+	$switch $kindof(bytes):
+		$case POINTER:
+			ptr = bytes;
+		$default:
+			ptr = bytes[..].ptr;
+	$endswitch
+	mem::store(($typeof(x)*)ptr, bitcast(x, $Type).val, 1);
+}
+
+macro bool is_bitorder($Type)
+{
+	$switch $Type:
+		$case UShortLE:
+		$case ShortLE:
+		$case UIntLE:
+		$case IntLE:
+		$case ULongLE:
+		$case LongLE:
+		$case UInt128LE:
+		$case Int128LE:
+		$case UShortBE:
+		$case ShortBE:
+		$case UIntBE:
+		$case IntBE:
+		$case ULongBE:
+		$case LongBE:
+		$case UInt128BE:
+		$case Int128BE:
+			return true;
+		$default:
+			return false;
+	$endswitch
+}
+
+macro bool is_array_or_slice_of_char(bytes) @deprecated("Use @is_array_or_slice_of_char")
+{
+	return @is_array_or_slice_of_char(bytes);
+}
+
+macro bool @is_array_or_slice_of_char(#bytes) @const
+{
+    var $Type = $typeof(#bytes);
+	$switch $Type.kindof:
+		$case POINTER:
+			typeid $inner = $Type.inner;
+			return $inner.kindof == ARRAY &&& $inner.inner == char.typeid;
+		$case ARRAY:
+		$case SLICE:
+			return $Type.inner == char.typeid;
+		$default:
+			return false;
+	$endswitch
+}
+
+macro bool is_arrayptr_or_slice_of_char(bytes) @deprecated("Use @is_arrayptr_or_slice_of_char")
+{
+	return @is_arrayptr_or_slice_of_char(bytes);
+}
+
+macro bool @is_arrayptr_or_slice_of_char(#bytes) @const
+{
+	var $Type = $typeof(#bytes);
+	$switch $Type.kindof:
+		$case POINTER:
+			typeid $inner = $Type.inner;
+			return $inner.kindof == ARRAY &&& $inner.inner == char.typeid;
+		$case SLICE:
+			return $Type.inner == char.typeid;
+		$default:
+			return false;
+	$endswitch
+}

lib/std/core/builtin_comparison.c3

@@ -1,76 +1,161 @@
-// Copyright (c) 2021-2022 Christoffer Lerno and contributors. All rights reserved.
+// Copyright (c) 2021-2024 Christoffer Lerno and contributors. All rights reserved.
 // Use of this source code is governed by the MIT license
 // a copy of which can be found in the LICENSE_STDLIB file.
 module std::core::builtin;
 
-/**
- * @require is_comparable_value(a) && is_comparable_value(b)
- **/
-macro less(a, b) @builtin
+<*
+ @require types::@comparable_value(a) && types::@comparable_value(b)
+*>
+macro bool less(a, b) @builtin
 {
-	$if ($defined(a.less)):
+	$switch:
+	$case $defined(a.less):
 		return a.less(b);
-	$elif ($defined(a.compare_to)):
+	$case $defined(a.compare_to):
 		return a.compare_to(b) < 0;
-	$else:
+	$default:
 		return a < b;
-	$endif;
+	$endswitch
 }
 
-/**
- * @require is_comparable_value(a) && is_comparable_value(b)
- **/
-macro less_eq(a, b) @builtin
+<*
+ @require types::@comparable_value(a) && types::@comparable_value(b)
+*>
+macro bool less_eq(a, b) @builtin
 {
-	$if ($defined(a.less)):
+	$switch:
+	$case $defined(a.less):
 		return !b.less(a);
-	$elif ($defined(a.compare_to)):
+	$case $defined(a.compare_to):
 		return a.compare_to(b) <= 0;
-	$else:
+	$default:
 		return a <= b;
-	$endif;
+	$endswitch
 }
 
-/**
- * @require is_comparable_value(a) && is_comparable_value(b)
- **/
-macro greater(a, b) @builtin
+<*
+ @require types::@comparable_value(a) && types::@comparable_value(b)
+*>
+macro bool greater(a, b) @builtin
 {
-	$if ($defined(a.less)):
+	$switch:
+	$case $defined(a.less):
 		return b.less(a);
-	$elif ($defined(a.compare_to)):
+	$case $defined(a.compare_to):
 		return a.compare_to(b) > 0;
-	$else:
+	$default:
 		return a > b;
-	$endif;
+	$endswitch
 }
 
-/**
- * @require is_comparable_value(a) && is_comparable_value(b)
- **/
-macro greater_eq(a, b) @builtin
+<*
+ @require types::@comparable_value(a) && types::@comparable_value(b)
+*>
+macro int compare_to(a, b) @builtin
 {
-	$if ($defined(a.less)):
+	$switch:
+	$case $defined(a.compare_to):
+		return a.compare_to(b);
+	$case $defined(a.less):
+		return (int)b.less(a) - (int)a.less(b);
+	$default:
+		return (int)(a > b) - (int)(a < b);
+	$endswitch
+}
+<*
+ @require types::@comparable_value(a) && types::@comparable_value(b)
+*>
+macro bool greater_eq(a, b) @builtin
+{
+	$switch:
+	$case $defined(a.less):
 		return !a.less(b);
-	$elif ($defined(a.compare_to)):
+	$case $defined(a.compare_to):
 		return a.compare_to(b) >= 0;
-	$else:
+	$default:
 		return a >= b;
-	$endif;
+	$endswitch
 }
 
-/**
- * @require is_equatable_value(a) && is_equatable_value(b) `values must be equatable`
- **/
+<*
+ @require types::@equatable_value(a) && types::@equatable_value(b) : `values must be equatable`
+*>
 macro bool equals(a, b) @builtin
 {
-	$if ($defined(a.equals)):
+	$switch:
+	$case $defined(a.equals, a.equals(b)):
 		return a.equals(b);
-	$elif ($defined(a.compare_to)):
+	$case $defined(a.compare_to, a.compare_to(b)):
 		return a.compare_to(b) == 0;
-	$elif ($defined(a.less)):
+	$case $defined(a.less):
 		return !a.less(b) && !b.less(a);
-	$else:
+	$default:
 		return a == b;
-	$endif;
+	$endswitch
 }
+
+macro min(x, ...) @builtin
+{
+	$if $vacount == 1:
+		return less(x, $vaarg[0]) ? x : $vaarg[0];
+	$else
+		var result = x;
+		$for var $i = 0; $i < $vacount; $i++:
+			if (less($vaarg[$i], result))
+			{
+				 result = $vaarg[$i];
+			}
+		$endfor
+		return result;
+	$endif
+}
+
+macro max(x, ...) @builtin
+{
+	$if $vacount == 1:
+		return greater(x, $vaarg[0]) ? x : $vaarg[0];
+	$else
+		var result = x;
+		$for var $i = 0; $i < $vacount; $i++:
+			if (greater($vaarg[$i], result))
+			{
+				 result = $vaarg[$i];
+			}
+		$endfor
+		return result;
+	$endif
+}
+
+
+<*
+ @require types::is_numerical($typeof($a))
+*>
+macro @max($a, ...) @builtin @const
+{
+	$if $vacount == 1:
+		return $a > $vaconst[0] ? $a : $vaconst[0];
+	$else
+		var $result = $a;
+		$for var $x = 0; $x < $vacount; ++$x:
+			$if $vaconst[$x] > $result: $result = $vaconst[$x]; $endif
+		$endfor
+		return $result;
+	$endif
+}
+
+<*
+ @require types::is_numerical($typeof($a))
+*>
+macro @min($a, ...) @builtin @const
+{
+	$if $vacount == 1:
+		return $a < $vaconst[0] ? $a : $vaconst[0];
+	$else
+		var $result = $a;
+		$for var $x = 0; $x < $vacount; ++$x:
+			$if $vaconst[$x] < $result: $result = $vaconst[$x]; $endif
+		$endfor
+		return $result;
+	$endif
+}
+

lib/std/core/cinterop.c3

@@ -1,87 +1,117 @@
-// Copyright (c) 2021 Christoffer Lerno. All rights reserved.
+// Copyright (c) 2021-2024 Christoffer Lerno. All rights reserved.
 // Use of this source code is governed by the MIT license
 // a copy of which can be found in the LICENSE_STDLIB file.
 module std::core::cinterop;
+import std::core::env;
+
 
 const C_INT_SIZE = $$C_INT_SIZE;
 const C_LONG_SIZE = $$C_LONG_SIZE;
 const C_SHORT_SIZE = $$C_SHORT_SIZE;
 const C_LONG_LONG_SIZE = $$C_LONG_LONG_SIZE;
 
-$assert (C_SHORT_SIZE < 32);
-$assert (C_INT_SIZE < 128);
-$assert (C_LONG_SIZE < 128);
-$assert (C_LONG_LONG_SIZE <= 128);
-$assert (C_SHORT_SIZE <= C_INT_SIZE);
-$assert (C_INT_SIZE <= C_LONG_SIZE);
-$assert (C_LONG_SIZE <= C_LONG_LONG_SIZE);
+$assert C_SHORT_SIZE < 32;
+$assert C_INT_SIZE < 128;
+$assert C_LONG_SIZE < 128;
+$assert C_LONG_LONG_SIZE <= 128;
+$assert C_SHORT_SIZE <= C_INT_SIZE;
+$assert C_INT_SIZE <= C_LONG_SIZE;
+$assert C_LONG_SIZE <= C_LONG_LONG_SIZE;
 
-$switch ($$C_INT_SIZE):
-$case 64:
-    define CInt = long;
-    define CUInt = ulong;
-$case 32:
-    define CInt = int;
-    define CUInt = uint;
-$case 16:
-    define CInt = short;
-    define CUInt = ushort;
-$default:
-    $assert(false, "Invalid C int size");
-$endswitch;
+alias CShort = $typefrom(signed_int_from_bitsize($$C_SHORT_SIZE));
+alias CUShort = $typefrom(unsigned_int_from_bitsize($$C_SHORT_SIZE));
+alias CInt = $typefrom(signed_int_from_bitsize($$C_INT_SIZE));
+alias CUInt = $typefrom(unsigned_int_from_bitsize($$C_INT_SIZE));
+alias CLong = $typefrom(signed_int_from_bitsize($$C_LONG_SIZE));
+alias CULong = $typefrom(unsigned_int_from_bitsize($$C_LONG_SIZE));
+alias CLongLong = $typefrom(signed_int_from_bitsize($$C_LONG_LONG_SIZE));
+alias CULongLong = $typefrom(unsigned_int_from_bitsize($$C_LONG_LONG_SIZE));
+alias CSChar = ichar;
+alias CUChar = char;
 
-$switch ($$C_LONG_SIZE):
-$case 64:
-    define CLong = long;
-    define CULong = ulong;
-$case 32:
-    define CLong = int;
-    define CULong = uint;
-$case 16:
-    define CLong = short;
-    define CULong = ushort;
-$default:
-    $assert(false, "Invalid C long size");
-$endswitch;
+alias CChar = $typefrom($$C_CHAR_IS_SIGNED ? ichar.typeid : char.typeid);
 
-$switch ($$C_SHORT_SIZE):
-$case 32:
-    define CShort = int;
-    define CUShort = uint;
-$case 16:
-    define CShort = short;
-    define CUShort = ushort;
-$case 8:
-    define CShort = ichar;
-    define CUShort = char;
-$default:
-    $assert(false, "Invalid C short size");
-$endswitch;
+enum CBool : char
+{
+	FALSE,
+	TRUE
+}
 
-$switch ($$C_LONG_LONG_SIZE):
-$case 128:
-    define CLongLong = int128;
-    define CULongLong = uint128;
-$case 64:
-    define CLongLong = long;
-    define CULongLong = ulong;
-$case 32:
-    define CLongLong = int;
-    define CULongLong = uint;
-$case 16:
-    define CLongLong = short;
-    define CULongLong = ushort;
-$default:
-    $assert(false, "Invalid C long long size");
-$endswitch;
+// Helper macros
+macro typeid signed_int_from_bitsize(usz $bitsize) @private
+{
+	$switch $bitsize:
+		$case 128: return int128.typeid;
+		$case 64: return long.typeid;
+		$case 32: return int.typeid;
+		$case 16: return short.typeid;
+		$case 8: return ichar.typeid;
+		$default: $error("Invalid bitsize");
+	$endswitch
+}
 
+macro typeid unsigned_int_from_bitsize(usz $bitsize) @private
+{
+	$switch $bitsize:
+		$case 128: return uint128.typeid;
+		$case 64: return ulong.typeid;
+		$case 32: return uint.typeid;
+		$case 16: return ushort.typeid;
+		$case 8: return char.typeid;
+		$default: $error("Invalid bitsize");
+	$endswitch
+}
 
+const USE_STACK_VALIST = env::ARCH_32_BIT || env::WIN32 || (env::DARWIN && env::AARCH64);
+module std::core::cinterop @if(USE_STACK_VALIST);
 
-define CSChar = ichar;
-define CUChar = char;
+typedef CVaList = void*;
+macro CVaList.next(&self, $Type)
+{
+	void *ptr = mem::aligned_pointer((void*)*self, max($Type.alignof, 8));
+	defer *self = (CVaList)(ptr + 1);
+	return *($Type*)ptr;
+}
 
-$if ($$C_CHAR_IS_SIGNED):
-    define CChar = ichar;
-$else:
-    define CChar = char;
-$endif;
+module std::core::cinterop @if(env::X86_64 && !env::WIN32);
+
+struct CVaListData
+{
+    uint gp_offset;
+    uint fp_offset;
+    void *overflow_arg_area;
+    void *reg_save_area;
+}
+
+typedef CVaList = CVaListData*;
+
+macro CVaList.next(self, $Type)
+{
+	CVaListData* data = (CVaListData*)self;
+	$switch:
+	    $case $Type.kindof == FLOAT ||| ($Type.kindof == VECTOR && $Type.sizeof <= 16):
+	        var $LoadType = $Type.sizeof < 8 ? double : $Type;
+	        if (data.fp_offset < 6 * 8 + 8 * 16 )
+			{
+				defer data.fp_offset += (uint)mem::aligned_offset($Type.sizeof, 16);
+				return ($Type)*($LoadType*)(data.reg_save_area + data.fp_offset);
+			}
+			void* ptr = mem::aligned_pointer(data.overflow_arg_area, max(8, $Type.alignof));
+			defer data.overflow_arg_area = ptr + $Type.sizeof;
+			return ($Type)*($LoadType*)ptr;
+		$case $Type.kindof == SIGNED_INT || $Type.kindof == UNSIGNED_INT:
+	        var $LoadType = $Type.sizeof < 4 ? int : $Type;
+			if (data.gp_offset < 6 * 8 && $Type.sizeof <= 8)
+			{
+				defer data.gp_offset += (uint)mem::aligned_offset($Type.sizeof, 8);
+				return ($Type)*($LoadType*)(data.reg_save_area + data.gp_offset);
+			}
+			void* ptr = mem::aligned_pointer(data.overflow_arg_area, max(8, $Type.alignof));
+			defer data.overflow_arg_area = ptr + $Type.sizeof;
+			return ($Type)*($LoadType*)ptr;
+		$default:
+			void* ptr = mem::aligned_pointer(data.overflow_arg_area, max(8, $Type.alignof));
+			defer data.overflow_arg_area = ptr + $Type.sizeof;
+			return *($Type*)ptr;
+	$endswitch
+}

lib/std/core/conv.c3

@@ -1,54 +1,57 @@
 module std::core::string::conv;
 
-private const uint UTF16_SURROGATE_OFFSET = 0x10000;
-private const uint UTF16_SURROGATE_GENERIC_MASK = 0xF800;
-private const uint UTF16_SURROGATE_GENERIC_VALUE = 0xD800;
-private const uint UTF16_SURROGATE_MASK = 0xFC00;
-private const uint UTF16_SURROGATE_CODEPOINT_MASK = 0x03FF;
-private const uint UTF16_SURROGATE_BITS = 10;
-private const uint UTF16_SURROGATE_LOW_VALUE = 0xDC00;
-private const uint UTF16_SURROGATE_HIGH_VALUE = 0xD800;
+const uint UTF16_SURROGATE_OFFSET @private = 0x10000;
+const uint UTF16_SURROGATE_GENERIC_MASK @private = 0xF800;
+const uint UTF16_SURROGATE_GENERIC_VALUE @private = 0xD800;
+const uint UTF16_SURROGATE_MASK @private = 0xFC00;
+const uint UTF16_SURROGATE_CODEPOINT_MASK @private = 0x03FF;
+const uint UTF16_SURROGATE_BITS @private = 10;
+const uint UTF16_SURROGATE_LOW_VALUE @private = 0xDC00;
+const uint UTF16_SURROGATE_HIGH_VALUE @private = 0xD800;
 
-/**
- * @param c `The utf32 codepoint to convert`
- * @param [out] output `the resulting buffer`
- * @param available `the size available`
- **/
-fn usize! char32_to_utf8(Char32 c, char* output, usize available)
+<*
+ @param c : `The utf32 codepoint to convert`
+ @param [out] output : `the resulting buffer`
+ @return? string::CONVERSION_FAILED
+*>
+fn usz? char32_to_utf8(Char32 c, char[] output)
 {
-	if (!available) return UnicodeResult.CONVERSION_FAILED!;
+	if (!output.len) return string::CONVERSION_FAILED~;
 	switch (true)
 	{
-		case c < 0x7f:
+		case c <= 0x7f:
 			output[0] = (char)c;
 			return 1;
-		case c < 0x7ff:
-	        if (available < 2) return UnicodeResult.CONVERSION_FAILED!;
+		case c <= 0x7ff:
+			if (output.len < 2) return string::CONVERSION_FAILED~;
 			output[0] = (char)(0xC0 | c >> 6);
-            output[1] = (char)(0x80 | (c & 0x3F));
-            return 2;
-        case c < 0xffff:
-	        if (available < 3) return UnicodeResult.CONVERSION_FAILED!;
-            output[0] = (char)(0xE0 | c >> 12);
-            output[1] = (char)(0x80 | (c >> 6 & 0x3F));
-            output[2] = (char)(0x80 | (c & 0x3F));
-            return 3;
-        default:
-	        if (available < 4) return UnicodeResult.CONVERSION_FAILED!;
-		    output[0] = (char)(0xF0 | c >> 18);
-            output[1] = (char)(0x80 | (c >> 12 & 0x3F));
-            output[2] = (char)(0x80 | (c >> 6 & 0x3F));
-            output[3] = (char)(0x80 | (c & 0x3F));
-            return 4;
+			output[1] = (char)(0x80 | (c & 0x3F));
+			return 2;
+		case c <= 0xffff:
+			if (output.len < 3) return string::CONVERSION_FAILED~;
+			output[0] = (char)(0xE0 | c >> 12);
+			output[1] = (char)(0x80 | (c >> 6 & 0x3F));
+			output[2] = (char)(0x80 | (c & 0x3F));
+			return 3;
+		case c <= 0x10ffff:
+			if (output.len < 4) return string::CONVERSION_FAILED~;
+			output[0] = (char)(0xF0 | c >> 18);
+			output[1] = (char)(0x80 | (c >> 12 & 0x3F));
+			output[2] = (char)(0x80 | (c >> 6 & 0x3F));
+			output[3] = (char)(0x80 | (c & 0x3F));
+			return 4;
+		default:
+			// 0x10FFFF and above is not defined.
+			return string::CONVERSION_FAILED~;
 	}
 }
 
-/**
- * Convert a code pointer into 1-2 UTF16 characters.
- *
- * @param c `The character to convert.`
- * @param [inout] output `the resulting UTF16 buffer to write to.`
- **/
+<*
+ Convert a code pointer into 1-2 UTF16 characters.
+
+ @param c : `The character to convert.`
+ @param [inout] output : `the resulting UTF16 buffer to write to.`
+*>
 fn void char32_to_utf16_unsafe(Char32 c, Char16** output)
 {
 	if (c < UTF16_SURROGATE_OFFSET)
@@ -64,14 +67,14 @@ fn void char32_to_utf16_unsafe(Char32 c, Char16** output)
 	(*output)++[0] = (Char16)low;
 }
 
-/**
- * Convert 1-2 UTF16 data points into UTF8.
- *
- * @param [in] ptr `The UTF16 data to convert.`
- * @param [inout] available `amount of UTF16 data available.`
- * @param [inout] output `the resulting utf8 buffer to write to.`
- **/
-fn void! char16_to_utf8_unsafe(Char16 *ptr, usize *available, char** output)
+<*
+ Convert 1-2 UTF16 data points into UTF8.
+
+ @param [in] ptr : `The UTF16 data to convert.`
+ @param [inout] available : `amount of UTF16 data available.`
+ @param [inout] output : `the resulting utf8 buffer to write to.`
+*>
+fn void? char16_to_utf8_unsafe(Char16 *ptr, usz *available, char** output)
 {
 	Char16 high = *ptr;
 	if (high & UTF16_SURROGATE_GENERIC_MASK != UTF16_SURROGATE_GENERIC_VALUE)
@@ -80,107 +83,115 @@ fn void! char16_to_utf8_unsafe(Char16 *ptr, usize *available, char** output)
 		*available = 1;
 		return;
 	}
-    // Low surrogate first is an error
-	if (high & UTF16_SURROGATE_MASK != UTF16_SURROGATE_HIGH_VALUE) return UnicodeResult.INVALID_UTF16!;
+	// Low surrogate first is an error
+	if (high & UTF16_SURROGATE_MASK != UTF16_SURROGATE_HIGH_VALUE) return string::INVALID_UTF16~;
 
 	// Unmatched high surrogate is an error
-	if (*available == 1) return UnicodeResult.INVALID_UTF16!;
+	if (*available == 1) return string::INVALID_UTF16~;
 
 	Char16 low = ptr[1];
 
 	// Unmatched high surrogate, invalid
-	if (low & UTF16_SURROGATE_MASK != UTF16_SURROGATE_LOW_VALUE) return UnicodeResult.INVALID_UTF16!;
+	if (low & UTF16_SURROGATE_MASK != UTF16_SURROGATE_LOW_VALUE) return string::INVALID_UTF16~;
 
-    // The high bits of the codepoint are the value bits of the high surrogate
-    // The low bits of the codepoint are the value bits of the low surrogate
-    Char32 uc = (high & UTF16_SURROGATE_CODEPOINT_MASK) << UTF16_SURROGATE_BITS
-                | (low & UTF16_SURROGATE_CODEPOINT_MASK) + UTF16_SURROGATE_OFFSET;
+	// The high bits of the codepoint are the value bits of the high surrogate
+	// The low bits of the codepoint are the value bits of the low surrogate
+	Char32 uc = (high & UTF16_SURROGATE_CODEPOINT_MASK) << UTF16_SURROGATE_BITS
+				| (low & UTF16_SURROGATE_CODEPOINT_MASK) + UTF16_SURROGATE_OFFSET;
 	char32_to_utf8_unsafe(uc, output);
 	*available = 2;
 }
-/**
- * @param c `The utf32 codepoint to convert`
- * @param [inout] output `the resulting buffer`
- **/
-fn void char32_to_utf8_unsafe(Char32 c, char** output)
+<*
+ @param c : `The utf32 codepoint to convert`
+ @param [inout] output : `the resulting buffer`
+*>
+fn usz char32_to_utf8_unsafe(Char32 c, char** output)
 {
-	switch (true)
+	switch
 	{
-		case c < 0x7f:
+		case c <= 0x7f:
 			(*output)++[0] = (char)c;
-		case c < 0x7ff:
+			return 1;
+		case c <= 0x7ff:
 			(*output)++[0] = (char)(0xC0 | c >> 6);
-            (*output)++[0] = (char)(0x80 | (c & 0x3F));
-        case c < 0xffff:
-	        (*output)++[0] = (char)(0xE0 | c >> 12);
-            (*output)++[0] = (char)(0x80 | (c >> 6 & 0x3F));
-            (*output)++[0] = (char)(0x80 | (c & 0x3F));
-        default:
-	 	    (*output)++[0] = (char)(0xF0 | c >> 18);
-            (*output)++[0] = (char)(0x80 | (c >> 12 & 0x3F));
-            (*output)++[0] = (char)(0x80 | (c >> 6 & 0x3F));
-            (*output)++[0] = (char)(0x80 | (c & 0x3F));
+			(*output)++[0] = (char)(0x80 | (c & 0x3F));
+			return 2;
+		case c <= 0xffff:
+			(*output)++[0] = (char)(0xE0 | c >> 12);
+			(*output)++[0] = (char)(0x80 | (c >> 6 & 0x3F));
+			(*output)++[0] = (char)(0x80 | (c & 0x3F));
+			return 3;
+		default:
+			(*output)++[0] = (char)(0xF0 | c >> 18);
+			(*output)++[0] = (char)(0x80 | (c >> 12 & 0x3F));
+			(*output)++[0] = (char)(0x80 | (c >> 6 & 0x3F));
+			(*output)++[0] = (char)(0x80 | (c & 0x3F));
+			return 4;
 	}
 }
 
-/**
- * @param [in] ptr `pointer to the first character to parse`
- * @param [inout] size `Set to max characters to read, set to characters read`
- * @return `the parsed 32 bit codepoint`
- **/
-fn Char32! utf8_to_char32(char* ptr, usize* size)
+<*
+ @param [in] ptr : `pointer to the first character to parse`
+ @param [inout] size : `Set to max characters to read, set to characters read`
+ @return `the parsed 32 bit codepoint`
+*>
+fn Char32? utf8_to_char32(char* ptr, usz* size)
 {
-	usize max_size = *size;
-	if (max_size < 1) return UnicodeResult.INVALID_UTF8!;
+	usz max_size = *size;
+	if (max_size < 1) return string::INVALID_UTF8~;
 	char c = (ptr++)[0];
 
-    if ((c & 0x80) == 0)
-    {
-        *size = 1;
-        return c;
-    }
-    if ((c & 0xE0) == 0xC0)
-    {
-		if (max_size < 2) return UnicodeResult.INVALID_UTF8!;
-        *size = 2;
-        Char32 uc = (c & 0x1F) << 6;
+	if ((c & 0x80) == 0)
+	{
+		*size = 1;
+		return c;
+	}
+	if ((c & 0xE0) == 0xC0)
+	{
+		if (max_size < 2) return string::INVALID_UTF8~;
+		*size = 2;
+		Char32 uc = (c & 0x1F) << 6;
 		c = *ptr;
-		if (c & 0xC0 != 0x80) return UnicodeResult.INVALID_UTF8!;
+		// Overlong sequence or invalid second.
+		if (!uc || c & 0xC0 != 0x80) return string::INVALID_UTF8~;
 		return uc + c & 0x3F;
-    }
-    if ((c & 0xF0) == 0xE0)
-    {
-		if (max_size < 3) return UnicodeResult.INVALID_UTF8!;
-        *size = 3;
-        Char32 uc = (c & 0x0F) << 12;
+	}
+	if ((c & 0xF0) == 0xE0)
+	{
+		if (max_size < 3) return string::INVALID_UTF8~;
+		*size = 3;
+		Char32 uc = (c & 0x0F) << 12;
 		c = ptr++[0];
-		if (c & 0xC0 != 0x80) return UnicodeResult.INVALID_UTF8!;
+		if (c & 0xC0 != 0x80) return string::INVALID_UTF8~;
 		uc += (c & 0x3F) << 6;
 		c = ptr++[0];
-		if (c & 0xC0 != 0x80) return UnicodeResult.INVALID_UTF8!;
+		// Overlong sequence or invalid last
+		if (!uc || c & 0xC0 != 0x80) return string::INVALID_UTF8~;
 		return uc + c & 0x3F;
-    }
-    if (max_size < 4) return UnicodeResult.INVALID_UTF8!;
-    *size = 4;
-    Char32 uc = (c & 0x07) << 18;
+	}
+	if (max_size < 4) return string::INVALID_UTF8~;
+	if ((c & 0xF8) != 0xF0) return string::INVALID_UTF8~;
+	*size = 4;
+	Char32 uc = (c & 0x07) << 18;
 	c = ptr++[0];
-	if (c & 0xC0 != 0x80) return UnicodeResult.INVALID_UTF8!;
+	if (c & 0xC0 != 0x80) return string::INVALID_UTF8~;
 	uc += (c & 0x3F) << 12;
 	c = ptr++[0];
-	if (c & 0xC0 != 0x80) return UnicodeResult.INVALID_UTF8!;
+	if (c & 0xC0 != 0x80) return string::INVALID_UTF8~;
 	uc += (c & 0x3F) << 6;
 	c = ptr++[0];
-	if (c & 0xC0 != 0x80) return UnicodeResult.INVALID_UTF8!;
+	// Overlong sequence or invalid last
+	if (!uc || c & 0xC0 != 0x80) return string::INVALID_UTF8~;
 	return uc + c & 0x3F;
 }
 
-/**
- * @param utf8 `An UTF-8 encoded slice of bytes`
- * @return `the number of encoded code points`
- **/
-fn usize utf8_codepoints(char[] utf8)
+<*
+ @param utf8 : `An UTF-8 encoded slice of bytes`
+ @return `the number of encoded code points`
+*>
+fn usz utf8_codepoints(String utf8)
 {
-	usize len = 0;
+	usz len = 0;
 	foreach (char c : utf8)
 	{
 		if (c & 0xC0 != 0x80) len++;
@@ -188,23 +199,23 @@ fn usize utf8_codepoints(char[] utf8)
 	return len;
 }
 
-/**
- * Calculate the UTF8 length required to encode an UTF32 array.
- * @param [in] utf32 `the utf32 data to calculate from`
- * @return `the length of the resulting UTF8 array`
- **/
-fn usize utf8len_for_utf32(Char32[] utf32)
+<*
+ Calculate the UTF8 length required to encode an UTF32 array.
+ @param [in] utf32 : `the utf32 data to calculate from`
+ @return `the length of the resulting UTF8 array`
+*>
+fn usz utf8len_for_utf32(Char32[] utf32)
 {
-	usize len = 0;
+	usz len = 0;
 	foreach (Char32 uc : utf32)
 	{
 		switch (true)
 		{
-			case uc < 0x7f:
+			case uc <= 0x7f:
 				len++;
-			case uc < 0x7ff:
+			case uc <= 0x7ff:
 				len += 2;
-			case uc < 0xffff:
+			case uc <= 0xffff:
 				len += 3;
 			default:
 				len += 4;
@@ -213,26 +224,26 @@ fn usize utf8len_for_utf32(Char32[] utf32)
 	return len;
 }
 
-/**
- * Calculate the UTF8 length required to encode an UTF16 array.
- * @param [in] utf16 `the utf16 data to calculate from`
- * @return `the length of the resulting UTF8 array`
- **/
-fn usize utf8len_for_utf16(Char16[] utf16)
+<*
+ Calculate the UTF8 length required to encode an UTF16 array.
+ @param [in] utf16 : `the utf16 data to calculate from`
+ @return `the length of the resulting UTF8 array`
+*>
+fn usz utf8len_for_utf16(Char16[] utf16)
 {
-	usize len = 0;
-	usize len16 = utf16.len;
-	for (usize i = 0; i < len16; i++)
+	usz len = 0;
+	usz len16 = utf16.len;
+	for (usz i = 0; i < len16; i++)
 	{
 		Char16 c = utf16[i];
 		if (c & UTF16_SURROGATE_GENERIC_MASK != UTF16_SURROGATE_GENERIC_VALUE)
 		{
-			if (c < 0x7f)
+			if (c <= 0x7f)
 			{
 				len++;
 				continue;
 			}
-			if (c < 0x7ff)
+			if (c <= 0x7ff)
 			{
 				len += 2;
 				continue;
@@ -245,16 +256,16 @@ fn usize utf8len_for_utf16(Char16[] utf16)
 	return len;
 }
 
-/**
- * Calculate the UTF16 length required to encode a UTF8 array.
- * @param utf8 `the utf8 data to calculate from`
- * @return `the length of the resulting UTF16 array`
- **/
-fn usize utf16len_for_utf8(char[] utf8)
+<*
+ Calculate the UTF16 length required to encode a UTF8 array.
+ @param utf8 : `the utf8 data to calculate from`
+ @return `the length of the resulting UTF16 array`
+*>
+fn usz utf16len_for_utf8(String utf8)
 {
-	usize len = utf8.len;
-	usize len16 = 0;
-	for (usize i = 0; i < len; i++)
+	usz len = utf8.len;
+	usz len16 = 0;
+	for (usz i = 0; i < len; i++)
 	{
 		len16++;
 		char c = utf8[i];
@@ -265,17 +276,17 @@ fn usize utf16len_for_utf8(char[] utf8)
 		if (c & 0xF0 == 0xE0) continue;
 		i++;
 		len16++;
-    }
-    return len16;
+	}
+	return len16;
 }
 
-/**
- * @param [in] utf32 `the UTF32 array to check the length for`
- * @return `the required length of an UTF16 array to hold the UTF32 data.`
- **/
-fn usize utf16len_for_utf32(Char32[] utf32)
+<*
+ @param [in] utf32 : `the UTF32 array to check the length for`
+ @return `the required length of an UTF16 array to hold the UTF32 data.`
+*>
+fn usz utf16len_for_utf32(Char32[] utf32)
 {
-	usize len = utf32.len;
+	usz len = utf32.len;
 	foreach (Char32 uc : utf32)
 	{
 		if (uc >= UTF16_SURROGATE_OFFSET) len++;
@@ -283,117 +294,119 @@ fn usize utf16len_for_utf32(Char32[] utf32)
 	return len;
 }
 
-/**
- * Convert an UTF32 array to an UTF8 array.
- *
- * @param [in] utf32
- * @param [out] utf8_buffer
- * @return `the number of bytes written.`
- **/
-fn usize! utf32to8(Char32[] utf32, char[] utf8_buffer)
+<*
+ Convert an UTF32 array to an UTF8 array.
+
+ @param [in] utf32
+ @param [out] utf8_buffer
+ @return `the number of bytes written.`
+*>
+fn usz? utf32to8(Char32[] utf32, char[] utf8_buffer)
 {
-	usize len = utf8_buffer.len;
-	char* ptr = utf8_buffer.ptr;
-	foreach (Char32 uc : utf32)
+	char[] buffer = utf8_buffer;
+	foreach (uc : utf32)
 	{
-		usize used = char32_to_utf8(uc, ptr, len) @inline?;
-		len -= used;
-		ptr += used;
+		usz used = char32_to_utf8(uc, buffer) @inline!;
+		buffer = buffer[used..];
 	}
-	return utf8_buffer.len - len;
+	// Zero terminate if there is space.
+	if (buffer.len > 0) buffer[0] = 0;
+	return utf8_buffer.len - buffer.len;
 }
 
-/**
- * Convert an UTF8 array to an UTF32 array.
- *
- * @param [in] utf8
- * @param [out] utf32_buffer
- * @return `the number of Char32s written.`
- **/
-fn usize! utf8to32(char[] utf8, Char32[] utf32_buffer)
+<*
+ Convert an UTF8 array to an UTF32 array.
+
+ @param [in] utf8
+ @param [out] utf32_buffer
+ @return `the number of Char32s written.`
+*>
+fn usz? utf8to32(String utf8, Char32[] utf32_buffer)
 {
-	usize len = utf8.len;
+	usz len = utf8.len;
 	Char32* ptr = utf32_buffer.ptr;
-    usize len32 = 0;
-    usize buf_len = utf32_buffer.len;
-    for (usize i = 0; i < len;)
-    {
-        if (len32 == buf_len) return UnicodeResult.CONVERSION_FAILED!;
-        usize width = len - i;
-    	Char32 uc = utf8_to_char32(&utf8[i], &width) @inline?;
-    	i += width;
-    	ptr[len32++] = uc;
-    }
-    return len32;
+	usz len32 = 0;
+	usz buf_len = utf32_buffer.len;
+	for (usz i = 0; i < len;)
+	{
+		if (len32 == buf_len) return string::CONVERSION_FAILED~;
+		usz width = len - i;
+		Char32 uc = utf8_to_char32(&utf8[i], &width) @inline!;
+		i += width;
+		ptr[len32++] = uc;
+	}
+	// Zero terminate if possible
+	if (len32 + 1 < buf_len) ptr[len32] = 0;
+	return len32;
 }
 
-/**
- * Copy an array of UTF16 data into an UTF8 buffer without bounds
- * checking. This will assume the buffer is sufficiently large to hold
- * the converted data.
- *
- * @param [in] utf16 `The UTF16 array containing the data to convert.`
- * @param [out] utf8_buffer `the (sufficiently large) buffer to hold the UTF16 data.`
- **/
-fn void! utf16to8_unsafe(Char16[] utf16, char* utf8_buffer)
+<*
+ Copy an array of UTF16 data into an UTF8 buffer without bounds
+ checking. This will assume the buffer is sufficiently large to hold
+ the converted data.
+
+ @param [in] utf16 : `The UTF16 array containing the data to convert.`
+ @param [out] utf8_buffer : `the (sufficiently large) buffer to hold the UTF16 data.`
+*>
+fn void? utf16to8_unsafe(Char16[] utf16, char* utf8_buffer)
 {
-	usize len16 = utf16.len;
-	for (usize i = 0; i < len16;)
+	usz len16 = utf16.len;
+	for (usz i = 0; i < len16;)
 	{
-		usize available = len16 - i;
-		char16_to_utf8_unsafe(&utf16[i], &available, &utf8_buffer) @inline?;
+		usz available = len16 - i;
+		char16_to_utf8_unsafe(&utf16[i], &available, &utf8_buffer) @inline!;
 		i += available;
 	}
 }
 
-/**
- * Copy an array of UTF8 data into an UTF32 buffer without bounds
- * checking. This will assume the buffer is sufficiently large to hold
- * the converted data.
- *
- * @param [in] utf8 `The UTF8 buffer containing the data to convert.`
- * @param [out] utf32_buffer `the (sufficiently large) buffer to hold the UTF8 data.`
- **/
-fn void! utf8to32_unsafe(char[] utf8, Char32* utf32_buffer)
+<*
+ Copy an array of UTF8 data into an UTF32 buffer without bounds
+ checking. This will assume the buffer is sufficiently large to hold
+ the converted data.
+
+ @param [in] utf8 : `The UTF8 buffer containing the data to convert.`
+ @param [out] utf32_buffer : `the (sufficiently large) buffer to hold the UTF8 data.`
+*>
+fn void? utf8to32_unsafe(String utf8, Char32* utf32_buffer)
 {
-	usize len = utf8.len;
-	for (usize i = 0; i < len;)
-    {
-        usize width = len - i;
-    	Char32 uc = utf8_to_char32(&utf8[i], &width) @inline?;
-    	i += width;
-    	(utf32_buffer++)[0] = uc;
-    }
+	usz len = utf8.len;
+	for (usz i = 0; i < len;)
+	{
+		usz width = len - i;
+		Char32 uc = utf8_to_char32(&utf8[i], &width) @inline!;
+		i += width;
+		(utf32_buffer++)[0] = uc;
+	}
 }
 
-/**
- * Copy an array of UTF8 data into an UTF16 buffer without bounds
- * checking. This will assume the buffer is sufficiently large to hold
- * the converted data.
- *
- * @param [in] utf8 `The UTF8 buffer containing the data to convert.`
- * @param [out] utf16_buffer `the (sufficiently large) buffer to hold the UTF8 data.`
- **/
-fn void! utf8to16_unsafe(char[] utf8, Char16* utf16_buffer)
+<*
+ Copy an array of UTF8 data into an UTF16 buffer without bounds
+ checking. This will assume the buffer is sufficiently large to hold
+ the converted data.
+
+ @param [in] utf8 : `The UTF8 buffer containing the data to convert.`
+ @param [out] utf16_buffer : `the (sufficiently large) buffer to hold the UTF8 data.`
+*>
+fn void? utf8to16_unsafe(String utf8, Char16* utf16_buffer)
 {
-	usize len = utf8.len;
-    for (usize i = 0; i < len;)
-    {
-        usize width = len - i;
-    	Char32 uc = utf8_to_char32(&utf8[i], &width) @inline?;
-        char32_to_utf16_unsafe(uc, &utf16_buffer) @inline;
-        i += width;
-    }
+	usz len = utf8.len;
+	for (usz i = 0; i < len;)
+	{
+		usz width = len - i;
+		Char32 uc = utf8_to_char32(&utf8[i], &width) @inline!;
+		char32_to_utf16_unsafe(uc, &utf16_buffer) @inline;
+		i += width;
+	}
 }
 
-/**
- * Copy an array of UTF32 code points into an UTF8 buffer without bounds
- * checking. This will assume the buffer is sufficiently large to hold
- * the converted data.
- *
- * @param [in] utf32 `The UTF32 buffer containing the data to convert.`
- * @param [out] utf8_buffer `the (sufficiently large) buffer to hold the UTF8 data.`
- **/
+<*
+ Copy an array of UTF32 code points into an UTF8 buffer without bounds
+ checking. This will assume the buffer is sufficiently large to hold
+ the converted data.
+
+ @param [in] utf32 : `The UTF32 buffer containing the data to convert.`
+ @param [out] utf8_buffer : `the (sufficiently large) buffer to hold the UTF8 data.`
+*>
 fn void utf32to8_unsafe(Char32[] utf32, char* utf8_buffer)
 {
 	char* start = utf8_buffer;

lib/std/core/dstring.c3

@@ -0,0 +1,693 @@
+module std::core::dstring;
+import std::io, std::math;
+
+<*
+ The DString offers a dynamic string builder.
+*>
+typedef DString (OutStream) = DStringOpaque*;
+typedef DStringOpaque = void;
+
+const usz MIN_CAPACITY @private = 16;
+
+<*
+ Initialize the DString with a particular allocator.
+
+ @param [&inout] allocator : "The allocator to use"
+ @param capacity : "Starting capacity, defaults to MIN_CAPACITY and cannot be smaller"
+ @return "Return the DString itself"
+ @require !self.data() : "String already initialized"
+*>
+fn DString DString.init(&self, Allocator allocator, usz capacity = MIN_CAPACITY)
+{
+	if (capacity < MIN_CAPACITY) capacity = MIN_CAPACITY;
+	StringData* data = allocator::alloc_with_padding(allocator, StringData, capacity)!!;
+	data.allocator = allocator;
+	data.len = 0;
+	data.capacity = capacity;
+	return *self = (DString)data;
+}
+
+<*
+ Initialize the DString with the temp allocator. Note that if the dstring is never
+ initialized, this is the allocator it will default to.
+
+ @param capacity : "Starting capacity, defaults to MIN_CAPACITY and cannot be smaller"
+ @return "Return the DString itself"
+ @require !self.data() : "String already initialized"
+*>
+fn DString DString.tinit(&self, usz capacity = MIN_CAPACITY)
+{
+	return self.init(tmem, capacity) @inline;
+}
+
+fn DString new_with_capacity(Allocator allocator, usz capacity)
+{
+	return (DString){}.init(allocator, capacity);
+}
+
+fn DString temp_with_capacity(usz capacity) => new_with_capacity(tmem, capacity) @inline;
+
+fn DString new(Allocator allocator, String c = "")
+{
+	usz len = c.len;
+	StringData* data = (StringData*)new_with_capacity(allocator, len);
+	if (len)
+	{
+		data.len = len;
+		mem::copy(&data.chars, c.ptr, len);
+	}
+	return (DString)data;
+}
+
+fn DString temp(String s = "") => new(tmem, s) @inline;
+
+
+fn void DString.replace_char(self, char ch, char replacement)
+{
+	StringData* data = self.data();
+	foreach (&c : data.chars[:data.len])
+	{
+		if (*c == ch) *c = replacement;
+	}
+}
+
+fn void DString.replace(&self, String needle, String replacement)
+{
+	StringData* data = self.data();
+	usz needle_len = needle.len;
+	if (!data || data.len < needle_len) return;
+	usz replace_len = replacement.len;
+	if (needle_len == 1 && replace_len == 1)
+	{
+		self.replace_char(needle[0], replacement[0]);
+		return;
+	}
+	@pool()
+	{
+		String str = self.tcopy_str();
+		self.clear();
+		usz len = str.len;
+		usz match = 0;
+		foreach (i, c : str)
+		{
+			if (c == needle[match])
+			{
+				match++;
+				if (match == needle_len)
+				{
+					self.append_string(replacement);
+					match = 0;
+					continue;
+				}
+				continue;
+			}
+			if (match > 0)
+			{
+				self.append_string(str[i - match:match]);
+				match = 0;
+			}
+			self.append_char(c);
+		}
+		if (match > 0) self.append_string(str[^match:match]);
+	};
+}
+
+fn DString DString.concat(self, Allocator allocator, DString b) @nodiscard
+{
+	DString string;
+	string.init(allocator, self.len() + b.len());
+	string.append(self);
+	string.append(b);
+	return string;
+}
+
+fn DString DString.tconcat(self, DString b) => self.concat(tmem, b);
+
+fn ZString DString.zstr_view(&self)
+{
+	StringData* data = self.data();
+	if (!data) return "";
+	if (data.capacity == data.len)
+	{
+		self.reserve(1);
+		data = self.data();
+		data.chars[data.len] = 0;
+	}
+	else if (data.chars[data.len] != 0)
+	{
+		data.chars[data.len] = 0;
+	}
+	return (ZString)&data.chars[0];
+}
+
+fn usz DString.capacity(self)
+{
+	if (!self) return 0;
+	return self.data().capacity;
+}
+
+fn usz DString.len(&self) @dynamic @operator(len)
+{
+	if (!*self) return 0;
+	return self.data().len;
+}
+
+<*
+ @require new_size <= self.len()
+*>
+fn void DString.chop(self, usz new_size)
+{
+	if (!self) return;
+	self.data().len = new_size;
+}
+
+fn String DString.str_view(self)
+{
+	StringData* data = self.data();
+	if (!data) return "";
+	return (String)data.chars[:data.len];
+}
+
+<*
+ @require index < self.len()
+ @require self.data() != null : "Empty string"
+*>
+fn char DString.char_at(self, usz index) @operator([])
+{
+	return self.data().chars[index];
+}
+
+<*
+ @require index < self.len()
+ @require self.data() != null  : "Empty string"
+*>
+fn char* DString.char_ref(&self, usz index) @operator(&[])
+{
+	return &self.data().chars[index];
+}
+
+fn usz DString.append_utf32(&self, Char32[] chars)
+{
+	self.reserve(chars.len);
+	usz end = self.len();
+	foreach (Char32 c : chars)
+	{
+		self.append_char32(c);
+	}
+	return self.data().len - end;
+}
+
+<*
+ @require index < self.len()
+*>
+fn void DString.set(self, usz index, char c) @operator([]=)
+{
+	self.data().chars[index] = c;
+}
+
+fn void DString.append_repeat(&self, char c, usz times)
+{
+	if (times == 0) return;
+	self.reserve(times);
+	StringData* data = self.data();
+	for (usz i = 0; i < times; i++)
+	{
+		data.chars[data.len++] = c;
+	}
+}
+
+<*
+ @require c <= 0x10ffff
+*>
+fn usz DString.append_char32(&self, Char32 c)
+{
+	char[4] buffer @noinit;
+	char* p = &buffer;
+	usz n = conv::char32_to_utf8_unsafe(c, &p);
+	self.reserve(n);
+	StringData* data = self.data();
+	data.chars[data.len:n] = buffer[:n];
+	data.len += n;
+	return n;
+}
+
+fn DString DString.tcopy(&self) => self.copy(tmem);
+
+fn DString DString.copy(self, Allocator allocator) @nodiscard
+{
+	if (!self) return new(allocator);
+	StringData* data = self.data();
+	DString new_string = new_with_capacity(allocator, data.capacity);
+	mem::copy((char*)new_string.data(), (char*)data, StringData.sizeof + data.len);
+	return new_string;
+}
+
+fn ZString DString.copy_zstr(self, Allocator allocator) @nodiscard
+{
+	usz str_len = self.len();
+	if (!str_len)
+	{
+		return (ZString)allocator::calloc(allocator, 1);
+	}
+	char* zstr = allocator::malloc(allocator, str_len + 1);
+	StringData* data = self.data();
+	mem::copy(zstr, &data.chars, str_len);
+	zstr[str_len] = 0;
+	return (ZString)zstr;
+}
+
+fn String DString.copy_str(self, Allocator allocator) @nodiscard
+{
+	return (String)self.copy_zstr(allocator)[:self.len()];
+}
+
+fn String DString.tcopy_str(self) @nodiscard => self.copy_str(tmem) @inline;
+
+fn bool DString.equals(self, DString other_string)
+{
+	StringData *str1 = self.data();
+	StringData *str2 = other_string.data();
+	if (str1 == str2) return true;
+	if (!str1) return str2.len == 0;
+	if (!str2) return str1.len == 0;
+	usz str1_len = str1.len;
+	if (str1_len != str2.len) return false;
+	for (int i = 0; i < str1_len; i++)
+	{
+		if (str1.chars[i] != str2.chars[i]) return false;
+	}
+	return true;
+}
+
+fn void DString.free(&self)
+{
+	if (!*self) return;
+	StringData* data = self.data();
+	if (!data) return;
+	allocator::free(data.allocator, data);
+	*self = (DString)null;
+}
+
+fn bool DString.less(self, DString other_string)
+{
+	StringData* str1 = self.data();
+	StringData* str2 = other_string.data();
+	if (str1 == str2) return false;
+	if (!str1) return str2.len != 0;
+	if (!str2) return str1.len == 0;
+	usz str1_len = str1.len;
+	usz str2_len = str2.len;
+	if (str1_len != str2_len) return str1_len < str2_len;
+	for (int i = 0; i < str1_len; i++)
+	{
+		if (str1.chars[i] >= str2.chars[i]) return false;
+	}
+	return true;
+}
+
+fn void DString.append_chars(&self, String str) @deprecated("Use append_string")
+{
+	self.append_bytes(str);
+}
+
+fn void DString.append_bytes(&self, char[] bytes)
+{
+	usz other_len = bytes.len;
+	if (!other_len) return;
+	if (!*self)
+	{
+		*self = temp((String)bytes);
+		return;
+	}
+	self.reserve(other_len);
+	StringData* data = self.data();
+	mem::copy(&data.chars[data.len], bytes.ptr, other_len);
+	data.len += other_len;
+}
+
+fn Char32[] DString.copy_utf32(&self, Allocator allocator)
+{
+	return self.str_view().to_utf32(allocator) @inline!!;
+}
+
+<*
+ @require $defined(String s = str) ||| $typeof(str) == DString : "Expected string or DString"
+*>
+macro void DString.append_string(&self, str)
+{
+	$if $typeof(str) == DString:
+		self.append_string_deprecated(str);
+	$else
+		self.append_bytes((String)str);
+	$endif
+}
+
+macro void DString.append_string_deprecated(&self, DString str) @deprecated("Use .append_dstring()")
+{
+	self.append_dstring(str);
+}
+
+fn void DString.append_dstring(&self, DString str)
+{
+	StringData* other = str.data();
+	if (!other) return;
+	self.append(str.str_view());
+}
+
+fn void DString.clear(self)
+{
+	if (!self) return;
+	self.data().len = 0;
+}
+
+fn usz? DString.write(&self, char[] buffer) @dynamic
+{
+	self.append_bytes(buffer);
+	return buffer.len;
+}
+
+fn void? DString.write_byte(&self, char c) @dynamic
+{
+	self.append_char(c);
+}
+
+fn void DString.append_char(&self, char c)
+{
+	if (!*self)
+	{
+		*self = temp_with_capacity(MIN_CAPACITY);
+	}
+	self.reserve(1);
+	StringData* data = self.data();
+	data.chars[data.len++] = c;
+}
+
+<*
+ @require start < self.len()
+ @require end < self.len()
+ @require end >= start : "End must be same or equal to the start"
+*>
+fn void DString.delete_range(&self, usz start, usz end)
+{
+	self.delete(start, end - start + 1);
+}
+
+<*
+ @require start < self.len()
+ @require start + len <= self.len()
+*>
+fn void DString.delete(&self, usz start, usz len = 1)
+{
+	if (!len) return;
+	StringData* data = self.data();
+	usz new_len = data.len - len;
+	if (new_len == 0)
+	{
+		data.len = 0;
+		return;
+	}
+	usz len_after = data.len - start - len;
+	if (len_after > 0)
+	{
+		data.chars[start:len_after] = data.chars[start + len:len_after];
+	}
+	data.len = new_len;
+}
+
+macro void DString.append(&self, value)
+{
+	var $Type = $typeof(value);
+	$switch $Type:
+		$case char:
+		$case ichar:
+			self.append_char(value);
+		$case DString:
+			self.append_dstring(value);
+		$case String:
+			self.append_string(value);
+		$case Char32:
+			self.append_char32(value);
+		$default:
+			$switch:
+				$case $defined((Char32)value):
+					self.append_char32((Char32)value);
+				$case $defined((String)value):
+					self.append_string((String)value);
+				$default:
+					$error "Unsupported type for append – use appendf instead.";
+			$endswitch
+	$endswitch
+}
+
+<*
+ @require index <= self.len()
+*>
+fn void DString.insert_chars_at(&self, usz index, String s)
+{
+	if (s.len == 0) return;
+	self.reserve(s.len);
+	StringData* data = self.data();
+	usz len = self.len();
+	if (data.chars[:len].ptr == s.ptr)
+	{
+		// Source and destination are the same: nothing to do.
+		return;
+	}
+	index = min(index, len);
+	data.len += s.len;
+
+	char* start = data.chars[index:s.len].ptr; // area to insert into
+	mem::move(start + s.len, start, len - index); // move existing data
+	switch
+	{
+		case s.ptr <= start && start < s.ptr + s.len:
+			// Overlapping areas.
+			foreach_r (i, c : s)
+			{
+				data.chars[index + i] = c;
+			}
+		case start <= s.ptr && s.ptr < start + len:
+			// Source has moved.
+			mem::move(start, s.ptr + s.len, s.len);
+		default:
+			mem::move(start, s, s.len);
+	}
+}
+
+<*
+ @require index <= self.len()
+*>
+fn void DString.insert_string_at(&self, usz index, DString str)
+{
+	StringData* other = str.data();
+	if (!other) return;
+	self.insert_at(index, str.str_view());
+}
+
+<*
+ @require index <= self.len()
+*>
+fn void DString.insert_char_at(&self, usz index, char c)
+{
+	self.reserve(1);
+	StringData* data = self.data();
+
+	char* start = &data.chars[index];
+	mem::move(start + 1, start, self.len() - index);
+	data.chars[index] = c;
+	data.len++;
+}
+
+<*
+ @require index <= self.len()
+*>
+fn usz DString.insert_char32_at(&self, usz index, Char32 c)
+{
+	char[4] buffer @noinit;
+	char* p = &buffer;
+	usz n = conv::char32_to_utf8_unsafe(c, &p);
+
+	self.reserve(n);
+	StringData* data = self.data();
+
+	char* start = &data.chars[index];
+	mem::move(start + n, start, self.len() - index);
+	data.chars[index:n] = buffer[:n];
+	data.len += n;
+
+	return n;
+}
+
+<*
+ @require index <= self.len()
+*>
+fn usz DString.insert_utf32_at(&self, usz index, Char32[] chars)
+{
+	usz n = conv::utf8len_for_utf32(chars);
+	
+	self.reserve(n);
+	StringData* data = self.data();
+
+	char* start = &data.chars[index];
+	mem::move(start + n, start, self.len() - index);
+
+	char[4] buffer @noinit;
+
+	foreach(c : chars)
+	{
+		char* p = &buffer;
+		usz m = conv::char32_to_utf8_unsafe(c, &p);
+		data.chars[index:m] = buffer[:m];
+		index += m;
+	}
+
+	data.len += n;
+
+	return n;
+}
+
+macro void DString.insert_at(&self, usz index, value)
+{
+	var $Type = $typeof(value);
+	$switch $Type:
+		$case char:
+		$case ichar:
+			self.insert_char_at(index, value);
+		$case DString:
+			self.insert_string_at(index, value);
+		$case String:
+			self.insert_chars_at(index, value);
+		$case Char32:
+			self.insert_char32_at(index, value);
+		$default:
+			$switch:
+				$case $defined((Char32)value):
+					self.insert_char32_at(index, (Char32)value);
+				$case $defined((String)value):
+					self.insert_chars_at(index, (String)value);
+				$default:
+					$error "Unsupported type for insert";
+			$endswitch
+	$endswitch
+}
+
+import libc;
+fn usz? DString.appendf(&self, String format, args...) @maydiscard
+{
+	if (!self.data()) self.tinit(format.len + 20);
+	Formatter formatter;
+	formatter.init(&out_string_append_fn, self);
+	return formatter.vprintf(format, args);
+}
+
+fn usz? DString.appendfn(&self, String format, args...) @maydiscard
+{
+	if (!self.data()) self.tinit(format.len + 20);
+	@pool()
+	{
+		Formatter formatter;
+		formatter.init(&out_string_append_fn, self);
+		usz len = formatter.vprintf(format, args)!;
+		self.append('\n');
+		return len + 1;
+	};
+}
+
+fn DString join(Allocator allocator, String[] s, String joiner) @nodiscard
+{
+	if (!s.len) return new(allocator);
+	usz total_size = joiner.len * s.len;
+	foreach (String* &str : s)
+	{
+		total_size += str.len;
+	}
+	DString res = new_with_capacity(allocator, total_size);
+	res.append(s[0]);
+	foreach (String str : s[1..])
+	{
+		res.append(joiner);
+		res.append(str);
+	}
+	return res;
+}
+
+fn void? out_string_append_fn(void* data, char c) @private
+{
+	DString* s = data;
+	s.append_char(c);
+}
+
+fn void DString.reverse(self)
+{
+	StringData *data = self.data();
+	if (!data) return;
+	isz mid = data.len / 2;
+	for (isz i = 0; i < mid; i++)
+	{
+		char temp = data.chars[i];
+		isz reverse_index = data.len - 1 - i;
+		data.chars[i] = data.chars[reverse_index];
+		data.chars[reverse_index] = temp;
+	}
+}
+
+fn StringData* DString.data(self) @inline
+{
+	return (StringData*)self;
+}
+
+fn void DString.reserve(&self, usz addition)
+{
+	StringData* data = self.data();
+	if (!data)
+	{
+		*self = dstring::temp_with_capacity(addition);
+		return;
+	}
+	usz len = data.len + addition;
+	if (data.capacity >= len) return;
+	usz new_capacity = data.capacity * 2;
+	if (new_capacity < MIN_CAPACITY) new_capacity = MIN_CAPACITY;
+	if (new_capacity < len) new_capacity = math::next_power_of_2(len);
+	data.capacity = new_capacity;
+	*self = (DString)allocator::realloc(data.allocator, data, StringData.sizeof + new_capacity);
+}
+
+fn usz? DString.read_from_stream(&self, InStream reader)
+{
+	if (&reader.available)
+	{
+		usz total_read = 0;
+		while (ulong available = reader.available()!)
+		{
+			if (available > isz.max) available = (ulong)isz.max;
+			self.reserve((usz)available);
+			StringData* data = self.data();
+			usz len = reader.read(data.chars[data.len..(data.capacity - 1)])!;
+			total_read += len;
+			data.len += len;
+		}
+		return total_read;
+	}
+	usz total_read = 0;
+	while (true)
+	{
+		// Reserve at least 16 bytes
+		self.reserve(16);
+		StringData* data = self.data();
+		// Read into the rest of the buffer
+		usz read = reader.read(data.chars[data.len..(data.capacity - 1)])!;
+		data.len += read;
+		// Ok, we reached the end.
+		if (read < 16) return total_read;
+		// Otherwise go another round
+	}
+}
+
+struct StringData @private
+{
+	Allocator allocator;
+	usz len;
+	usz capacity;
+	char[*] chars;
+}

lib/std/core/env.c3

@@ -1,14 +1,22 @@
-// Copyright (c) 2021 Christoffer Lerno. All rights reserved.
+// Copyright (c) 2021-2024 Christoffer Lerno. All rights reserved.
 // Use of this source code is governed by the MIT license
 // a copy of which can be found in the LICENSE_STDLIB file.
 module std::core::env;
 
 enum CompilerOptLevel
 {
-    O0,
-    O1,
-    O2,
-    O3
+	O0,
+	O1,
+	O2,
+	O3
+}
+
+enum MemoryEnvironment
+{
+	NORMAL,
+	SMALL,
+	TINY,
+	NONE
 }
 
 enum OsType
@@ -24,7 +32,7 @@ enum OsType
 	KFREEBSD,
 	LINUX,
 	PS3,
-	MACOSX,
+	MACOS,
 	NETBSD,
 	OPENBSD,
 	SOLARIS,
@@ -49,10 +57,158 @@ enum OsType
 	HURD,
 	WASI,
 	EMSCRIPTEN,
+	ANDROID,
 }
 
-const OsType OS_TYPE = (OsType)($$OS_TYPE);
-const CompilerOptLevel COMPILER_OPT_LEVEL = (CompilerOptLevel)($$COMPILER_OPT_LEVEL);
+enum ArchType
+{
+	UNKNOWN,
+	ARM,          // ARM (little endian): arm, armv.*, xscale
+	ARMB,         // ARM (big endian): armeb
+	AARCH64,      // AArch64 (little endian): aarch64
+	AARCH64_BE,   // AArch64 (big endian): aarch64_be
+	AARCH64_32,   // AArch64 (little endian) ILP32: aarch64_32
+	ARC,          // ARC: Synopsys ARC
+	AVR,          // AVR: Atmel AVR microcontroller
+	BPFEL,        // eBPF or extended BPF or 64-bit BPF (little endian)
+	BPFEB,        // eBPF or extended BPF or 64-bit BPF (big endian)
+	HEXAGON,      // Hexagon: hexagon
+	MIPS,         // MIPS: mips, mipsallegrex, mipsr6
+	MIPSEL,       // MIPSEL: mipsel, mipsallegrexe, mipsr6el
+	MIPS64,       // MIPS64: mips64, mips64r6, mipsn32, mipsn32r6
+	MIPS64EL,     // MIPS64EL: mips64el, mips64r6el, mipsn32el, mipsn32r6el
+	MSP430,       // MSP430: msp430
+	PPC,          // PPC: powerpc
+	PPC64,        // PPC64: powerpc64, ppu
+	PPC64LE,      // PPC64LE: powerpc64le
+	R600,         // R600: AMD GPUs HD2XXX - HD6XXX
+	AMDGCN,       // AMDGCN: AMD GCN GPUs
+	RISCV32,      // RISC-V (32-bit): riscv32
+	RISCV64,      // RISC-V (64-bit): riscv64
+	SPARC,        // Sparc: sparc
+	SPARCV9,      // Sparcv9: Sparcv9
+	SPARCEL,      // Sparc: (endianness = little). NB: 'Sparcle' is a CPU variant
+	SYSTEMZ,      // SystemZ: s390x
+	TCE,          // TCE (http://tce.cs.tut.fi/): tce
+	TCELE,        // TCE little endian (http://tce.cs.tut.fi/): tcele
+	THUMB,        // Thumb (little endian): thumb, thumbv.*
+	THUMBEB,      // Thumb (big endian): thumbeb
+	X86,          // X86: i[3-9]86
+	X86_64,       // X86-64: amd64, x86_64
+	XCORE,        // XCore: xcore
+	NVPTX,        // NVPTX: 32-bit
+	NVPTX64,      // NVPTX: 64-bit
+	LE32,         // le32: generic little-endian 32-bit CPU (PNaCl)
+	LE64,         // le64: generic little-endian 64-bit CPU (PNaCl)
+	AMDIL,        // AMDIL
+	AMDIL64,      // AMDIL with 64-bit pointers
+	HSAIL,        // AMD HSAIL
+	HSAIL64,      // AMD HSAIL with 64-bit pointers
+	SPIR,         // SPIR: standard portable IR for OpenCL 32-bit version
+	SPIR64,       // SPIR: standard portable IR for OpenCL 64-bit version
+	KALIMBA,      // Kalimba: generic kalimba
+	SHAVE,        // SHAVE: Movidius vector VLIW processors
+	LANAI,        // Lanai: Lanai 32-bit
+	WASM32,       // WebAssembly with 32-bit pointers
+	WASM64,       // WebAssembly with 64-bit pointers
+	RSCRIPT32,    // 32-bit RenderScript
+	RSCRIPT64,    // 64-bit RenderScript
+	XTENSA,       // Xtensa
+}
+
+const String COMPILER_BUILD_HASH = $$BUILD_HASH;
+const String COMPILER_BUILD_DATE = $$BUILD_DATE;
+const OsType OS_TYPE = OsType.from_ordinal($$OS_TYPE);
+const ArchType ARCH_TYPE = ArchType.from_ordinal($$ARCH_TYPE);
+const usz MAX_VECTOR_SIZE = $$MAX_VECTOR_SIZE;
+const bool ARCH_32_BIT = $$REGISTER_SIZE == 32;
+const bool ARCH_64_BIT = $$REGISTER_SIZE == 64;
+const bool LIBC = $$COMPILER_LIBC_AVAILABLE;
+const bool NO_LIBC = !LIBC && !CUSTOM_LIBC;
+const bool CUSTOM_LIBC = $$CUSTOM_LIBC;
+const bool OLD_IO = $feature(OLD_IO);
+const CompilerOptLevel COMPILER_OPT_LEVEL = CompilerOptLevel.from_ordinal($$COMPILER_OPT_LEVEL);
 const bool BIG_ENDIAN = $$PLATFORM_BIG_ENDIAN;
-const bool I128_SUPPORT = $$PLATFORM_I128_SUPPORTED;
+const bool I128_NATIVE_SUPPORT = $$PLATFORM_I128_SUPPORTED;
+const bool F16_SUPPORT = $$PLATFORM_F16_SUPPORTED;
+const bool F128_SUPPORT = $$PLATFORM_F128_SUPPORTED;
+const REGISTER_SIZE = $$REGISTER_SIZE;
 const bool COMPILER_SAFE_MODE = $$COMPILER_SAFE_MODE;
+const bool DEBUG_SYMBOLS = $$DEBUG_SYMBOLS;
+const bool BACKTRACE = $$BACKTRACE;
+const usz LLVM_VERSION = $$LLVM_VERSION;
+const bool BENCHMARKING = $$BENCHMARKING;
+const bool TESTING = $$TESTING;
+const bool PANIC_MSG = $$PANIC_MSG;
+const MemoryEnvironment MEMORY_ENV = MemoryEnvironment.from_ordinal($$MEMORY_ENVIRONMENT);
+const bool TRACK_MEMORY = DEBUG_SYMBOLS && (COMPILER_SAFE_MODE || TESTING);
+const bool X86_64 = ARCH_TYPE == X86_64;
+const bool X86 = ARCH_TYPE == X86;
+const bool AARCH64 = ARCH_TYPE == AARCH64;
+const bool NATIVE_STACKTRACE = LINUX || DARWIN || OPENBSD || WIN32;
+const bool LINUX = LIBC && OS_TYPE == LINUX;
+const bool DARWIN = LIBC && os_is_darwin();
+const bool WIN32 = LIBC && OS_TYPE == WIN32;
+const bool POSIX = LIBC && os_is_posix();
+const bool OPENBSD = LIBC && OS_TYPE == OPENBSD;
+const bool FREEBSD = LIBC && OS_TYPE == FREEBSD;
+const bool NETBSD = LIBC && OS_TYPE == NETBSD;
+const bool BSD_FAMILY = env::FREEBSD || env::OPENBSD || env::NETBSD;
+const bool WASI = LIBC && OS_TYPE == WASI;
+const bool WASM = ARCH_TYPE == ArchType.WASM32 || ARCH_TYPE == ArchType.WASM64;
+const bool ANDROID = LIBC && OS_TYPE == ANDROID;
+const bool WASM_NOLIBC @builtin @deprecated("Use 'FREESTANDING_WASM' instead") = !LIBC && ARCH_TYPE == ArchType.WASM32 || ARCH_TYPE == ArchType.WASM64;
+const bool FREESTANDING_PE32 = NO_LIBC && OS_TYPE == WIN32;
+const bool FREESTANDING_MACHO = NO_LIBC && OS_TYPE == MACOS;
+const bool FREESTANDING_ELF = NO_LIBC && !env::FREESTANDING_PE32 && !env::FREESTANDING_MACHO && !env::FREESTANDING_WASM;
+const bool FREESTANDING_WASM = NO_LIBC && WASM;
+const bool FREESTANDING = env::FREESTANDING_PE32 || env::FREESTANDING_MACHO || env::FREESTANDING_ELF || env::FREESTANDING_WASM;
+const bool ADDRESS_SANITIZER = $$ADDRESS_SANITIZER;
+const bool MEMORY_SANITIZER = $$MEMORY_SANITIZER;
+const bool THREAD_SANITIZER = $$THREAD_SANITIZER;
+const bool ANY_SANITIZER = ADDRESS_SANITIZER || MEMORY_SANITIZER || THREAD_SANITIZER;
+const int LANGUAGE_DEV_VERSION = $$LANGUAGE_DEV_VERSION;
+const bool HAS_NATIVE_ERRNO = env::LINUX || env::ANDROID || env::OPENBSD || env::DARWIN || env::WIN32 || env::NETBSD;
+
+macro bool os_is_darwin() @const
+{
+	$switch OS_TYPE:
+	$case IOS:
+	$case MACOS:
+	$case TVOS:
+	$case WATCHOS:
+		return true;
+	$default:
+		return false;
+	$endswitch
+}
+
+macro bool os_is_posix() @const
+{
+	$switch OS_TYPE:
+	$case IOS:
+	$case MACOS:
+	$case NETBSD:
+	$case LINUX:
+	$case KFREEBSD:
+	$case FREEBSD:
+	$case OPENBSD:
+	$case SOLARIS:
+	$case TVOS:
+	$case WATCHOS:
+	$case ANDROID:
+		return true;
+	$case WIN32:
+	$case WASI:
+	$case EMSCRIPTEN:
+		return false;
+	$default:
+		$echo("Assuming non-Posix environment");
+		return false;
+	$endswitch
+}
+const String[] AUTHORS = $$AUTHORS;
+const String[] AUTHOR_EMAILS = $$AUTHOR_EMAILS;
+const String PROJECT_VERSION = $$PROJECT_VERSION;
+const BUILTIN_EXPECT_IS_DISABLED = $feature(DISABLE_BUILTIN_EXPECT);
+const BUILTIN_PREFETCH_IS_DISABLED = $feature(DISABLE_BUILTIN_PREFETCH);

lib/std/core/logging.c3

@@ -0,0 +1,240 @@
+module std::core::log;
+import std::io, std::thread, std::time, std::math::random;
+
+const FULL_LOG = env::COMPILER_SAFE_MODE || $feature(FULL_LOG);
+
+typedef LogCategory = inline char;
+typedef LogTag = char[12];
+
+const LogCategory CATEGORY_APPLICATION  = (LogCategory)0;
+const LogCategory CATEGORY_SYSTEM       = (LogCategory)1;
+const LogCategory CATEGORY_KERNEL       = (LogCategory)2;
+const LogCategory CATEGORY_AUDIO        = (LogCategory)3;
+const LogCategory CATEGORY_VIDEO        = (LogCategory)4;
+const LogCategory CATEGORY_RENDER       = (LogCategory)5;
+const LogCategory CATEGORY_INPUT        = (LogCategory)6;
+const LogCategory CATEGORY_NETWORK      = (LogCategory)7;
+const LogCategory CATEGORY_SOCKET       = (LogCategory)8;
+const LogCategory CATEGORY_SECURITY     = (LogCategory)9;
+const LogCategory CATEGORY_TEST         = (LogCategory)10;
+const LogCategory CATEGORY_ERROR        = (LogCategory)11;
+const LogCategory CATEGORY_ASSERT       = (LogCategory)12;
+const LogCategory CATEGORY_CRASH        = (LogCategory)13;
+const LogCategory CATEGORY_STATS        = (LogCategory)14;
+const LogCategory CATEGORY_CUSTOM_START = (LogCategory)100;
+
+tlocal LogCategory default_category = CATEGORY_APPLICATION;
+tlocal LogTag current_tag;
+
+
+enum LogPriority : int
+{
+	VERBOSE,
+	DEBUG,
+	INFO,
+	WARN,
+	ERROR,
+	CRITICAL,
+}
+
+interface Logger
+{
+	fn void log(LogPriority priority, LogCategory category, LogTag tag, String file, String function, int line, String fmt, any[] args);
+}
+
+macro void verbose(String fmt, ..., LogCategory category = default_category) => call_log(VERBOSE, category, fmt, $vasplat);
+macro void debug(String fmt, ..., LogCategory category = default_category) => call_log(DEBUG, category, fmt, $vasplat);
+macro void info(String fmt, ..., LogCategory category = default_category) => call_log(INFO, category, fmt, $vasplat);
+macro void warn(String fmt, ..., LogCategory category = default_category) => call_log(WARN, category, fmt, $vasplat);
+macro void error(String fmt, ..., LogCategory category = default_category) => call_log(ERROR, category, fmt, $vasplat);
+macro void critical(String fmt, ..., LogCategory category = default_category) => call_log(CRITICAL, category, fmt, $vasplat);
+
+macro void @category_scope(LogCategory new_category; @body)
+{
+	LogCategory old = default_category;
+	default_category = new_category;
+	defer default_category = old;
+	@body();
+}
+
+<*
+ @require tag_prefix.len <= 3 : "The prefix may not exceed 3 bytes"
+*>
+macro void @tag_scope(String tag_prefix = ""; @body)
+{
+	LogTag old = current_tag;
+	push_tag(tag_prefix);
+	defer current_tag = old;
+	@body();
+}
+
+<*
+ @require tag_prefix.len <= 3 : "The prefix may not exceed 3 bytes"
+*>
+macro void push_tag(String tag_prefix = "")
+{
+	current_tag = create_tag(tag_prefix);
+}
+
+<*
+ @require tag_prefix.len <= 3 : "The prefix may not exceed 3 bytes"
+*>
+fn LogTag create_tag(String tag_prefix)
+{
+	LogTag tag @noinit;
+	int start = 0;
+	foreach (int i, c : tag_prefix)
+	{
+		if (c == 0) break;
+		tag[start++] = c;
+	}
+	if (start > 0) tag[start++] = '_';
+	for (int i = start; i < tag.len; i++)
+	{
+		tag[i] = (char)rand_in_range('a', 'z');
+	}
+	return tag;
+}
+
+fn void set_priority_for_category(LogCategory category, LogPriority new_priority)
+{
+	@atomic_store(config_priorities[category], new_priority, UNORDERED);
+}
+
+fn LogPriority get_priority_for_category(LogCategory category)
+{
+	return @atomic_load(config_priorities[category], UNORDERED);
+}
+
+fn void set_priority_all(LogPriority new_priority)
+{
+	for (int i = 0; i < config_priorities.len; i++)
+	{
+		@atomic_store(config_priorities[i], new_priority, UNORDERED);
+	}
+}
+fn void set_logger(Logger logger)
+{
+	init();
+	if (!logger_mutex.is_initialized())
+	{
+		current_logger = logger;
+		current_logfn = &logger.log;
+		return;
+	}
+	logger_mutex.@in_lock()
+	{
+		current_logger = logger;
+		current_logfn = &logger.log;
+	};
+}
+
+macro void init()
+{
+	log_init.call(fn () => (void)logger_mutex.init());
+}
+
+macro void call_log(LogPriority prio, LogCategory category, String fmt, args...)
+{
+	$if FULL_LOG:
+	call_log_internal(prio, category, $$FILE, $$FUNC, $$LINE, fmt, args);
+	$else
+	call_log_internal(prio, category, "", "", 0, fmt, args);
+	$endif
+}
+
+fn void call_log_internal(LogPriority prio, LogCategory category, String file, String func, int line, String fmt, any[] args)
+{
+	LogPriority priority = mem::@atomic_load(config_priorities[category], UNORDERED);
+	if (priority > prio) return;
+	init();
+	bool locked = logger_mutex.is_initialized();
+	if (locked) logger_mutex.lock();
+	Logger logger = current_logger;
+	LogFn logfn = current_logfn;
+	defer if (locked) logger_mutex.unlock();
+	logfn(logger.ptr, prio, category, current_tag, file, func, line, fmt, args);
+}
+
+fn String? get_category_name(LogCategory category)
+{
+	String val = category_names[category];
+	return val ?: NOT_FOUND~;
+}
+
+fn void set_category_name(LogCategory category, String name)
+{
+	category_names[category] = name;
+}
+
+struct NullLogger (Logger)
+{
+	void* dummy;
+}
+
+fn void NullLogger.log(&self, LogPriority priority, LogCategory category, LogTag tag, String file, String function, int line, String fmt, any[] args) @dynamic
+{}
+
+struct MultiLogger (Logger)
+{
+	Logger[] loggers;
+}
+
+fn void MultiLogger.log(&self, LogPriority priority, LogCategory category, LogTag tag, String file, String function, int line, String fmt, any[] args) @dynamic
+{
+	foreach (logger : self.loggers)
+	{
+		logger.log(priority, category, tag, file, function, line, fmt, args);
+	}
+}
+
+
+module std::core::log @private;
+import std::io, std::thread, std::time;
+
+struct StderrLogger (Logger) @if(env::LIBC)
+{
+	void* dummy;
+}
+
+fn void StderrLogger.log(&self, LogPriority priority, LogCategory category, LogTag tag, String file, String function, int line, String fmt, any[] args) @dynamic @if(env::LIBC)
+{
+	@stack_mem(256 + 64; Allocator mem)
+	{
+		DString str;
+		str.init(mem, 256);
+		str.appendf(fmt, ...args);
+		TzDateTime time = datetime::now().to_local();
+		$if FULL_LOG:
+		io::eprintfn("[%02d:%02d:%02d:%04d] %s:%d [%s] %s", time.hour, time.min, time.sec, (time.usec / 1000), file, line, priority, str);
+		$else
+		io::eprintfn("[%02d:%02d:%02d:%04d] [%s] %s", time.hour, time.min, time.sec, (time.usec / 1000), priority, str);
+		$endif
+	};
+}
+
+alias LogFn = fn void(void*, LogPriority priority, LogCategory category, LogTag tag, String file, String function, int line, String fmt, any[] args);
+LogFn current_logfn = env::LIBC ??? (LogFn)&StderrLogger.log : (LogFn)&NullLogger.log;
+OnceFlag log_init;
+Mutex logger_mutex;
+Logger current_logger = env::LIBC ??? &stderr_logger : &null_logger;
+StderrLogger stderr_logger @if (env::LIBC);
+NullLogger null_logger;
+LogPriority[256] config_priorities = { [0..255] = ERROR, [CATEGORY_APPLICATION] = INFO, [CATEGORY_TEST] = VERBOSE, [CATEGORY_ASSERT] = WARN};
+String[256] category_names = {
+	[CATEGORY_APPLICATION] = "APP",
+    [CATEGORY_SYSTEM] = "SYSTEM",
+    [CATEGORY_KERNEL] = "KERNEL",
+    [CATEGORY_AUDIO] = "AUDIO",
+    [CATEGORY_VIDEO] = "VIDEO",
+    [CATEGORY_RENDER] = "RENDER",
+    [CATEGORY_INPUT] = "INPUT",
+    [CATEGORY_NETWORK] = "NETWORD",
+    [CATEGORY_SOCKET] = "SOCKET",
+    [CATEGORY_SECURITY] = "SECURITY",
+    [CATEGORY_TEST] = "TEST",
+    [CATEGORY_ERROR] = "ERROR",
+    [CATEGORY_ASSERT] = "ASSERT",
+    [CATEGORY_CRASH] = "CRASH",
+    [CATEGORY_STATS] = "STATS"
+};

lib/std/core/mem_allocator.c3

@@ -1,151 +1,646 @@
 module std::core::mem::allocator;
+import std::math;
 
-const MAX_MEMORY_ALIGNMENT = 0x1000_0000;
-const DEFAULT_MEM_ALIGNMENT = $alignof(void*) * 2;
-const DEFAULT_SIZE_PREFIX = usize.sizeof;
-const DEFAULT_SIZE_PREFIX_ALIGNMENT = $alignof(usize);
+// C3 has several different allocators available:
+//
+// Name                     Arena  Uses buffer  OOM Fallback?     Mark?   Reset?
+// ArenaAllocator             Yes          Yes             No       Yes      Yes
+// BackedArenaAllocator       Yes           No            Yes       Yes      Yes
+// DynamicArenaAllocator      Yes           No            Yes        No      Yes
+// HeapAllocator               No           No             No        No       No   *Note: Not for normal use
+// LibcAllocator               No           No             No        No       No   *Note: Wraps malloc
+// OnStackAllocator           Yes          Yes            Yes        No       No   *Note: Used by @stack_mem
+// TempAllocator              Yes           No            Yes        No*      No*  *Note: Mark/reset using @pool
+// TrackingAllocator           No           No            N/A        No       No   *Note: Wraps other heap allocator
+// Vmem                       Yes           No             No       Yes      Yes   *Note: Can be set to huge sizes
 
-const Allocator* NULL_ALLOCATOR = &_NULL_ALLOCATOR;
-const Allocator* LIBC_ALLOCATOR = &_SYSTEM_ALLOCATOR;
+const DEFAULT_SIZE_PREFIX = usz.sizeof;
+const DEFAULT_SIZE_PREFIX_ALIGNMENT = usz.alignof;
 
-define AllocatorFunction = fn void*!(Allocator* allocator, usize new_size, usize alignment, void* old_pointer, AllocationKind kind);
-
-struct Allocator
+struct TrackingEnv
 {
-    AllocatorFunction function;
+	String file;
+	String function;
+	uint line;
 }
 
-enum AllocationKind
+enum AllocInitType
 {
-    ALLOC,
-    CALLOC,
-    REALLOC,
-    FREE,
-    RESET,
+	NO_ZERO,
+	ZERO
 }
 
-fault AllocationFailure
+interface Allocator
 {
-    OUT_OF_MEMORY,
-    UNSUPPORTED_OPERATION,
+	<*
+	 Acquire memory from the allocator, with the given alignment and initialization type.
+
+	 @require !alignment || math::is_power_of_2(alignment)
+	 @require alignment <= mem::MAX_MEMORY_ALIGNMENT : `alignment too big`
+	 @require size > 0 : "The size must be 1 or more"
+	 @return? mem::INVALID_ALLOC_SIZE, mem::OUT_OF_MEMORY
+	*>
+	fn void*? acquire(usz size, AllocInitType init_type, usz alignment = 0);
+
+	<*
+	 Resize acquired memory from the allocator, with the given new size and alignment.
+
+	 @require !alignment || math::is_power_of_2(alignment)
+	 @require alignment <= mem::MAX_MEMORY_ALIGNMENT : `alignment too big`
+	 @require ptr != null
+	 @require new_size > 0
+	 @return? mem::INVALID_ALLOC_SIZE, mem::OUT_OF_MEMORY
+	*>
+	fn void*? resize(void* ptr, usz new_size, usz alignment = 0);
+
+	<*
+	 Release memory acquired using `acquire` or `resize`.
+
+	 @require ptr != null : "Empty pointers should never be released"
+	*>
+	fn void release(void* ptr, bool aligned);
 }
 
+alias MemoryAllocFn = fn char[]?(usz);
 
 
-/**
- * @require !alignment || math::is_power_of_2(alignment)
- */
-fn void*! Allocator.alloc(Allocator* allocator, usize size, usize alignment = 0) @inline
+
+fn usz alignment_for_allocation(usz alignment) @inline
 {
-	return allocator.function(allocator, size, alignment, null, ALLOC);
+	return alignment < mem::DEFAULT_MEM_ALIGNMENT ? mem::DEFAULT_MEM_ALIGNMENT : alignment;
 }
 
-/**
- * @require !alignment || math::is_power_of_2(alignment)
- */
-fn void*! Allocator.realloc(Allocator* allocator, void* old_pointer, usize size, usize alignment = 0) @inline
+macro void* malloc(Allocator allocator, usz size) @nodiscard
 {
-	return allocator.function(allocator, size, alignment, old_pointer, REALLOC);
+	return malloc_try(allocator, size)!!;
 }
 
-/**
- * @require !alignment || math::is_power_of_2(alignment)
- */
-fn void*! Allocator.calloc(Allocator* allocator, usize size, usize alignment = 0) @inline
+macro void*? malloc_try(Allocator allocator, usz size) @nodiscard
 {
-	return allocator.function(allocator, size, alignment, null, CALLOC);
+	if (!size) return null;
+	$if env::TESTING:
+		char* data = allocator.acquire(size, NO_ZERO)!;
+		mem::set(data, 0xAA, size, mem::DEFAULT_MEM_ALIGNMENT);
+		return data;
+	$else
+		return allocator.acquire(size, NO_ZERO);
+	$endif
 }
 
-fn void! Allocator.free(Allocator* allocator, void* old_pointer) @inline
+macro void* calloc(Allocator allocator, usz size) @nodiscard
 {
-	allocator.function(allocator, 0, 0, old_pointer, FREE)?;
+	return calloc_try(allocator, size)!!;
 }
 
-fn void Allocator.reset(Allocator* allocator)
+macro void*? calloc_try(Allocator allocator, usz size) @nodiscard
 {
-	allocator.function(allocator, 0, 0, null, RESET)!!;
+	if (!size) return null;
+	return allocator.acquire(size, ZERO);
 }
 
-private fn usize alignment_for_allocation(usize alignment) @inline
+macro void* realloc(Allocator allocator, void* ptr, usz new_size) @nodiscard
 {
-	if (alignment < DEFAULT_MEM_ALIGNMENT)
+	return realloc_try(allocator, ptr, new_size)!!;
+}
+
+macro void*? realloc_try(Allocator allocator, void* ptr, usz new_size) @nodiscard
+{
+	if (!new_size)
 	{
-		alignment = DEFAULT_SIZE_PREFIX_ALIGNMENT;
+		free(allocator, ptr);
+		return null;
 	}
-	return alignment;
+	if (!ptr) return allocator.acquire(new_size, NO_ZERO);
+	return allocator.resize(ptr, new_size);
 }
 
-struct DynamicArenaAllocator
+macro void free(Allocator allocator, void* ptr)
 {
-	inline Allocator allocator;
-	Allocator* backing_allocator;
-	DynamicArenaPage* page;
-	DynamicArenaPage* unused_page;
-	usize page_size;
+	if (!ptr) return;
+	$if env::TESTING:
+		((char*)ptr)[0] = 0xBA;
+	$endif
+	allocator.release(ptr, false);
 }
 
-/**
- * @require page_size >= 128
- * @require this != null
- **/
-fn void DynamicArenaAllocator.init(DynamicArenaAllocator* this, usize page_size, Allocator* backing_allocator = mem::allocator())
+macro void*? malloc_aligned(Allocator allocator, usz size, usz alignment) @nodiscard
 {
-	this.function = &dynamic_arena_allocator_function;
-	this.page = null;
-	this.unused_page = null;
-	this.page_size = page_size;
-	this.backing_allocator = backing_allocator;
+	if (!size) return null;
+	$if env::TESTING:
+		char* data = allocator.acquire(size, NO_ZERO, alignment)!;
+		mem::set(data, 0xAA, size, mem::DEFAULT_MEM_ALIGNMENT);
+		return data;
+	$else
+		return allocator.acquire(size, NO_ZERO, alignment);
+	$endif
 }
 
-/**
- * @require this != null
- **/
-fn void DynamicArenaAllocator.destroy(DynamicArenaAllocator* this)
+macro void*? calloc_aligned(Allocator allocator, usz size, usz alignment) @nodiscard
 {
-	DynamicArenaPage* page = this.page;
-	while (page)
+	if (!size) return null;
+	return allocator.acquire(size, ZERO, alignment);
+}
+
+macro void*? realloc_aligned(Allocator allocator, void* ptr, usz new_size, usz alignment) @nodiscard
+{
+	if (!new_size)
 	{
-		DynamicArenaPage* next_page = page.prev_arena;
-		this.backing_allocator.free(page)!!;
-		page = next_page;
+		free_aligned(allocator, ptr);
+		return null;
 	}
-	page = this.unused_page;
-	while (page)
+	if (!ptr)
 	{
-		DynamicArenaPage* next_page = page.prev_arena;
-		this.backing_allocator.free(page)!!;
-		page = next_page;
+		return malloc_aligned(allocator, new_size, alignment);
 	}
-	this.page = null;
-	this.unused_page = null;
+	return allocator.resize(ptr, new_size, alignment);
+}
+
+macro void free_aligned(Allocator allocator, void* ptr)
+{
+	if (!ptr) return;
+	$if env::TESTING:
+	((char*)ptr)[0] = 0xBA;
+	$endif
+	allocator.release(ptr, aligned: true);
+}
+
+<*
+ @require $Type.alignof <= mem::DEFAULT_MEM_ALIGNMENT : "Types with alignment exceeding the default must use 'new_aligned' instead"
+ @require $vacount < 2 : "Too many arguments."
+ @require $vacount == 0 ||| $defined($Type t = $vaexpr[0]) : "The second argument must be an initializer for the type"
+*>
+macro new(Allocator allocator, $Type, ...) @nodiscard
+{
+	$if $vacount == 0:
+		return ($Type*)calloc(allocator, $Type.sizeof);
+	$else
+		$Type* val = malloc(allocator, $Type.sizeof);
+		*val = $vaexpr[0];
+		return val;
+	$endif
+}
+
+<*
+ @require $Type.alignof <= mem::DEFAULT_MEM_ALIGNMENT : "Types with alignment exceeding the default must use 'new_aligned' instead"
+ @require $vacount < 2 : "Too many arguments."
+ @require $vacount == 0 ||| $defined($Type t = $vaexpr[0]) : "The second argument must be an initializer for the type"
+*>
+macro new_try(Allocator allocator, $Type, ...) @nodiscard
+{
+	$if $vacount == 0:
+		return ($Type*)calloc_try(allocator, $Type.sizeof);
+	$else
+		$Type* val = malloc_try(allocator, $Type.sizeof)!;
+		*val = $vaexpr[0];
+		return val;
+	$endif
+}
+
+<*
+ Allocate using an aligned allocation. This is necessary for types with a default memory alignment
+ exceeding DEFAULT_MEM_ALIGNMENT. IMPORTANT! It must be freed using free_aligned.
+ @require $vacount < 2 : "Too many arguments."
+ @require $vacount == 0 ||| $defined($Type t = $vaexpr[0]) : "The second argument must be an initializer for the type"
+*>
+macro new_aligned(Allocator allocator, $Type, ...) @nodiscard
+{
+	$if $vacount == 0:
+		return ($Type*)calloc_aligned(allocator, $Type.sizeof, $Type.alignof);
+	$else
+		$Type* val = malloc_aligned(allocator, $Type.sizeof, $Type.alignof)!;
+		*val = $vaexpr[0];
+		return val;
+	$endif
+}
+
+<*
+ @require $Type.alignof <= mem::DEFAULT_MEM_ALIGNMENT
+*>
+macro new_with_padding(Allocator allocator, $Type, usz padding) @nodiscard
+{
+	return ($Type*)calloc_try(allocator, $Type.sizeof + padding);
+}
+
+<*
+ @require $Type.alignof <= mem::DEFAULT_MEM_ALIGNMENT : "Types with alignment exceeding the default must use 'alloc_aligned' instead"
+*>
+macro alloc(Allocator allocator, $Type) @nodiscard
+{
+	return ($Type*)malloc(allocator, $Type.sizeof);
+}
+
+<*
+ @require $Type.alignof <= mem::DEFAULT_MEM_ALIGNMENT : "Types with alignment exceeding the default must use 'alloc_aligned' instead"
+*>
+macro alloc_try(Allocator allocator, $Type) @nodiscard
+{
+	return ($Type*)malloc_try(allocator, $Type.sizeof);
+}
+
+<*
+ Allocate using an aligned allocation. This is necessary for types with a default memory alignment
+ exceeding DEFAULT_MEM_ALIGNMENT. IMPORTANT! It must be freed using free_aligned.
+*>
+macro alloc_aligned(Allocator allocator, $Type) @nodiscard
+{
+	return ($Type*)malloc_aligned(allocator, $Type.sizeof, $Type.alignof);
+}
+
+<*
+ @require $Type.alignof <= mem::DEFAULT_MEM_ALIGNMENT
+*>
+macro alloc_with_padding(Allocator allocator, $Type, usz padding) @nodiscard
+{
+	return ($Type*)malloc_try(allocator, $Type.sizeof + padding);
+}
+
+<*
+ @require $Type.alignof <= mem::DEFAULT_MEM_ALIGNMENT : "Types with alignment exceeding the default must use 'new_array_aligned' instead"
+*>
+macro new_array(Allocator allocator, $Type, usz elements) @nodiscard
+{
+	return new_array_try(allocator, $Type, elements)!!;
+}
+
+<*
+ @require $Type.alignof <= mem::DEFAULT_MEM_ALIGNMENT : "Types with alignment exceeding the default must use 'new_array_aligned' instead"
+*>
+macro new_array_try(Allocator allocator, $Type, usz elements) @nodiscard
+{
+	return (($Type*)calloc_try(allocator, $Type.sizeof * elements))[:elements];
+}
+
+<*
+ Allocate using an aligned allocation. This is necessary for types with a default memory alignment
+ exceeding DEFAULT_MEM_ALIGNMENT. IMPORTANT! It must be freed using free_aligned.
+*>
+macro new_array_aligned(Allocator allocator, $Type, usz elements) @nodiscard
+{
+	return (($Type*)calloc_aligned(allocator, $Type.sizeof * elements, $Type.alignof))[:elements]!!;
+}
+
+<*
+ @require $Type.alignof <= mem::DEFAULT_MEM_ALIGNMENT : "Types with alignment exceeding the default must use 'alloc_array_aligned' instead"
+*>
+macro alloc_array(Allocator allocator, $Type, usz elements) @nodiscard
+{
+	return alloc_array_try(allocator, $Type, elements)!!;
+}
+
+<*
+ Allocate using an aligned allocation. This is necessary for types with a default memory alignment
+ exceeding DEFAULT_MEM_ALIGNMENT. IMPORTANT! It must be freed using free_aligned.
+*>
+macro alloc_array_aligned(Allocator allocator, $Type, usz elements) @nodiscard
+{
+	return (($Type*)malloc_aligned(allocator, $Type.sizeof * elements, $Type.alignof))[:elements]!!;
+}
+
+<*
+ @require $Type.alignof <= mem::DEFAULT_MEM_ALIGNMENT : "Types with alignment exceeding the default must use 'alloc_array_aligned' instead"
+*>
+macro alloc_array_try(Allocator allocator, $Type, usz elements) @nodiscard
+{
+	return (($Type*)malloc_try(allocator, $Type.sizeof * elements))[:elements];
+}
+
+<*
+ @require $Type.alignof <= mem::DEFAULT_MEM_ALIGNMENT : "Types with alignment exceeding the default must use 'alloc_array_aligned' instead"
+*>
+macro realloc_array(Allocator allocator, void* ptr, $Type, usz elements) @nodiscard
+{
+	return realloc_array_try(allocator, ptr, $Type, elements)!!;
+}
+
+<*
+ Allocate using an aligned allocation. This is necessary for types with a default memory alignment
+ exceeding DEFAULT_MEM_ALIGNMENT. IMPORTANT! It must be freed using free_aligned.
+*>
+macro realloc_array_aligned(Allocator allocator, void* ptr, $Type, usz elements) @nodiscard
+{
+	return (($Type*)realloc_aligned(allocator, ptr, $Type.sizeof * elements, $Type.alignof))[:elements]!!;
+}
+
+<*
+ @require $Type.alignof <= mem::DEFAULT_MEM_ALIGNMENT : "Types with alignment exceeding the default must use 'alloc_array_aligned' instead"
+*>
+macro realloc_array_try(Allocator allocator, void* ptr, $Type, usz elements) @nodiscard
+{
+	return (($Type*)realloc_try(allocator, ptr, $Type.sizeof * elements))[:elements];
+}
+
+<*
+ Clone a value.
+
+ @param [&inout] allocator : "The allocator to use to clone"
+ @param value : "The value to clone"
+ @return "A pointer to the cloned value"
+ @require $alignof(value) <= mem::DEFAULT_MEM_ALIGNMENT : "Types with alignment exceeding the default must use 'clone_aligned' instead"
+*>
+macro clone(Allocator allocator, value) @nodiscard
+{
+	return new(allocator, $typeof(value), value);
+}
+
+<*
+ @param [&inout] allocator : "The allocator used to clone"
+ @param slice : "The slice to clone"
+ @return "A pointer to the cloned slice"
+
+ @require $kindof(slice) == SLICE || $kindof(slice) == ARRAY
+*>
+macro clone_slice(Allocator allocator, slice) @nodiscard
+{
+	if (!lengthof(slice)) return {};
+
+	var $Type = $typeof(slice[0]);
+
+	$Type[] new_arr = new_array(allocator, $Type, slice.len);
+	mem::copy(new_arr.ptr, &slice[0], slice.len * $Type.sizeof);
+
+	return new_arr;
+}
+
+<*
+ Clone overaligned values. Must be released using free_aligned.
+
+ @param [&inout] allocator : "The allocator to use to clone"
+ @param value : "The value to clone"
+ @return "A pointer to the cloned value"
+*>
+macro clone_aligned(Allocator allocator, value) @nodiscard
+{
+	return new_aligned(allocator, $typeof(value), value)!!;
+}
+
+fn any clone_any(Allocator allocator, any value) @nodiscard
+{
+	usz size = value.type.sizeof;
+	void* data = malloc(allocator, size);
+	mem::copy(data, value.ptr, size);
+	return any_make(data, value.type);
 }
 
 
-struct MemoryArena
+<*
+ @require bytes > 0
+ @require alignment > 0
+ @require bytes <= isz.max
+*>
+macro void*? @aligned_alloc(#alloc_fn, usz bytes, usz alignment)
 {
-	inline Allocator allocator;
-	void* memory;
-	usize total;
-	usize used;
+	if (alignment < void*.alignof) alignment = void*.alignof;
+	usz header = AlignedBlock.sizeof + alignment;
+	usz alignsize = bytes + header;
+	$if $kindof(#alloc_fn(bytes)) == OPTIONAL:
+		void* data = #alloc_fn(alignsize)!;
+	$else
+		void* data = #alloc_fn(alignsize);
+	$endif
+	void* mem = mem::aligned_pointer(data + AlignedBlock.sizeof, alignment);
+	AlignedBlock* desc = (AlignedBlock*)mem - 1;
+	assert(mem > data);
+	*desc = { bytes, data };
+	return mem;
 }
 
-/**
- * Initialize a memory arena for use using the provided bytes.
- *
- * @require this != null
- **/
-fn void MemoryArena.init(MemoryArena* this, char[] data)
+<*
+ @require bytes > 0
+ @require alignment > 0
+ @require bytes <= isz.max
+*>
+macro void*? @aligned_alloc_fn(context, #alloc_fn, usz bytes, usz alignment)
 {
-	this.function = &arena_allocator_function;
-	this.memory = data.ptr;
-	this.total = data.len;
-	this.used = 0;
+	if (alignment < void*.alignof) alignment = void*.alignof;
+	usz header = AlignedBlock.sizeof + alignment;
+	usz alignsize = bytes + header;
+	$if $kindof(#alloc_fn(context, bytes)) == OPTIONAL:
+		void* data = #alloc_fn(context, alignsize)!;
+	$else
+		void* data = #alloc_fn(context, alignsize);
+	$endif
+	void* mem = mem::aligned_pointer(data + AlignedBlock.sizeof, alignment);
+	AlignedBlock* desc = (AlignedBlock*)mem - 1;
+	assert(mem > data);
+	*desc = { bytes, data };
+	return mem;
 }
 
-/**
- * @require this != null
- **/
-fn void MemoryArena.reset(MemoryArena* this)
+struct AlignedBlock
 {
-	this.used = 0;
-}
+	usz len;
+	void* start;
+}
+
+macro void? @aligned_free(#free_fn, void* old_pointer)
+{
+	AlignedBlock* desc = (AlignedBlock*)old_pointer - 1;
+	$if $kindof(#free_fn(desc.start)) == OPTIONAL:
+	#free_fn(desc.start)!;
+	$else
+	#free_fn(desc.start);
+	$endif
+}
+
+macro void? @aligned_free_fn(context, #free_fn, void* old_pointer)
+{
+	AlignedBlock* desc = (AlignedBlock*)old_pointer - 1;
+	$if $kindof(#free_fn(context, desc.start)) == OPTIONAL:
+	#free_fn(context, desc.start)!;
+	$else
+	#free_fn(context, desc.start);
+	$endif
+}
+
+<*
+ @require bytes > 0
+ @require alignment > 0
+*>
+macro void*? @aligned_realloc(#calloc_fn, #free_fn, void* old_pointer, usz bytes, usz alignment)
+{
+	AlignedBlock* desc = (AlignedBlock*)old_pointer - 1;
+	void* data_start = desc.start;
+	void* new_data = @aligned_alloc(#calloc_fn, bytes, alignment)!;
+	mem::copy(new_data, old_pointer, desc.len < bytes ? desc.len : bytes, 1, 1);
+	$if $kindof(#free_fn(data_start)) == OPTIONAL:
+	#free_fn(data_start)!;
+	$else
+	#free_fn(data_start);
+	$endif
+	return new_data;
+}
+
+<*
+ @require bytes > 0
+ @require alignment > 0
+*>
+macro void*? @aligned_realloc_fn(context, #calloc_fn, #free_fn, void* old_pointer, usz bytes, usz alignment)
+{
+	AlignedBlock* desc = (AlignedBlock*)old_pointer - 1;
+	void* data_start = desc.start;
+	void* new_data = @aligned_alloc_fn(context, #calloc_fn, bytes, alignment)!;
+	mem::copy(new_data, old_pointer, desc.len < bytes ? desc.len : bytes, 1, 1);
+	$if $kindof(#free_fn(context, data_start)) == OPTIONAL:
+	#free_fn(context, data_start)!;
+	$else
+	#free_fn(context, data_start);
+	$endif
+	return new_data;
+}
+
+// All allocators
+alias mem @builtin = thread_allocator ;
+tlocal Allocator thread_allocator @private = base_allocator();
+Allocator temp_base_allocator @private = base_allocator();
+
+typedef PoolState = TempAllocator*;
+
+const LazyTempAllocator LAZY_TEMP @private = {};
+tlocal Allocator current_temp = &LAZY_TEMP;
+tlocal TempAllocator* top_temp;
+tlocal bool auto_create_temp = false;
+
+usz temp_allocator_min_size = temp_allocator_default_min_size();
+usz temp_allocator_reserve_size = temp_allocator_default_reserve_size();
+usz temp_allocator_realloc_size = temp_allocator_default_min_size() * 4;
+
+fn PoolState push_pool(usz reserve = 0)
+{
+	Allocator old = top_temp ? current_temp : create_temp_allocator_on_demand();
+	current_temp = ((TempAllocator*)old).derive_allocator(reserve)!!;
+	return (PoolState)old.ptr;
+}
+
+fn void pop_pool(PoolState old)
+{
+	TempAllocator* temp = (TempAllocator*)old;
+	current_temp = temp;
+	temp.reset();
+}
+
+macro Allocator base_allocator() @private
+{
+	$if env::LIBC:
+		return &allocator::LIBC_ALLOCATOR;
+	$else
+		return &allocator::NULL_ALLOCATOR;
+	$endif
+}
+
+macro usz temp_allocator_size() @local
+{
+	$switch env::MEMORY_ENV:
+		$case NORMAL: return 256 * 1024;
+		$case SMALL: return 1024 * 32;
+		$case TINY: return 1024 * 4;
+		$case NONE: return 0;
+	$endswitch
+}
+
+macro usz temp_allocator_default_min_size() @local
+{
+	$switch env::MEMORY_ENV:
+		$case NORMAL: return 16 * 1024;
+		$case SMALL: return 1024 * 2;
+		$case TINY: return 256;
+		$case NONE: return 256;
+	$endswitch
+}
+
+macro usz temp_allocator_default_reserve_size() @local
+{
+	$switch env::MEMORY_ENV:
+		$case NORMAL: return 1024;
+		$case SMALL: return 128;
+		$case TINY: return 64;
+		$case NONE: return 64;
+	$endswitch
+}
+
+macro Allocator heap() @deprecated("Use 'mem' instead.") => thread_allocator;
+
+<*
+ @require !top_temp : "This should never be called when temp already exists"
+*>
+fn Allocator create_temp_allocator_on_demand() @private
+{
+	if (!auto_create_temp)
+	{
+	    auto_create_temp = true;
+	    abort("Use '@pool_init()' to enable the temp allocator on a new thread. A temp allocator is only implicitly created on the main thread.");
+	}
+	return create_temp_allocator(temp_base_allocator, temp_allocator_size(), temp_allocator_reserve_size, temp_allocator_min_size, temp_allocator_realloc_size);
+}
+
+<*
+ @require !top_temp : "This should never be called when temp already exists"
+*>
+fn Allocator create_temp_allocator(Allocator allocator, usz size, usz reserve, usz min_size, usz realloc_size) @private
+{
+	return current_temp = top_temp = allocator::new_temp_allocator(allocator, size, reserve, min_size, realloc_size)!!;
+}
+
+macro Allocator temp() @deprecated("Use 'tmem' instead")
+{
+	return current_temp;
+}
+
+alias tmem @builtin = current_temp;
+
+fn void allow_implicit_temp_allocator_on_load_thread() @init(1) @local @if(env::LIBC || env::FREESTANDING_WASM)
+{
+	auto_create_temp = true;
+}
+
+fn void destroy_temp_allocators_after_exit() @finalizer(65535) @local @if(env::LIBC)
+{
+	destroy_temp_allocators();
+}
+
+<*
+ Call this to destroy any memory used by the temp allocators. This will invalidate all temp memory.
+*>
+fn void destroy_temp_allocators()
+{
+	if (!top_temp) return;
+	top_temp.free();
+	top_temp = null;
+	current_temp = &LAZY_TEMP;
+}
+
+import libc;
+typedef LazyTempAllocator (Allocator) @private = uptr;
+
+fn void*? LazyTempAllocator.acquire(&self, usz bytes, AllocInitType init_type, usz alignment) @dynamic
+{
+	if (!top_temp) create_temp_allocator_on_demand();
+	return top_temp.acquire(bytes, init_type, alignment);
+}
+
+fn void*? LazyTempAllocator.resize(&self, void* old_ptr, usz new_bytes, usz alignment) @dynamic
+{
+	if (!top_temp) create_temp_allocator_on_demand();
+	return top_temp.resize(old_ptr, new_bytes, alignment);
+}
+
+fn void LazyTempAllocator.release(&self, void* old_ptr, bool aligned) @dynamic
+{
+}
+
+const NullAllocator NULL_ALLOCATOR = {};
+typedef NullAllocator (Allocator) = uptr;
+
+fn void*? NullAllocator.acquire(&self, usz bytes, AllocInitType init_type, usz alignment) @dynamic
+{
+	return mem::OUT_OF_MEMORY~;
+}
+
+fn void*? NullAllocator.resize(&self, void* old_ptr, usz new_bytes, usz alignment) @dynamic
+{
+	return mem::OUT_OF_MEMORY~;
+}
+
+fn void NullAllocator.release(&self, void* old_ptr, bool aligned) @dynamic
+{
+}
+

lib/std/core/mem_array.c3

@@ -1,22 +0,0 @@
-// Copyright (c) 2021 Christoffer Lerno. All rights reserved.
-// Use of this source code is governed by the MIT license
-// a copy of which can be found in the LICENSE_STDLIB file.
-module std::core::mem::array;
-
-/**
- * @require usize.max / elements > $Type.sizeof
- **/
-macro alloc($Type, usize elements)
-{
-    $Type* ptr = mem::alloc($Type.sizeof * elements, $alignof($Type));
-    return ptr[:elements];
-}
-
-/**
- * @require (usize.max / elements > $Type.sizeof)
- **/
-macro make($Type, usize elements)
-{
-    $Type* ptr = mem::calloc($sizeof($Type) * elements, $alignof($Type));
-    return ptr[:elements];
-}

lib/std/core/mem_mempool.c3

@@ -0,0 +1,252 @@
+module std::core::mem::mempool;
+import std::core::mem, std::core::mem::allocator, std::math;
+import std::core::sanitizer::asan;
+
+const INITIAL_CAPACITY = 0;
+
+struct FixedBlockPoolNode
+{
+	void* buffer;
+	FixedBlockPoolNode *next;
+	usz capacity;
+}
+
+struct FixedBlockPoolEntry
+{
+	void *previous;
+}
+
+<*
+ Fixed blocks pool pre-allocating blocks backed by an Allocator which are then reserved for the user,
+ blocks deallocated by the user are later re-used by future blocks allocations
+
+ `grow_capacity` can be changed in order to affect how many blocks will be allocated by next pool allocation,
+ it has to be greater than 0
+ `allocated` number of allocated blocks
+ `used` number of used blocks by the user
+*>
+struct FixedBlockPool
+{
+	Allocator allocator;
+	FixedBlockPoolNode head;
+	FixedBlockPoolNode *tail;
+	void *next_free;
+	void *freelist;
+	usz block_size;
+	usz grow_capacity;
+	usz allocated;
+	usz page_size;
+	usz alignment;
+	usz used;
+	bool initialized;
+}
+
+<*
+ Initialize an block pool
+
+ @param [in] allocator : "The allocator to use"
+ @param block_size : "The block size to use"
+ @param capacity : "The amount of blocks to be pre-allocated"
+ @param alignment : "The alignment of the buffer"
+ @require !alignment || math::is_power_of_2(alignment)
+ @require !self.initialized : "The block pool must not be initialized"
+ @require block_size > 0 : "Block size must be non zero"
+ @require calculate_actual_capacity(capacity, block_size) * block_size >= block_size
+    : "Total memory would overflow"
+*>
+fn FixedBlockPool* FixedBlockPool.init(&self, Allocator allocator, usz block_size, usz capacity = INITIAL_CAPACITY, usz alignment = 0)
+{
+	self.allocator = allocator;
+	self.tail = &self.head;
+	self.head.next = null;
+	self.block_size = math::max(block_size, FixedBlockPoolEntry.sizeof);
+	capacity = calculate_actual_capacity(capacity, self.block_size);
+	self.alignment = allocator::alignment_for_allocation(alignment);
+	self.page_size = capacity * self.block_size;
+    assert(self.page_size >= self.block_size, "Total memory would overflow %d %d", block_size, capacity);
+	self.head.buffer = fixedblockpool_allocate_page(self);
+	$if env::COMPILER_SAFE_MODE && env::ADDRESS_SANITIZER:
+		asan::poison_memory_region(self.head.buffer, self.page_size);
+	$endif
+	self.head.capacity = capacity;
+	self.next_free = self.head.buffer;
+	self.freelist = null;
+	self.grow_capacity = capacity;
+	self.initialized = true;
+	self.allocated = capacity;
+	self.used = 0;
+	return self;
+}
+
+<*
+ Initialize an block pool
+
+ @param [in] allocator : "The allocator to use"
+ @param $Type : "The type used for setting the block size"
+ @param capacity : "The amount of blocks to be pre-allocated"
+ @require !self.initialized : "The block pool must not be initialized"
+*>
+macro FixedBlockPool* FixedBlockPool.init_for_type(&self, Allocator allocator, $Type, usz capacity = INITIAL_CAPACITY)
+{
+	return self.init(allocator, $Type.sizeof, capacity, $Type.alignof);
+}
+
+<*
+ Initialize an block pool using Temporary allocator
+
+ @param $Type : "The type used for setting the block size"
+ @param capacity : "The amount of blocks to be pre-allocated"
+ @require !self.initialized : "The block pool must not be initialized"
+*>
+macro FixedBlockPool* FixedBlockPool.tinit_for_type(&self, $Type, usz capacity = INITIAL_CAPACITY) => self.init_for_type(tmem, $Type, capacity);
+
+<*
+ Initialize an block pool using Temporary allocator
+
+ @param block_size : "The block size to use"
+ @param capacity : "The amount of blocks to be pre-allocated"
+ @require !self.initialized : "The block pool must not be initialized"
+*>
+macro FixedBlockPool* FixedBlockPool.tinit(&self, usz block_size, usz capacity = INITIAL_CAPACITY) => self.init(tmem, block_size, capacity);
+
+<*
+ Free up the entire block pool
+
+ @require self.initialized : "The block pool must be initialized"
+*>
+fn void FixedBlockPool.free(&self)
+{
+	$if env::COMPILER_SAFE_MODE && env::ADDRESS_SANITIZER:
+		asan::unpoison_memory_region(self.head.buffer, self.page_size);
+	$endif
+	fixedblockpool_free_page(self, self.head.buffer);
+	FixedBlockPoolNode* iter = self.head.next;
+
+	while (iter)
+	{
+		$if env::COMPILER_SAFE_MODE && env::ADDRESS_SANITIZER:
+			asan::unpoison_memory_region(iter.buffer, self.page_size);
+		$endif
+		fixedblockpool_free_page(self, iter.buffer);
+		FixedBlockPoolNode* current = iter;
+		iter = iter.next;
+		allocator::free(self.allocator, current);
+	}
+	self.initialized = false;
+	self.allocated = 0;
+	self.used = 0;
+}
+
+<*
+ Allocate an block on the block pool, re-uses previously deallocated blocks
+
+ @require self.initialized : "The block pool must be initialized"
+*>
+fn void* FixedBlockPool.alloc(&self)
+{
+	defer self.used++;
+
+	if (self.freelist)
+	{
+		FixedBlockPoolEntry* entry = self.freelist;
+		$if env::COMPILER_SAFE_MODE && env::ADDRESS_SANITIZER:
+			asan::unpoison_memory_region(entry, self.block_size);
+		$endif
+		self.freelist = entry.previous;
+		mem::clear(entry, self.block_size);
+		return entry;
+	}
+
+	void* end = self.tail.buffer + (self.tail.capacity * self.block_size);
+	if (self.next_free >= end) fixedblockpool_new_node(self);
+	void* ptr = self.next_free;
+	self.next_free += self.block_size;
+	$if env::COMPILER_SAFE_MODE && env::ADDRESS_SANITIZER:
+		asan::unpoison_memory_region(ptr, self.block_size);
+	$endif
+
+	return ptr;
+}
+
+<*
+ Deallocate a block from the block pool
+
+ @require self.initialized : "The block pool must be initialized"
+ @require fixedblockpool_check_ptr(self, ptr) : "The pointer should be part of the pool"
+*>
+fn void FixedBlockPool.dealloc(&self, void* ptr)
+{
+	$if env::COMPILER_SAFE_MODE && !env::ADDRESS_SANITIZER:
+		mem::set(ptr, 0xAA, self.block_size);
+	$endif
+
+	FixedBlockPoolEntry* entry = ptr;
+	entry.previous = self.freelist;
+	self.freelist = entry;
+	self.used--;
+
+	$if env::COMPILER_SAFE_MODE && env::ADDRESS_SANITIZER:
+		asan::poison_memory_region(ptr, self.block_size);
+	$endif
+}
+
+<*
+ @require self.initialized : "The block pool must be initialized"
+*>
+fn bool fixedblockpool_check_ptr(FixedBlockPool* self, void *ptr) @local
+{
+	FixedBlockPoolNode* iter = &self.head;
+
+	while (iter)
+	{
+		void* end = iter.buffer + (iter.capacity * self.block_size);
+		if (ptr >= iter.buffer && ptr < end) return true;
+		iter = iter.next;
+	}
+
+	return false;
+}
+
+<*
+ @require self.grow_capacity > 0 : "How many blocks will it store"
+*>
+fn void fixedblockpool_new_node(FixedBlockPool* self) @local
+{
+	FixedBlockPoolNode* node = allocator::new(self.allocator, FixedBlockPoolNode);
+	node.buffer = fixedblockpool_allocate_page(self);
+	$if env::COMPILER_SAFE_MODE && env::ADDRESS_SANITIZER:
+		asan::poison_memory_region(node.buffer, self.page_size);
+	$endif
+	node.capacity = self.grow_capacity;
+	self.tail.next = node;
+	self.tail = node;
+	self.next_free = node.buffer;
+	self.allocated += node.capacity;
+}
+
+macro void* fixedblockpool_allocate_page(FixedBlockPool* self) @private
+{
+	return self.alignment > mem::DEFAULT_MEM_ALIGNMENT
+	       ? allocator::calloc_aligned(self.allocator, self.page_size, self.alignment)!!
+           : allocator::calloc(self.allocator, self.page_size);
+}
+
+macro void fixedblockpool_free_page(FixedBlockPool* self, void* page) @private
+{
+	if (self.alignment > mem::DEFAULT_MEM_ALIGNMENT)
+	{
+		allocator::free_aligned(self.allocator, page);
+	}
+	else
+	{
+		allocator::free(self.allocator, page);
+	}
+}
+
+macro usz calculate_actual_capacity(usz capacity, usz block_size) @private
+{
+	// Assume some overhead
+	if (capacity) return capacity;
+	capacity = (mem::os_pagesize() - 128) / block_size;
+	return capacity ?: 1;
+}

lib/std/core/mem_temp_allocator.c3

@@ -1,106 +0,0 @@
-module std::core::mem;
-
-const TEMP_BLOCK_SIZE = 1024;
-const TEMP_PAGES = 64;
-
-private char[TEMP_BLOCK_SIZE * TEMP_PAGES] allocator_static_storage;
-private void*[TEMP_PAGES] allocator_static_page_storage;
-
-SlotAllocator temp_allocator = {
-    .pages = &allocator_static_storage,
-    .page_size = TEMP_BLOCK_SIZE,
-    .page_count = TEMP_PAGES,
-    .bitmask = TEMP_PAGES - 1,
-    .current_page = 0,
-};
-
-struct SlotAllocator
-{
-    void* pages;
-    usize page_size;
-    usize page_count;
-    usize bitmask;
-    usize current_page;
-}
-
-fn void*! SlotAllocator.alloc(SlotAllocator *allocator, usize size)
-{
-    void* active_page = (char*)(allocator.pages) + allocator.current_page * allocator.page_size;
-    void** page_pointer = (void**)(active_page);
-    if (*page_pointer)
-    {
-        // TODO fix
-        thread_allocator.free(*page_pointer)?;
-        *page_pointer = null;
-    }
-    if (size > allocator.page_size - $sizeof(page_pointer))
-    {
-        void* mem = thread_allocator.alloc(size)?;
-        *page_pointer = mem;
-        allocator.current_page = (allocator.current_page + 1) & (allocator.bitmask);
-        return mem;
-    }
-    allocator.current_page = (allocator.current_page + 1) & (allocator.bitmask);
-    return &page_pointer[1];
-}
-
-
-struct RingAllocator
-{
-    char *data;
-    usize size;
-    usize offset;
-}
-
-
-fn void* RingAllocator.alloc(RingAllocator *allocator, usize size)
-{
-    if (size > allocator.size) return null;
-    // Wraparound? If so, start at the beginning.
-    if (allocator.offset + size > allocator.size)
-    {
-        allocator.offset = size;
-        return allocator.data;
-    }
-    void* data = allocator.offset + allocator.data;
-    allocator.offset = (allocator.offset + size) & allocator.size;
-    return data;
-}
-
-fn void* RingAllocator.realloc(RingAllocator *allocator, void* ptr, usize size)
-{
-    if (size > allocator.size) return null;
-    assert(allocator.data >= ptr && ptr < allocator.data + size, "Realloc on other allocator.");
-    // 1. The pointer is before the allocator
-    if (allocator.data + allocator.offset > ptr)
-    {
-        if (allocator.data + allocator.size < ptr + size)
-        {
-            // 1a. There is not enough space, we need to copy to the start.
-            usize pointer_offset = ptr - allocator.data;
-            usize copy_len = pointer_offset + size > allocator.offset ? allocator.offset - pointer_offset : size;
-            //memcpy(allocator.data, ptr, copy_len);
-            allocator.offset = size;
-            return allocator.data;
-        }
-        // 1b. There is enough space, so we just change the offset:
-        allocator.offset = ptr - allocator.data + size;
-        return ptr;
-    }
-    // 2. The pointer is after the allocator
-    // 2a. Is there sufficient space?
-    if (ptr + size <= allocator.data + allocator.size)
-    {
-        // Good, if so we simply change the offset and return the pointer.
-        allocator.offset = ptr - allocator.data + size;
-        return ptr;
-    }
-    // 2b. Not sufficient space, we copy to the beginning.
-    usize pointer_offset = ptr - allocator.data;
-    usize copy_len = allocator.size - (ptr - allocator.data);
-    if (copy_len > size) copy_len = size;
-    //memcpy(allocator.data, ptr, copy_len);
-    allocator.offset = size;
-    return allocator.data;
-}
-

lib/std/core/os/linux.c3

@@ -1,17 +0,0 @@
-module std::core::os::linux;
-
-$if (env::OS_TYPE == OsType.LINUX):
-
-extern fn int* __errno_location();
-
-fn int errno() @inline
-{
-    return *__errno_location();
-}
-
-fn void errno_set(int err)
-{
-    *(__errno_location()) = err;
-}
-
-$endif;

lib/std/core/os/macos.c3

@@ -1,14 +0,0 @@
-module std::core::os::macos;
-$if (env::OS_TYPE == OsType.MACOSX):
-
-extern fn int* __error();
-
-fn int errno() @inline
-{
-    return *__error();
-}
-fn void errno_set(int err)
-{
-    *(__error()) = err;
-}
-$endif;

lib/std/core/os/mem_vm.c3

@@ -0,0 +1,353 @@
+<*
+ The VM module holds code for working with virtual memory on supported platforms (currently Win32 and Posix)
+*>
+module std::core::mem::vm;
+import std::io, std::os::win32, std::os::posix, libc;
+
+<*
+ VirtualMemory is an abstraction for working with an allocated virtual memory area. It will invoke vm:: functions
+ but will perform more checks and track its size (required to unmap the memory on Posix)
+*>
+struct VirtualMemory
+{
+	void* ptr;
+	usz size;
+	VirtualMemoryAccess default_access;
+}
+
+faultdef RANGE_OVERFLOW, UNKNOWN_ERROR, ACCESS_DENIED, UNMAPPED_ACCESS, UNALIGNED_ADDRESS, RELEASE_FAILED, UPDATE_FAILED, INVALID_ARGS;
+
+enum VirtualMemoryAccess
+{
+	PROTECTED,
+	READ,
+	WRITE,
+	READWRITE,
+	EXEC,
+	EXECREAD,
+	EXECWRITE,
+	ANY
+}
+
+fn usz aligned_alloc_size(usz size)
+{
+	$if env::WIN32:
+		return size > 0 ? mem::aligned_offset(size, win32::allocation_granularity()) : win32::allocation_granularity();
+	$else
+		return size > 0 ? mem::aligned_offset(size, mem::os_pagesize()) : mem::os_pagesize();
+	$endif
+}
+
+<*
+ Allocate virtual memory, size is rounded up to platform granularity (Win32) / page size (Posix).
+
+ @param size : "The size of the memory to allocate, will be rounded up"
+ @param access : "The initial access permissions."
+ @return? mem::OUT_OF_MEMORY, RANGE_OVERFLOW, UNKNOWN_ERROR, ACCESS_DENIED, INVALID_ARGS
+ @return "Pointer to the allocated memory, page aligned"
+*>
+fn void*? alloc(usz size, VirtualMemoryAccess access)
+{
+	$switch:
+		$case env::POSIX:
+			void* ptr = posix::mmap(null, aligned_alloc_size(size), access.to_posix(), posix::MAP_PRIVATE | posix::MAP_ANONYMOUS, -1, 0);
+			if (ptr != posix::MAP_FAILED) return ptr;
+			switch (libc::errno())
+			{
+				case errno::ENOMEM:    return mem::OUT_OF_MEMORY~;
+				case errno::EOVERFLOW: return RANGE_OVERFLOW~;
+				case errno::EPERM:     return ACCESS_DENIED~;
+				case errno::EINVAL:    return INVALID_ARGS~;
+				default:               return UNKNOWN_ERROR~;
+			}
+		$case env::WIN32:
+			void* ptr = win32::virtualAlloc(null, aligned_alloc_size(size), MEM_RESERVE, access.to_win32());
+			if (ptr) return ptr;
+			switch (win32::getLastError())
+			{
+				case win32::ERROR_NOT_ENOUGH_MEMORY:
+				case win32::ERROR_COMMITMENT_LIMIT:  return mem::OUT_OF_MEMORY~;
+				default:                             return UNKNOWN_ERROR~;
+			}
+		$default:
+			unsupported("Virtual alloc only available on Win32 and Posix");
+	$endswitch
+}
+
+<*
+ Release memory allocated with "alloc".
+
+ @param [&inout] ptr : "Pointer to page to release, should be allocated using vm::alloc"
+ @param size : "The size of the allocated pointer"
+ @require mem::ptr_is_page_aligned(ptr) : "The pointer should be page aligned"
+*>
+fn void? release(void* ptr, usz size)
+{
+	$switch:
+		$case env::POSIX:
+			if (posix::munmap(ptr, aligned_alloc_size(size)))
+			{
+				switch (libc::errno())
+				{
+					case errno::EINVAL: return INVALID_ARGS~;    // Not a valid mapping or size
+					case errno::ENOMEM: return UNMAPPED_ACCESS~; // Address not mapped
+					default:            return RELEASE_FAILED~;
+				}
+			}
+		$case env::WIN32:
+			if (win32::virtualFree(ptr, 0, MEM_RELEASE)) return;
+			switch (win32::getLastError())
+			{
+				case win32::ERROR_INVALID_ADDRESS:   return INVALID_ARGS~;
+				case win32::ERROR_NOT_ENOUGH_MEMORY: return mem::OUT_OF_MEMORY~;
+				default:                             return RELEASE_FAILED~;
+			}
+		$default:
+			unsupported("Virtual free only available on Win32 and Posix");
+	$endswitch
+}
+
+<*
+ Change the access protection of a region in memory. The region must be page aligned.
+
+ @param [&inout] ptr : "Pointer to page to update, must be page aligned"
+ @param len : "To what len to update, must be page aligned"
+ @param access : "The new access"
+ @require mem::ptr_is_page_aligned(ptr) : "The pointer should be page aligned"
+ @require mem::ptr_is_page_aligned(ptr + len) : "The length must be page aligned"
+ @return? ACCESS_DENIED, UNALIGNED_ADDRESS, RANGE_OVERFLOW, UPDATE_FAILED, UNMAPPED_ACCESS, INVALID_ARGS
+*>
+fn void? protect(void* ptr, usz len, VirtualMemoryAccess access)
+{
+	$switch:
+		$case env::POSIX:
+			if (!posix::mprotect(ptr, len, access.to_posix())) return;
+			switch (libc::errno())
+			{
+				case errno::EACCES:    return ACCESS_DENIED~;
+				case errno::EINVAL:    return UNALIGNED_ADDRESS~;
+				case errno::EOVERFLOW: return RANGE_OVERFLOW~;
+				case errno::ENOMEM:    return UNMAPPED_ACCESS~;
+				default:               return UPDATE_FAILED~;
+			}
+		$case env::WIN32:
+			Win32_Protect old;
+			if (win32::virtualProtect(ptr, len, access.to_win32(), &old)) return;
+			switch (win32::getLastError())
+			{
+				case win32::ERROR_INVALID_ADDRESS:   return UNALIGNED_ADDRESS~;
+				case win32::ERROR_ACCESS_DENIED:     return ACCESS_DENIED~;
+				case win32::ERROR_INVALID_PARAMETER: return INVALID_ARGS~;
+				default:                             return UPDATE_FAILED~;
+			}
+		$default:
+			unsupported("'virtual_protect' is only available on Win32 and Posix.");
+	$endswitch
+}
+
+<*
+ Makes a region of memory available that was previously retrieved using 'alloc'. This is necessary on Win32,
+ but optional on Posix.
+
+ @param [&inout] ptr : "Pointer to page to update, must be page aligned"
+ @param len : "To what len to commit, must be page aligned"
+ @require mem::ptr_is_page_aligned(ptr) : "The pointer should be page aligned"
+ @require mem::ptr_is_page_aligned(ptr + len) : "The length must be page aligned"
+ @return? UNKNOWN_ERROR, mem::OUT_OF_MEMORY, ACCESS_DENIED, UNALIGNED_ADDRESS, RANGE_OVERFLOW, UPDATE_FAILED, UNMAPPED_ACCESS, INVALID_ARGS
+*>
+fn void? commit(void* ptr, usz len, VirtualMemoryAccess access = READWRITE)
+{
+	$switch:
+		$case env::POSIX:
+			return protect(ptr, len, READWRITE) @inline;
+		$case env::WIN32:
+			void* result = win32::virtualAlloc(ptr, len, MEM_COMMIT, access.to_win32());
+			if (result) return;
+			switch (win32::getLastError())
+			{
+				case win32::ERROR_INVALID_ADDRESS:   return UNALIGNED_ADDRESS~;
+				case win32::ERROR_ACCESS_DENIED:     return ACCESS_DENIED~;
+				case win32::ERROR_COMMITMENT_LIMIT:
+				case win32::ERROR_NOT_ENOUGH_MEMORY: return mem::OUT_OF_MEMORY~;
+				case win32::ERROR_INVALID_PARAMETER: return INVALID_ARGS~;
+				default:                             return UNKNOWN_ERROR~;
+			}
+		$default:
+			unsupported("'virtual_commit' is only available on Win32 and Posix.");
+	$endswitch
+}
+
+<*
+ Notifies that the memory in the region can be released back to the OS. On Win32 this decommits the region,
+ whereas on Posix it tells the system that it may be reused using madvise. The "block" parameter is only
+ respected on Posix, and protects the region from read/write/exec. On Win32 this always happens.
+
+ @param [&inout] ptr : "Pointer to page to update, must be page aligned"
+ @param len : "To what len to commit, must be page aligned"
+ @param block : "Set the released memory to protected"
+ @require mem::ptr_is_page_aligned(ptr) : "The pointer should be page aligned"
+ @require mem::ptr_is_page_aligned(ptr + len) : "The length must be page aligned"
+ @return? ACCESS_DENIED, UNALIGNED_ADDRESS, RANGE_OVERFLOW, UPDATE_FAILED, UNMAPPED_ACCESS, INVALID_ARGS
+*>
+fn void? decommit(void* ptr, usz len, bool block = true)
+{
+	$switch:
+		$case env::POSIX:
+			if (posix::madvise(ptr, len, posix::MADV_DONTNEED))
+			{
+				switch (libc::errno())
+				{
+					case errno::EINVAL: return UNALIGNED_ADDRESS~;
+					case errno::ENOMEM: return UNMAPPED_ACCESS~;
+					default:            return UPDATE_FAILED~;
+				}
+			}
+			if (block) (void)protect(ptr, len, PROTECTED) @inline;
+		$case env::WIN32:
+			if (!win32::virtualFree(ptr, len, MEM_DECOMMIT))
+			{
+				switch (win32::getLastError())
+				{
+					case win32::ERROR_INVALID_ADDRESS:   return UNALIGNED_ADDRESS~;
+					case win32::ERROR_INVALID_PARAMETER: return INVALID_ARGS~;
+					case win32::ERROR_ACCESS_DENIED:     return ACCESS_DENIED~;
+					default:                             return UPDATE_FAILED~;
+				}
+			}
+		$default:
+			unsupported("'virtual_decommit' is only available on Win32 and Posix.");
+	$endswitch
+}
+
+<*
+ Map a portion of an already-opened file into memory.
+
+ @param fd : "File descriptor"
+ @param size : "Number of bytes to map, will be rounded up to page size"
+ @param offset : "Byte offset in file, must be page size aligned"
+ @param access : "The initial access permissions"
+ @param shared : "if True then MAP_SHARED else MAP_PRIVATE"
+ @return? mem::OUT_OF_MEMORY, RANGE_OVERFLOW, UNKNOWN_ERROR, ACCESS_DENIED, INVALID_ARGS, io::NO_PERMISSION, io::FILE_NOT_VALID, io::WOULD_BLOCK, io::FILE_NOT_FOUND
+ @return "Pointer to the mapped region"
+*>
+fn void*? mmap_file(Fd fd, usz size, usz offset = 0, VirtualMemoryAccess access = READ, bool shared = false) @if (env::POSIX)
+{
+	CInt flags = shared ? posix::MAP_SHARED : posix::MAP_PRIVATE;
+	void* ptr = posix::mmap(null, aligned_alloc_size(size), access.to_posix(), flags, fd, offset);
+	if (ptr != posix::MAP_FAILED) return ptr;
+	switch (libc::errno())
+	{
+		case errno::ENOMEM:    return mem::OUT_OF_MEMORY~;
+		case errno::EOVERFLOW: return RANGE_OVERFLOW~;
+		case errno::EPERM:     return ACCESS_DENIED~;
+		case errno::EINVAL:    return INVALID_ARGS~;
+		case errno::EACCES:    return io::NO_PERMISSION~;
+		case errno::EBADF:     return io::FILE_NOT_VALID~;
+		case errno::EAGAIN:    return io::WOULD_BLOCK~;
+		case errno::ENXIO:     return io::FILE_NOT_FOUND~;
+		default:               return UNKNOWN_ERROR~;
+	}
+}
+
+<*
+ Create a VirtualMemory using
+
+ @param size : "The size of the memory to allocate."
+ @require size > 0 : "The size must be non-zero"
+ @return? mem::OUT_OF_MEMORY, RANGE_OVERFLOW, UNKNOWN_ERROR, ACCESS_DENIED, INVALID_ARGS
+*>
+fn VirtualMemory? virtual_alloc(usz size, VirtualMemoryAccess access = PROTECTED)
+{
+	size = aligned_alloc_size(size);
+	void* ptr = alloc(size, access)!;
+	return { ptr, size, access };
+}
+
+<*
+ Commits memory, using vm::commit
+
+ @param offset : "Starting from what offset to commit"
+ @param len : "To what len to commit"
+ @require mem::ptr_is_page_aligned(self.ptr + offset) : "The offset should be page aligned"
+ @require mem::ptr_is_page_aligned(self.ptr + offset + len) : "The length must be page aligned"
+ @require offset < self.size : "Offset out of range"
+ @require offset + len <= self.size : "Length out of range"
+ @return? UPDATE_FAILED, ACCESS_DENIED, UNALIGNED_ADDRESS, RANGE_OVERFLOW, UNKNOWN_ERROR
+*>
+macro void? VirtualMemory.commit(self, usz offset, usz len)
+{
+	return commit(self.ptr + offset, len, self.default_access);
+}
+
+<*
+ Changes protection of a part of memory using vm::protect
+
+ @param offset : "Starting from what offset to update"
+ @param len : "To what len to update"
+ @require mem::ptr_is_page_aligned(self.ptr + offset) : "The offset should be page aligned"
+ @require mem::ptr_is_page_aligned(self.ptr + offset + len) : "The length must be page aligned"
+ @require offset < self.size : "Offset out of range"
+ @require offset + len < self.size : "Length out of range"
+ @return? UPDATE_FAILED, ACCESS_DENIED, UNALIGNED_ADDRESS, RANGE_OVERFLOW, UNKNOWN_ERROR
+*>
+macro void? VirtualMemory.protect(self, usz offset, usz len, VirtualMemoryAccess access)
+{
+	return protect(self.ptr + offset, len, access);
+}
+<*
+ Decommits a part of memory using vm::decommit
+
+ @param offset : "Starting from what offset to decommit"
+ @param len : "To what len to decommit"
+ @param block : "Should the memory be blocked from access after decommit"
+ @require mem::ptr_is_page_aligned(self.ptr + offset) : "The offset should be page aligned"
+ @require mem::ptr_is_page_aligned(self.ptr + offset + len) : "The length must be page aligned"
+ @require offset < self.size : "Offset out of range"
+ @require offset + len < self.size : "Length out of range"
+ @return? UPDATE_FAILED
+*>
+fn void? VirtualMemory.decommit(self, usz offset, usz len, bool block = true)
+{
+	return decommit(self.ptr + offset, len, block);
+}
+
+<*
+ Releases the memory region
+
+ @require self.ptr != null : "Virtual memory must be initialized to call destroy"
+*>
+fn void? VirtualMemory.destroy(&self)
+{
+	return release(self.ptr, self.size);
+}
+
+fn CInt VirtualMemoryAccess.to_posix(self) @if(env::POSIX)
+{
+	switch (self)
+	{
+		case PROTECTED: return posix::PROT_NONE;
+		case READ: return posix::PROT_READ;
+		case WRITE: return posix::PROT_WRITE;
+		case EXEC: return posix::PROT_EXEC;
+		case READWRITE: return posix::PROT_READ | posix::PROT_WRITE;
+		case EXECREAD: return posix::PROT_READ | posix::PROT_EXEC;
+		case EXECWRITE: return posix::PROT_WRITE | posix::PROT_EXEC;
+		case ANY: return posix::PROT_WRITE | posix::PROT_READ | posix::PROT_EXEC;
+	}
+}
+
+fn Win32_Protect VirtualMemoryAccess.to_win32(self) @if(env::WIN32)
+{
+	switch (self)
+	{
+		case PROTECTED: return PAGE_NOACCESS;
+		case READ: return PAGE_READONLY;
+		case WRITE: return PAGE_READWRITE;
+		case EXEC: return PAGE_EXECUTE;
+		case READWRITE: return PAGE_READWRITE;
+		case EXECWRITE: return PAGE_EXECUTE_READWRITE;
+		case EXECREAD: return PAGE_EXECUTE_READ;
+		case ANY: return PAGE_EXECUTE_READWRITE;
+	}
+}
+

lib/std/core/os/wasm/wasm_memory.c3

@@ -0,0 +1,32 @@
+module std::core::mem::allocator;
+
+
+const usz WASM_BLOCK_SIZE = 65536;
+
+WasmMemory wasm_memory;
+
+struct WasmMemory
+{
+	usz allocation;
+	uptr use;
+}
+
+fn char[]? WasmMemory.allocate_block(&self, usz bytes)
+{
+	if (!self.allocation)
+	{
+		self.allocation = $$wasm_memory_size(0) * WASM_BLOCK_SIZE;
+	}
+	isz bytes_required = bytes + self.use - self.allocation;
+	if (bytes_required <= 0)
+	{
+		defer self.use += bytes;
+		return ((char*)self.use)[:bytes];
+	}
+
+	usz blocks_required = (bytes_required + WASM_BLOCK_SIZE + 1) / WASM_BLOCK_SIZE;
+	if ($$wasm_memory_grow(0, blocks_required) == -1) return mem::OUT_OF_MEMORY~;
+	self.allocation = $$wasm_memory_size(0) * WASM_BLOCK_SIZE;
+	defer self.use += bytes;
+	return ((char*)self.use)[:bytes];
+}

lib/std/core/os/windows.c3

@@ -1,10 +0,0 @@
-module std::core::os::windows;
-
-$if (env::OS_TYPE == OsType.WIN32):
-
-extern fn int getLastError() @stdcall @extname("GetLastError");
-fn int errno() @inline
-{
-    return getLastError();
-}
-$endif;