Update current version.

Additional fix and updated error message.
@param name parsing too lenient #2614 .
2026-02-27 12:01:16 +00:00 · 2025-12-04 15:45:14 +01:00 · 2025-12-03 22:25:38 +01:00 · 2025-12-03 21:54:06 +01:00 · 2025-12-03 00:42:36 +01:00 · 2025-12-03 00:36:10 +01:00
2712 changed files with 65634 additions and 138986 deletions
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -8,10 +8,12 @@ on:

 env:
  LLVM_RELEASE_VERSION_WINDOWS: 18
-  LLVM_RELEASE_VERSION_MAC: 17
-  LLVM_RELEASE_VERSION_LINUX: 17
-  LLVM_RELEASE_VERSION_UBUNTU20: 17
-  LLVM_DEV_VERSION: 21
+  LLVM_RELEASE_VERSION_MAC: 18
+  LLVM_RELEASE_VERSION_LINUX: 19
+  LLVM_RELEASE_VERSION_OPENBSD: 19
+  LLVM_RELEASE_VERSION_UBUNTU22: 19
+  LLVM_RELEASE_VERSION_ALPINEv3_22: 20
+  LLVM_DEV_VERSION: 22
 jobs:

  build-msvc:
@@ -52,9 +54,9 @@ jobs:
          call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvarsall.bat" x64
          cd resources/testproject
          ..\..\build\${{ matrix.build_type }}\c3c.exe -vvv --emit-llvm run hello_world_win32 --trust=full
-          dir build\llvm\windows-x64
+          dir out\llvm\windows-x64
          ..\..\build\${{ matrix.build_type }}\c3c.exe clean
-          dir build\llvm\windows-x64
+          dir out\llvm\windows-x64


      - name: Build testproject lib
@@ -77,25 +79,25 @@ jobs:

      - name: Vendor-fetch
        run: |
-          build\${{ matrix.build_type }}\c3c.exe vendor-fetch raylib5
+          build\${{ matrix.build_type }}\c3c.exe vendor-fetch raylib

      - name: Try raylib5
        run: |
          cd resources
-          ..\build\${{ matrix.build_type }}\c3c.exe vendor-fetch raylib5
-          ..\build\${{ matrix.build_type }}\c3c.exe compile --lib raylib5 --print-linking examples\raylib\raylib_arkanoid.c3
-          ..\build\${{ matrix.build_type }}\c3c.exe compile --lib raylib5 --print-linking examples\raylib\raylib_snake.c3
-          ..\build\${{ matrix.build_type }}\c3c.exe compile --lib raylib5 --print-linking examples\raylib\raylib_tetris.c3
-
-      - name: Compile run unit tests
-        run: |
-          cd test
-          ..\build\${{ matrix.build_type }}\c3c.exe compile-test unit -O1
+          ..\build\${{ matrix.build_type }}\c3c.exe vendor-fetch raylib
+          ..\build\${{ matrix.build_type }}\c3c.exe compile --lib raylib --print-linking examples\raylib\raylib_arkanoid.c3
+          ..\build\${{ matrix.build_type }}\c3c.exe compile --lib raylib --print-linking examples\raylib\raylib_snake.c3
+          ..\build\${{ matrix.build_type }}\c3c.exe compile --lib raylib --print-linking examples\raylib\raylib_tetris.c3

      - name: run compiler tests
        run: |
          cd test
-          ..\build\${{ matrix.build_type }}\c3c.exe compile-run -O1 src/test_suite_runner.c3 --stdlib ..\lib7 --enable-new-generics -- ..\build\${{ matrix.build_type }}\c3c.exe test_suite7/ --stdlib ../lib7 --no-terminal
+          ..\build\${{ matrix.build_type }}\c3c.exe compile-run -O1 src/test_suite_runner.c3 -- ..\build\${{ matrix.build_type }}\c3c.exe test_suite/
+
+      - name: Compile run unit tests
+        run: |
+          cd test
+          ..\build\${{ matrix.build_type }}\c3c.exe compile-test unit -O1 -D SLOW_TESTS

      - name: Test python script
        run: |
@@ -112,7 +114,7 @@ jobs:

  build-msys2-mingw:
    runs-on: windows-latest
-    # if: ${{ false }}
+    if: ${{ false }}
    strategy:
      # Don't abort runners if a single one fails
      fail-fast: false
@@ -132,11 +134,11 @@ jobs:
          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
      - shell: msys2 {0}
        run: |
-            pacman --noconfirm -U https://mirror.msys2.org/mingw/mingw64/mingw-w64-x86_64-llvm-19.1.7-1-any.pkg.tar.zst
-            pacman --noconfirm -U https://mirror.msys2.org/mingw/mingw64/mingw-w64-x86_64-lld-19.1.7-1-any.pkg.tar.zst
+            pacman --noconfirm -U https://mirror.msys2.org/mingw/mingw64/mingw-w64-x86_64-llvm-20.1.0-1-any.pkg.tar.zst
+            pacman --noconfirm -U https://mirror.msys2.org/mingw/mingw64/mingw-w64-x86_64-lld-20.1.0-1-any.pkg.tar.zst
      - name: CMake
        run: |
-          cmake -B build -G Ninja -DCMAKE_C_COMPILER=clang -DCMAKE_BUILD_TYPE=${{ matrix.build_type }}
+          cmake -B build -G Ninja -DCMAKE_C_COMPILER=clang -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} -DCMAKE_LINKER=lld
          cmake --build build

      - name: Compile and run some examples
@@ -158,7 +160,7 @@ jobs:

      - name: Vendor-fetch
        run: |
-          ./build/c3c vendor-fetch raylib5
+          ./build/c3c vendor-fetch raylib

      - name: Build testproject lib
        run: |
@@ -168,8 +170,8 @@ jobs:
      - name: run compiler tests
        run: |
          cd test
-          ../build/c3c.exe compile --target windows-x64 -O1 src/test_suite_runner.c3 --stdlib ../lib7 --enable-new-generics
-          ./test_suite_runner.exe ../build/c3c.exe test_suite7/ --stdlib ../lib7 --no-terminal
+          ../build/c3c.exe compile --target windows-x64 -O1 src/test_suite_runner.c3
+          ./test_suite_runner.exe ../build/c3c.exe test_suite/ --no-terminal

  build-msys2-clang:
    runs-on: windows-latest
@@ -220,7 +222,7 @@ jobs:
      - name: run compiler tests
        run: |
          cd test
-          ../build/c3c.exe compile-run -O1 --stdlib ../lib7 src/test_suite_runner.c3 --enable-new-generics -- ../build/c3c.exe test_suite7/ --stdlib ../lib7 --no-terminal
+          ../build/c3c.exe compile-run -O1 src/test_suite_runner.c3 -- ../build/c3c.exe test_suite/ --no-terminal

  build-linux:
    runs-on: ubuntu-22.04
@@ -229,13 +231,14 @@ jobs:
      fail-fast: false
      matrix:
        build_type: [Release, Debug]
-        llvm_version: [17, 18, 19, 20, 21]
+        llvm_version: [17, 18, 19, 20, 21, 22]

    steps:
      - uses: actions/checkout@v4
      - name: Install common deps
        run: |
-          sudo apt-get install zlib1g zlib1g-dev python3 ninja-build curl
+          sudo apt-get update
+          sudo apt-get install zlib1g zlib1g-dev python3 ninja-build curl libcurl4-openssl-dev

      - name: Install Clang ${{matrix.llvm_version}}
        run: |
@@ -273,6 +276,7 @@ jobs:
                -DCMAKE_OBJCOPY=llvm-objcopy-${{matrix.llvm_version}} \
                -DCMAKE_STRIP=llvm-strip-${{matrix.llvm_version}} \
                -DCMAKE_DLLTOOL=llvm-dlltool-${{matrix.llvm_version}} \
+                -DLLVM_ENABLE_LIBXML2=OFF \
                -DC3_LLVM_VERSION=${{matrix.llvm_version}}
          cmake --build build
      - name: CMake18
@@ -287,6 +291,7 @@ jobs:
                -DCMAKE_OBJCOPY=llvm-objcopy-${{matrix.llvm_version}} \
                -DCMAKE_STRIP=llvm-strip-${{matrix.llvm_version}} \
                -DCMAKE_DLLTOOL=llvm-dlltool-${{matrix.llvm_version}} \
+                -DLLVM_ENABLE_LIBXML2=OFF \
                -DC3_LLVM_VERSION=${{matrix.llvm_version}}.1
          cmake --build build

@@ -345,7 +350,7 @@ jobs:
      - name: Compile run unit tests
        run: |
          cd test
-          ../build/c3c compile-test unit
+          ../build/c3c compile-test unit -D SLOW_TESTS

      - name: Build testproject
        run: |
@@ -378,10 +383,14 @@ jobs:
          ./build/c3c init myproject
          ls myproject

+      - name: Vendor-fetch
+        run: |
+          ./build/c3c vendor-fetch raylib
+
      - name: run compiler tests
        run: |
          cd test
-          ../build/c3c compile-run -O1 src/test_suite_runner.c3 --stdlib ../lib7 --enable-new-generics -- ../build/c3c  test_suite7/ --stdlib ../lib7
+          ../build/c3c compile-run -O1 src/test_suite_runner.c3 -- ../build/c3c  test_suite/

      - name: bundle_output
        if: matrix.llvm_version == env.LLVM_RELEASE_VERSION_LINUX
@@ -391,6 +400,7 @@ jobs:
          cp msvc_build_libraries.py c3
          cp build/c3c c3
          cp README.md c3
+          cp releasenotes.md c3
          tar czf c3-linux-${{matrix.build_type}}.tar.gz c3

      - name: upload artifacts
@@ -400,19 +410,201 @@ jobs:
          name: c3-linux-${{matrix.build_type}}
          path: c3-linux-${{matrix.build_type}}.tar.gz

-  build-linux-ubuntu20:
-    runs-on: ubuntu-20.04
+  build-linux-alpine:
+    runs-on: ubuntu-22.04
+    container:
+      image: alpine:3.22
    strategy:
      # Don't abort runners if a single one fails
      fail-fast: false
      matrix:
        build_type: [Release, Debug]
-        llvm_version: [17, 18, 19, 20, 21]
+        llvm_version: [18, 19, 20]
+
    steps:
      - uses: actions/checkout@v4
      - name: Install common deps
        run: |
-          sudo apt-get install zlib1g zlib1g-dev python3 ninja-build curl
+          apk update
+          apk add zlib-dev zlib-static python3 samurai cmake curl-dev curl-static openssl-dev
+
+      - name: Install Clang ${{matrix.llvm_version}}
+        run: |
+            apk add "llvm${{matrix.llvm_version}}-dev" "llvm${{matrix.llvm_version}}-static" \
+            "llvm${{matrix.llvm_version}}-gtest" "llvm${{matrix.llvm_version}}-linker-tools" \
+            "llvm${{matrix.llvm_version}}-test-utils" "llvm${{matrix.llvm_version}}-test-utils-pyc" \
+            "lld${{matrix.llvm_version}}-dev" "clang${{matrix.llvm_version}}-dev" \
+            "clang${{matrix.llvm_version}}-extra-tools" "clang${{matrix.llvm_version}}-static"
+      - name: CMake
+        if: matrix.llvm_version == env.LLVM_DEV_VERSION
+        run: |
+          cmake -B build \
+                -G Ninja \
+                -DCMAKE_BUILD_TYPE=${{matrix.build_type}}" \
+                -DCMAKE_C_COMPILER=clang-${{matrix.llvm_version}} \
+                -DCMAKE_CXX_COMPILER=clang++-${{matrix.llvm_version}} \
+                -DCMAKE_LINKER=lld-link-${{matrix.llvm_version}} \
+                -DCMAKE_OBJCOPY=llvm-objcopy-${{matrix.llvm_version}} \
+                -DCMAKE_STRIP=llvm-strip-${{matrix.llvm_version}} \
+                -DCMAKE_DLLTOOL=llvm-dlltool-${{matrix.llvm_version}} \
+                -DLLVM_ENABLE_LIBXML2=OFF \
+                -DC3_LINK_DYNAMIC=ON \
+                -DC3_LLVM_VERSION=${{matrix.llvm_version}}
+          cmake --build build
+      - name: CMake_Stable
+        if: matrix.llvm_version >= 18 && matrix.llvm_version != env.LLVM_DEV_VERSION
+        run: |
+          cmake -B build \
+                -G Ninja \
+                -DCMAKE_BUILD_TYPE=${{matrix.build_type}} \
+                -DCMAKE_C_COMPILER=clang-${{matrix.llvm_version}} \
+                -DCMAKE_CXX_COMPILER=clang++-${{matrix.llvm_version}} \
+                -DCMAKE_LINKER=lld-link-${{matrix.llvm_version}} \
+                -DCMAKE_OBJCOPY=llvm-objcopy-${{matrix.llvm_version}} \
+                -DCMAKE_STRIP=llvm-strip-${{matrix.llvm_version}} \
+                -DCMAKE_DLLTOOL=llvm-dlltool-${{matrix.llvm_version}} \
+                -DLLVM_ENABLE_LIBXML2=OFF \
+                -DC3_LINK_DYNAMIC=ON \
+                -DC3_LLVM_VERSION=${{matrix.llvm_version}}.1
+          cmake --build build
+
+      - name: Compile and run some examples
+        run: |
+          export C3C="$(realpath ./build/c3c)"
+          cd resources
+          "$C3C" compile examples/base64.c3
+          "$C3C" compile examples/binarydigits.c3
+          "$C3C" compile examples/brainfk.c3
+          "$C3C" compile examples/factorial_macro.c3
+          "$C3C" compile examples/fasta.c3
+          "$C3C" compile examples/gameoflife.c3
+          "$C3C" compile examples/hash.c3
+          "$C3C" compile-only examples/levenshtein.c3
+          "$C3C" compile examples/load_world.c3
+          "$C3C" compile-only examples/map.c3
+          "$C3C" compile examples/mandelbrot.c3
+          "$C3C" compile examples/plus_minus.c3
+          "$C3C" compile examples/nbodies.c3
+          "$C3C" compile examples/spectralnorm.c3
+          "$C3C" compile examples/swap.c3
+          "$C3C" compile examples/contextfree/boolerr.c3
+          "$C3C" compile examples/contextfree/dynscope.c3
+          "$C3C" compile examples/contextfree/guess_number.c3
+          "$C3C" compile examples/contextfree/multi.c3
+          "$C3C" compile examples/contextfree/cleanup.c3
+          "$C3C" compile-run examples/hello_world_many.c3
+          "$C3C" compile-run examples/time.c3
+          "$C3C" compile-run examples/fannkuch-redux.c3
+          "$C3C" compile-run examples/contextfree/boolerr.c3
+          "$C3C" compile-run examples/load_world.c3
+          "$C3C" compile-run examples/process.c3
+          "$C3C" compile-run examples/ls.c3
+          # "$C3C" compile-run --linker=builtin linux_stack.c3  # Program will hang due to incorrect linking to `/lib64/ld-linux-x86-64.so.2` instead of `/lib/ld-musl-x86_64.so.1`
+          "$C3C" compile-run linux_stack.c3
+          "$C3C" compile-run examples/args.c3 -- foo -bar "baz baz"
+
+      - name: Compile and run dynlib-test
+        run: |
+          export C3C="$(realpath ./build/c3c)"
+          cd resources/examples/dynlib-test
+          "$C3C" -vv dynamic-lib add.c3
+          mv add.so libadd.so
+          cc test.c -L. -ladd -Wl,-rpath=.         
+          ./a.out
+          "$C3C" compile-run test.c3 -L . -l add -z -Wl,-rpath=.           
+
+      - name: Compile and run staticlib-test
+        run: |
+          export C3C="$(realpath ./build/c3c)"
+          cd resources/examples/staticlib-test
+          "$C3C" -vv static-lib add.c3
+          mv add.a libadd.a
+          cc test.c -L. -ladd         
+          ./a.out
+          "$C3C" compile-run test.c3 -L . -l add           
+
+      - name: Compile run unit tests
+        run: |
+          export C3C="$(realpath ./build/c3c)"
+          cd test
+          "$C3C" compile-test unit -D SLOW_TESTS
+
+      - name: Build testproject
+        run: |
+          export C3C="$(realpath ./build/c3c)"
+          cd resources/testproject
+          "$C3C" run -vvv --trust=full
+
+      - name: Test WASM
+        run: |
+          export C3C="$(realpath ./build/c3c)"
+          cd resources/testfragments
+          "$C3C" compile --target wasm32 -g0 --no-entry -Os wasm4.c3
+
+      - name: Install QEMU and Risc-V toolchain
+        run: |
+          apk add qemu-dev qemu-system-riscv32 gcc-riscv-none-elf make
+
+      - name: Compile and run Baremetal Risc-V Example
+        run: |
+          cd resources/examples/embedded/riscv-qemu
+          make C3C_PATH=../../../../build/ run
+
+      - name: Build testproject direct linker
+        run: |
+          export C3C="$(realpath ./build/c3c)"
+          cd resources/testproject
+          "$C3C" run -vvv --linker=builtin --trust=full --linux-libc=musl
+
+      - name: Init a library & a project
+        run: |
+          ./build/c3c init-lib mylib
+          ls mylib.c3l
+          ./build/c3c init myproject
+          ls myproject
+
+      - name: Vendor-fetch
+        run: |
+          "$(realpath ./build/c3c)" vendor-fetch raylib55
+
+      - name: run compiler tests
+        run: |
+          export C3C="$(realpath ./build/c3c)"
+          cd test
+          "$C3C" compile-run -O1 src/test_suite_runner.c3 -- ../build/c3c test_suite/
+
+      - name: bundle_output
+        if: matrix.llvm_version == env.LLVM_RELEASE_VERSION_ALPINEv3_22
+        run: |
+          mkdir c3
+          cp -r lib c3
+          cp msvc_build_libraries.py c3
+          cp build/c3c c3
+          cp README.md c3
+          cp releasenotes.md c3
+          tar -czf c3-musl-${{matrix.build_type}}.tar.gz c3
+
+      - name: upload artifacts
+        if: matrix.llvm_version == env.LLVM_RELEASE_VERSION_ALPINEv3_22
+        uses: actions/upload-artifact@v4
+        with:
+          name: c3-musl-${{matrix.build_type}}
+          path: c3-musl-${{matrix.build_type}}.tar.gz
+
+  build-linux-ubuntu22:
+    runs-on: ubuntu-22.04
+    strategy:
+      # Don't abort runners if a single one fails
+      fail-fast: false
+      matrix:
+        build_type: [Release, Debug]
+        llvm_version: [17, 18, 19, 20]
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install common deps
+        run: |
+          sudo apt-get update
+          sudo apt-get install zlib1g zlib1g-dev python3 ninja-build curl libcurl4-openssl-dev

      - name: Install Clang ${{matrix.llvm_version}}
        run: |
@@ -438,6 +630,7 @@ jobs:
                -DCMAKE_OBJCOPY=llvm-objcopy-${{matrix.llvm_version}} \
                -DCMAKE_STRIP=llvm-strip-${{matrix.llvm_version}} \
                -DCMAKE_DLLTOOL=llvm-dlltool-${{matrix.llvm_version}} \
+                -DLLVM_ENABLE_LIBXML2=OFF \
                -DC3_LLVM_VERSION=${{matrix.llvm_version}}
          cmake --build build
      - name: CMake
@@ -452,8 +645,10 @@ jobs:
                -DCMAKE_OBJCOPY=llvm-objcopy-${{matrix.llvm_version}} \
                -DCMAKE_STRIP=llvm-strip-${{matrix.llvm_version}} \
                -DCMAKE_DLLTOOL=llvm-dlltool-${{matrix.llvm_version}} \
+                -DLLVM_ENABLE_LIBXML2=OFF \
                -DC3_LLVM_VERSION=${{matrix.llvm_version}}.1
          cmake --build build
+
      - name: Compile and run some examples
        run: |
          cd resources
@@ -488,7 +683,7 @@ jobs:
      - name: Compile run unit tests
        run: |
          cd test
-          ../build/c3c compile-test unit --sanitize=address
+          ../build/c3c compile-test unit --sanitize=address -D SLOW_TESTS

      - name: Build testproject
        run: |
@@ -500,28 +695,33 @@ jobs:
          cd resources/testproject
          ../../build/c3c run -vvv --linker=builtin --trust=full

+      - name: Vendor-fetch
+        run: |
+          ./build/c3c vendor-fetch raylib
+
      - name: run compiler tests
        run: |
          cd test
-          ../build/c3c compile-run -O1 src/test_suite_runner.c3 --stdlib ../lib7 --enable-new-generics -- ../build/c3c  test_suite7/ --stdlib ../lib7
+          ../build/c3c compile-run -O1 src/test_suite_runner.c3 -- ../build/c3c test_suite/

      - name: bundle_output
-        if: matrix.llvm_version == env.LLVM_RELEASE_VERSION_UBUNTU20
+        if: matrix.llvm_version == env.LLVM_RELEASE_VERSION_UBUNTU22
        run: |
          mkdir c3
          cp -r lib c3
          cp README.md c3
+          cp releasenotes.md c3          
          cp msvc_build_libraries.py c3
          cp build/c3c c3
-          tar czf c3-ubuntu-20-${{matrix.build_type}}.tar.gz c3
+          tar czf c3-ubuntu-22-${{matrix.build_type}}.tar.gz c3

      - name: upload artifacts
-        if: matrix.llvm_version == env.LLVM_RELEASE_VERSION_UBUNTU20
+        if: matrix.llvm_version == env.LLVM_RELEASE_VERSION_UBUNTU22
        uses: actions/upload-artifact@v4
        with:
-          name: c3-ubuntu-20-${{matrix.build_type}}
-          path: c3-ubuntu-20-${{matrix.build_type}}.tar.gz
-  
+          name: c3-ubuntu-22-${{matrix.build_type}}
+          path: c3-ubuntu-22-${{matrix.build_type}}.tar.gz
+
  build-with-docker:
    runs-on: ubuntu-22.04
    strategy:
@@ -581,7 +781,7 @@ jobs:
      - name: Compile run unit tests
        run: |
          cd test
-          ../build/c3c compile-test unit
+          ../build/c3c compile-test unit -D SLOW_TESTS

      - name: Build testproject
        run: |
@@ -608,7 +808,7 @@ jobs:
      - name: run compiler tests
        run: |
          cd test
-          ../build/c3c compile-run -O1 src/test_suite_runner.c3 --stdlib ../lib7 --enable-new-generics -- ../build/c3c  test_suite7/ --stdlib ../lib7
+          ../build/c3c compile-run -O1 src/test_suite_runner.c3 -- ../build/c3c test_suite/

  build-mac:
    runs-on: macos-latest
@@ -640,7 +840,7 @@ jobs:

      - name: Vendor-fetch
        run: |
-          ./build/c3c vendor-fetch raylib5
+          ./build/c3c vendor-fetch raylib

      - name: Compile and run some examples
        run: |
@@ -663,7 +863,7 @@ jobs:
      - name: Compile run unit tests
        run: |
          cd test
-          ../build/c3c compile-test unit -O1
+          ../build/c3c compile-test unit -O1 -D SLOW_TESTS

      - name: Test WASM
        run: |
@@ -688,13 +888,13 @@ jobs:
      - name: run compiler tests
        run: |
          cd test
-          ../build/c3c compile -O1 src/test_suite_runner.c3 --stdlib ../lib7 --enable-new-generics
-          ./test_suite_runner ../build/c3c test_suite7/ --stdlib ../lib7
+          ../build/c3c compile -O1 src/test_suite_runner.c3
+          ./test_suite_runner ../build/c3c test_suite/

      - name: run build test suite runner
        run: |
          cd test
-          ../build/c3c compile -O1 src/test_suite_runner.c3 --stdlib ../lib7 --enable-new-generics
+          ../build/c3c compile -O1 src/test_suite_runner.c3

      - name: bundle_output
        if: matrix.llvm_version == env.LLVM_RELEASE_VERSION_MAC
@@ -703,6 +903,7 @@ jobs:
          cp -r lib macos
          cp msvc_build_libraries.py macos
          cp README.md macos
+          cp releasenotes.md macos          
          cp build/c3c macos
          zip -r c3-macos-${{matrix.build_type}}.zip macos

@@ -744,35 +945,128 @@ jobs:
          nix build -L ".#c3c-checks"
        fi

-  release:
-    runs-on: ubuntu-22.04
-    needs: [build-msvc, build-linux, build-mac, build-linux-ubuntu20]
-    if: github.ref == 'refs/heads/master'
+  build-openbsd:
+    runs-on: ubuntu-latest
+    strategy:
+      # Don't abort runners if a single one fails
+      fail-fast: false
+      matrix:
+        build_type: [Release, Debug]

    steps:
      - uses: actions/checkout@v4
-      - name: delete tag
-        continue-on-error: true
-        uses: actions/github-script@v6
+      - name: OpenBSD VM
+        uses: vmactions/openbsd-vm@main
        with:
-          script: |
-            github.rest.git.deleteRef({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              ref: 'tags/latest',
-              sha: context.sha
-            })
-      - name: create tag
-        uses: actions/github-script@v6
-        with:
-          script: |
-            github.rest.git.createRef({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              ref: 'refs/tags/latest',
-              sha: context.sha
-            })
+          prepare: |
+            pkg_add cmake llvm-20.1.8p1 ninja

+          run: |
+            echo "CMake"
+            cmake -B build \
+              -G Ninja \
+              -DCMAKE_BUILD_TYPE=${{matrix.build_type}} \
+              -DLLVM_ENABLE_LIBXML2=OFF \
+              -DC3_LLVM_VERSION=${LLVM_RELEASE_VERSION_OPENBSD}
+            cmake --build build
+            echo "Compile and run some examples"
+            cd resources
+            ../build/c3c compile examples/base64.c3
+            ../build/c3c compile examples/binarydigits.c3
+            ../build/c3c compile examples/brainfk.c3
+            ../build/c3c compile examples/factorial_macro.c3
+            ../build/c3c compile examples/fasta.c3
+            ../build/c3c compile examples/gameoflife.c3
+            ../build/c3c compile examples/hash.c3
+            ../build/c3c compile-only examples/levenshtein.c3
+            ../build/c3c compile examples/load_world.c3
+            ../build/c3c compile-only examples/map.c3
+            ../build/c3c compile examples/mandelbrot.c3
+            ../build/c3c compile examples/plus_minus.c3
+            ../build/c3c compile examples/nbodies.c3
+            ../build/c3c compile examples/spectralnorm.c3
+            ../build/c3c compile examples/swap.c3
+            ../build/c3c compile examples/contextfree/boolerr.c3
+            ../build/c3c compile examples/contextfree/dynscope.c3
+            ../build/c3c compile examples/contextfree/guess_number.c3
+            ../build/c3c compile examples/contextfree/multi.c3
+            ../build/c3c compile examples/contextfree/cleanup.c3
+            ../build/c3c compile-run examples/hello_world_many.c3
+            ../build/c3c compile-run examples/time.c3
+            ../build/c3c compile-run examples/fannkuch-redux.c3
+            ../build/c3c compile-run examples/contextfree/boolerr.c3
+            ../build/c3c compile-run examples/load_world.c3
+            ../build/c3c compile-run examples/process.c3
+            ../build/c3c compile-run examples/ls.c3
+            ../build/c3c compile-run examples/args.c3 -- foo -bar "baz baz"
+            cd ..
+            echo "Compile and run dynlib-test"
+            cd resources/examples/dynlib-test
+            ../../../build/c3c -vv dynamic-lib add.c3
+            mv add.so libadd.so
+            cc test.c -L. -ladd -Wl,-rpath=.         
+            ./a.out
+            ../../../build/c3c compile-run test.c3 -L . -l add -z -Wl,-rpath=.
+            cd ../../../
+            echo "Compile and run staticlib-test"
+            cd resources/examples/staticlib-test
+            ../../../build/c3c -vv static-lib add.c3
+            mv add.a libadd.a
+            cc test.c -L. -ladd         
+            ./a.out
+            ../../../build/c3c compile-run test.c3 -L . -l add           
+            cd ../../../
+            echo "Compile run unit tests"
+            cd test
+            ../build/c3c --max-mem 128 compile-test unit -D SLOW_TESTS
+            cd ..
+            echo "Build testproject"
+            cd resources/testproject
+            ../../build/c3c run -vvv --trust=full
+            cd ../../
+            echo "Test WASM"
+            cd resources/testfragments
+            ../../build/c3c compile --target wasm32 -g0 --no-entry -Os wasm4.c3
+            cd ../../
+            echo "Build testproject direct linker"
+            cd resources/testproject
+            ../../build/c3c run -vvv --linker=builtin --trust=full
+            cd ../../
+            echo "Init a library & a project"
+            ./build/c3c init-lib mylib
+            ls mylib.c3l
+            ./build/c3c init myproject
+            ls myproject
+            echo "run compiler tests"
+            cd test
+            ../build/c3c --max-mem 128 compile-run -O1 src/test_suite_runner.c3 -- ../build/c3c  test_suite/
+            cd ..
+
+      - name: bundle_output
+        run: |
+          mkdir c3
+          cp -r lib c3
+          cp msvc_build_libraries.py c3
+          cp build/c3c c3
+          cp README.md c3
+          cp releasenotes.md c3
+          tar czf c3-openbsd-${{matrix.build_type}}.tar.gz c3
+
+      - name: upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: c3-openbsd-${{matrix.build_type}}
+          path: c3-openbsd-${{matrix.build_type}}.tar.gz
+
+  release:
+    runs-on: ubuntu-22.04
+    needs: [build-msvc, build-linux, build-mac, build-linux-ubuntu22]
+    if: github.ref == 'refs/heads/master'
+    env:
+      GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+    steps:
+      - uses: actions/checkout@v4
      - uses: actions/download-artifact@v4
      - run: cp -r lib c3-windows-Release
      - run: cp -r lib c3-windows-Debug
@@ -780,22 +1074,28 @@ jobs:
      - run: cp msvc_build_libraries.py c3-windows-Debug
      - run: cp README.md c3-windows-Release
      - run: cp README.md c3-windows-Debug
+      - run: cp releasenotes.md c3-windows-Release
+      - run: cp releasenotes.md c3-windows-Debug
      - run: zip -r c3-windows.zip c3-windows-Release
      - run: zip -r c3-windows-debug.zip c3-windows-Debug
      - run: mv c3-linux-Release/c3-linux-Release.tar.gz c3-linux-Release/c3-linux.tar.gz
      - run: mv c3-linux-Debug/c3-linux-Debug.tar.gz c3-linux-Debug/c3-linux-debug.tar.gz
-      - run: mv c3-ubuntu-20-Release/c3-ubuntu-20-Release.tar.gz c3-ubuntu-20-Release/c3-ubuntu-20.tar.gz
-      - run: mv c3-ubuntu-20-Debug/c3-ubuntu-20-Debug.tar.gz c3-ubuntu-20-Debug/c3-ubuntu-20-debug.tar.gz
+      - run: mv c3-openbsd-Release/c3-openbsd-Release.tar.gz c3-openbsd-Release/c3-openbsd.tar.gz
+      - run: mv c3-openbsd-Debug/c3-openbsd-Debug.tar.gz c3-openbsd-Debug/c3-openbsd-debug.tar.gz
+      - run: mv c3-ubuntu-22-Release/c3-ubuntu-22-Release.tar.gz c3-ubuntu-22-Release/c3-ubuntu-22.tar.gz
+      - run: mv c3-ubuntu-22-Debug/c3-ubuntu-22-Debug.tar.gz c3-ubuntu-22-Debug/c3-ubuntu-22-debug.tar.gz
      - run: mv c3-macos-Release/c3-macos-Release.zip c3-macos-Release/c3-macos.zip
      - run: mv c3-macos-Debug/c3-macos-Debug.zip c3-macos-Debug/c3-macos-debug.zip
+      - 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

      - id: create_release
        uses: softprops/action-gh-release@v2
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        with:
-          tag_name: latest
-          release_name: latest
+          tag_name: latest-prerelease-tag
+          name: ${{ env.RELEASE_NAME }}
          draft: false
          prerelease: true
          files: |
@@ -803,7 +1103,9 @@ jobs:
            c3-windows-debug.zip
            c3-linux-Release/c3-linux.tar.gz
            c3-linux-Debug/c3-linux-debug.tar.gz
-            c3-ubuntu-20-Release/c3-ubuntu-20.tar.gz
-            c3-ubuntu-20-Debug/c3-ubuntu-20-debug.tar.gz
+            c3-openbsd-Release/c3-openbsd.tar.gz
+            c3-openbsd-Debug/c3-openbsd-debug.tar.gz
+            c3-ubuntu-22-Release/c3-ubuntu-22.tar.gz
+            c3-ubuntu-22-Debug/c3-ubuntu-22-debug.tar.gz
            c3-macos-Release/c3-macos.zip
            c3-macos-Debug/c3-macos-debug.zip
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,7 @@
 # Prerequisites
 *.d
+testrun
+benchmarkrun

 # Object files
 *.o
@@ -7,6 +9,8 @@
 *.obj
 *.elf
 *.ll
+*.wasm
+*.s

 # Linker output
 *.ilk
@@ -76,8 +80,10 @@ TAGS
 /.cache/
 /compile_commands.json

-# 'nix build' resulting symlink
+# Nix
 result
+/.envrc
+/.direnv/

 # macOS
 .DS_Store
@@ -85,3 +91,9 @@ result
 # tests
 /test/tmp/*
 /test/testrun
+/test/test_suite_runner
+
+# patches, originals and rejects
+*.patch
+*.rej
+*.orig
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,5 +1,13 @@
 cmake_minimum_required(VERSION 3.20)

+set(C3_LLVM_MIN_VERSION 17)
+set(C3_LLVM_MAX_VERSION 22)
+set(C3_LLVM_DEFAULT_VERSION 19)
+
+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]+)\"")
@@ -7,8 +15,20 @@ if (NOT ${ver} MATCHES "COMPILER_VERSION \"([0-9]+.[0-9]+.[0-9]+)\"")
 endif()

 # Set the project and version
-project(c3c VERSION ${CMAKE_MATCH_1})
-message("C3C version: ${CMAKE_PROJECT_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")
@@ -16,7 +36,7 @@ if (CMAKE_VERSION VERSION_GREATER_EQUAL "3.24.0")
 endif()

 if (NOT DEFINED CMAKE_INSTALL_LIBDIR)
-    if (MSVC)
+    if (WIN32)
        set(CMAKE_INSTALL_LIBDIR "c:\\c3c\\lib")
        set(CMAKE_INSTALL_BINDIR "c:\\c3c")
    else ()
@@ -36,36 +56,42 @@ set(CMAKE_FIND_PACKAGE_SORT_DIRECTION DEC)
 set(CMAKE_C_STANDARD 11)
 set(CMAKE_CXX_STANDARD 17)

+# Use /MT or /MTd
+set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
+
 if(MSVC)
    message(STATUS "MSVC version ${MSVC_VERSION}")
-    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /O2 /EHsc /utf-8")
-    set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} /O2 /EHsc /utf-8")
-    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /Od /Zi /EHa /utf-8")
-    set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /Od /Zi /EHa /utf-8")
+    add_compile_options(/utf-8)
 else()
-    if (true)
-        set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O0 -fno-exceptions")
-        set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -gdwarf-3 -O0 -fno-exceptions")
-        set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -gdwarf-3 -O3 -fno-exceptions")
-        set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -gdwarf-3 -fno-exceptions")
-    else()
-        set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -gdwarf-3 -O3 -fsanitize=undefined,address -fno-exceptions")
-        set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -gdwarf-3 -O1 -fsanitize=undefined,address -fno-exceptions")
-        set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -gdwarf-3 -O3 -fsanitize=undefined,address -fno-exceptions")
-        set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -gdwarf-3 -O1 -fsanitize=undefined,address -fno-exceptions")
-        set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=undefined,address -fno-exceptions")
-    endif()
+    add_compile_options(-gdwarf-3 -fno-exceptions)
+
+    #add_compile_options(-fsanitize=address,undefined)
+    #add_link_options(-fsanitize=address,undefined)
 endif()

-option(C3_LINK_DYNAMIC "link dynamically with LLVM/LLD libs")
+# 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_ENABLE_CLANGD_LSP    OFF                         CACHE BOOL   "Enable/Disable output of compile commands during generation")
+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_LLVM_VERSION "auto" CACHE STRING "Use LLVM version [default: auto]")
-option(C3_USE_MIMALLOC "Use built-in mimalloc" OFF)
-option(C3_USE_TB "Use TB" OFF)
-set(C3_MIMALLOC_TAG "v1.7.3" CACHE STRING "Used version of mimalloc")
-option(C3_WITH_LLVM "Build with LLVM" ON)
-option(C3_LLD_DIR "Use custom LLD directory" "")
-option(LLVM_CRT_LIBRARY_DIR "Use custom llvm's compiler-rt directory" "")
+set(C3_OPTIONS
+        C3_LINK_DYNAMIC
+        C3_WITH_LLVM
+        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)
@@ -83,13 +109,6 @@ endif()
 if (NOT WIN32)
    find_package(CURL)
 endif()
-if(C3_WITH_LLVM)
-    if (NOT C3_LLVM_VERSION STREQUAL "auto")
-        if (${C3_LLVM_VERSION} VERSION_LESS 17 OR ${C3_LLVM_VERSION} VERSION_GREATER 21)
-            message(FATAL_ERROR "LLVM ${C3_LLVM_VERSION} is not supported!")
-        endif()
-    endif()
-endif()

 find_package(Git QUIET)
 if(C3_USE_TB AND GIT_FOUND AND EXISTS "${CMAKE_SOURCE_DIR}/.git")
@@ -107,7 +126,6 @@ if(C3_USE_TB AND GIT_FOUND AND EXISTS "${CMAKE_SOURCE_DIR}/.git")
 endif()

 # Clangd LSP support
-option(C3_ENABLE_CLANGD_LSP "Enable/Disable output of compile commands during generation." OFF)
 if(C3_ENABLE_CLANGD_LSP)
    set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
    execute_process(
@@ -120,7 +138,7 @@ endif(C3_ENABLE_CLANGD_LSP)
 if(C3_WITH_LLVM)
    if(CMAKE_C_COMPILER_ID STREQUAL "MSVC")
        if (C3_LLVM_VERSION STREQUAL "auto")
-            set(C3_LLVM_VERSION "19")
+            set(C3_LLVM_VERSION ${C3_LLVM_DEFAULT_VERSION})
        endif()
        FetchContent_Declare(
                LLVM_Windows
@@ -139,11 +157,26 @@ if(C3_WITH_LLVM)
            FetchContent_MakeAvailable(LLVM_Windows)
            set(llvm_dir ${llvm_windows_SOURCE_DIR})
        endif()
+        message("Loaded Windows LLVM libraries into ${llvm_dir}")
        set(CMAKE_SYSTEM_PREFIX_PATH ${llvm_dir} ${CMAKE_SYSTEM_PREFIX_PATH})

        find_package(LLVM REQUIRED CONFIG)
        find_package(LLD REQUIRED CONFIG)
    else()
+        # Add paths for LLVM CMake files of version 19 and higher as they follow a new installation 
+        # layout and are now in /usr/lib/llvm/*/lib/cmake/llvm/ rather than /usr/lib/cmake/llvm/
+        # 
+        # Because of CMAKE_FIND_PACKAGE_SORT_ORDER CMAKE_FIND_PACKAGE_SORT_DIRECTION,
+        # the newest version will always be found first.
+        c3_print_variables(CMAKE_PREFIX_PATH)
+        if (DEFINED LLVM_DIR) 
+            message(STATUS "Looking for LLVM CMake files in user-specified directory ${LLVM_DIR}")
+        else()
+            file (GLOB LLVM_CMAKE_PATHS "/usr/lib/llvm/*/lib/cmake/llvm/")
+            list (APPEND CMAKE_PREFIX_PATH ${LLVM_CMAKE_PATHS} "/usr/lib/")
+            message(STATUS "No LLVM_DIR specified, searching default directories ${CMAKE_PREFIX_PATH}")
+        endif()
+
        if (NOT C3_LLVM_VERSION STREQUAL "auto")
            find_package(LLVM ${C3_LLVM_VERSION} REQUIRED CONFIG)
        else()
@@ -151,6 +184,10 @@ if(C3_WITH_LLVM)
        endif()
    endif()

+    if (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
@@ -158,12 +195,15 @@ if(C3_WITH_LLVM)
        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 "Libraries located in: ${LLVM_LIBRARY_DIRS}")
+    message(STATUS "LLVM libraries located in: ${LLVM_LIBRARY_DIRS}")

-    if (NOT LLVM_PACKAGE_VERSION VERSION_GREATER_EQUAL 15.0)
-        message(FATAL_ERROR "LLVM version 15.0 or later is required.")
+    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)
@@ -213,44 +253,43 @@ if(C3_WITH_LLVM)
        llvm_map_components_to_libnames(llvm_libs ${LLVM_LINK_COMPONENTS})

        if(NOT ${C3_LLD_DIR} EQUAL "" AND EXISTS ${C3_LLD_DIR})
-            message("C3_LLD_DIR: " ${C3_LLD_DIR})
-            set(LLVM_LIBRARY_DIRS
-                    "${LLVM_LIBRARY_DIRS}"
-                    "${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.
-        message(STATUS "using find_library")
-        find_library(LLD_COFF NAMES liblldCOFF.dylib lldCOFF.lib lldCOFF.a liblldCOFF.dll.a liblldCOFF.a PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
-        find_library(LLD_COMMON NAMES liblldCommon.dylib lldCommon.lib lldCommon.a liblldCommon.dll.a liblldCommon.a PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
-        find_library(LLD_ELF NAMES liblldELF.dylib lldELF.lib lldELF.a liblldELF.dll.a liblldELF.a PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
-        find_library(LLD_MACHO NAMES liblldMachO.dylib lldMachO.lib lldMachO.a liblldMachO.dll.a liblldMachO.a PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
-        find_library(LLD_MINGW NAMES liblldMinGW.dylib lldMinGW.lib lldMinGW.a liblldMinGW.dll.a liblldMinGW.a PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
-        find_library(LLD_WASM NAMES liblldWasm.dylib lldWasm.lib lldWasm.a liblldWasm.dll.a liblldWasm.a PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
+        find_library(LLD_COFF NAMES liblldCOFF.dylib lldCOFF.lib lldCOFF.a liblldCOFF.dll.a liblldCOFF.a PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH REQUIRED)
+        find_library(LLD_COMMON NAMES liblldCommon.dylib lldCommon.lib lldCommon.a liblldCommon.dll.a liblldCommon.a PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH REQUIRED)
+        find_library(LLD_ELF NAMES liblldELF.dylib lldELF.lib lldELF.a liblldELF.dll.a liblldELF.a PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH REQUIRED)
+        if (NOT ${CMAKE_SYSTEM_NAME} STREQUAL "OpenBSD")
+            find_library(LLD_MACHO NAMES liblldMachO.dylib lldMachO.lib lldMachO.a liblldMachO.dll.a liblldMachO.a PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH REQUIRED)
+        else()
+            set(LLD_MACHO "")
+        endif()
+        find_library(LLD_MINGW NAMES liblldMinGW.dylib lldMinGW.lib lldMinGW.a liblldMinGW.dll.a liblldMinGW.a PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH REQUIRED)
+        find_library(LLD_WASM NAMES liblldWasm.dylib lldWasm.lib lldWasm.a liblldWasm.dll.a liblldWasm.a PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH REQUIRED)
    else()
-        find_library(LLVM NAMES libLLVM.so PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
+        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)
        set(llvm_libs ${LLVM})

        # These don't seem to be reliable on windows.
-        message(STATUS "using find_library")
-        find_library(LLD_COFF NAMES liblldCOFF.so PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
-        find_library(LLD_COMMON NAMES liblldCommon.so PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
-        find_library(LLD_ELF NAMES liblldELF.so PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
-        find_library(LLD_MACHO NAMES liblldMachO.so PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
-        find_library(LLD_MINGW NAMES liblldMinGW.so PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
-        find_library(LLD_WASM NAMES liblldWasm.so PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
+        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()
-endif()

-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)
-    find_library(LLD_LOONG NAMES libLLVMLoongArchCodeGen.lib libLLVMLoongArchAsmParser.lib libLLVMLoongArchCodeGen.a libLLVMLoongArchAsmParser.a PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
+    # 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}
@@ -275,8 +314,8 @@ if(C3_WITH_LLVM)
        )
    endif()

-    message(STATUS "linking to llvm libs ${lld_libs}")
-    message(STATUS "Found lld libs ${lld_libs}")
+    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)
@@ -352,6 +391,7 @@ add_executable(c3c
        src/utils/unzipper.c
        src/compiler/c_codegen.c
        src/compiler/decltable.c
+        src/compiler/methodtable.c
        src/compiler/mac_support.c
        src/compiler/windows_support.c
        src/compiler/codegen_asm.c
@@ -394,6 +434,11 @@ if(C3_WITH_LLVM)

    target_compile_definitions(c3c PUBLIC LLVM_AVAILABLE=1)
    add_library(c3c_wrappers STATIC wrapper/src/wrapper.cpp)
+    if (MSVC)
+        target_compile_options(c3c PRIVATE
+                "$<$<CONFIG:Debug>:/EHa>"
+                "$<$<CONFIG:Release>:/EHsc>")
+    endif()
 else()
    target_sources(c3c PRIVATE src/utils/hostinfo.c)
    target_compile_definitions(c3c PUBLIC LLVM_AVAILABLE=0)
@@ -477,7 +522,7 @@ endif ()

 if (CURL_FOUND)
    target_link_libraries(c3c ${CURL_LIBRARIES})
-    target_include_directories(c3c PRIVATE ${CURL_INCLUDES})
+    target_include_directories(c3c PRIVATE ${CURL_INCLUDE_DIRS})
    target_compile_definitions(c3c PUBLIC CURL_FOUND=1)
 else()
    target_compile_definitions(c3c PUBLIC CURL_FOUND=0)
@@ -485,34 +530,27 @@ endif()


 if(MSVC)
-    message("Adding MSVC options")
-    target_compile_options(c3c PRIVATE /wd4068 /wd4090 /WX /Wv:18)
+    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)
+        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(CMAKE_BUILD_TYPE STREQUAL "Debug")
-        target_compile_options(c3c PUBLIC /MTd)
-        if (C3_WITH_LLVM)
-            target_compile_options(c3c_wrappers PUBLIC /MTd)
-        endif()
-        target_compile_options(miniz PUBLIC /MTd)
-        if (C3_USE_TB)
-            target_compile_options(tilde-backend PUBLIC /MTd)
-        endif()
-    else()
-        target_compile_options(c3c PUBLIC /MT)
-        if (C3_WITH_LLVM)
-            target_compile_options(c3c_wrappers PUBLIC /MT)
-        endif()
-        target_compile_options(miniz PUBLIC /MT)
-        if (C3_USE_TB)
-            target_compile_options(tilde-backend PUBLIC /MT)
-        endif()
-    endif()
+
    if(C3_WITH_LLVM)
        set(clang_lib_dir ${llvm_dir}/lib/clang/${C3_LLVM_VERSION}/lib/windows)
        set(sanitizer_runtime_libraries
@@ -522,13 +560,31 @@ if(MSVC)
                ${clang_lib_dir}/clang_rt.asan_dynamic_runtime_thunk-x86_64.lib)
    endif()
 else()
-    message(STATUS "using gcc/clang warning switches")
-    target_link_options(c3c PRIVATE -pthread)
    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)
+    target_compile_options(c3c PRIVATE
+        -pthread
+        -Wall
+        -Werror
+        -Wno-unknown-pragmas
+        -Wno-unused-result
+        -Wno-unused-function
+        -Wno-unused-variable
+        -Wno-unused-parameter
+    )
+    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)
@@ -539,6 +595,12 @@ 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
@@ -558,3 +620,35 @@ if (C3_WITH_LLVM AND DEFINED sanitizer_runtime_libraries)
 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}\"")
--- a/CMakePresets.json
+++ b/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"
+        }
+    ]
+}
--- a/CODESTYLE.md
+++ b/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

@@ -147,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.
--- a/CODE_OF_CONDUCT.md
+++ b/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.
--- a/CONTRIBUTING.md
+++ b/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.
--- a/179
+++ b/179
@@ -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.
--- a/165
+++ b/165
@@ -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.
--- a/20
+++ b/20
@@ -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.
--- a/README.md
+++ b/README.md
@@ -8,16 +8,19 @@ 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/c3-windows.zip), [install instructions](#installing-on-windows-with-precompiled-binaries).
- Debian x64 [download](https://github.com/c3lang/c3c/releases/download/latest/c3-linux.tar.gz), [install instructions](#installing-on-debian-with-precompiled-binaries).
- Ubuntu x86 [download](https://github.com/c3lang/c3c/releases/download/latest/c3-ubuntu-20.tar.gz), [install instructions](#installing-on-ubuntu-with-precompiled-binaries).
- MacOS Arm64 [download](https://github.com/c3lang/c3c/releases/download/latest/c3-macos.zip), [install instructions](#installing-on-mac-with-precompiled-binaries).
+- 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.
@@ -33,10 +36,10 @@ whole new language.

 ### Example code

-The following code shows [generic modules](https://c3-lang.org/references/docs/generics/) (more examples can be found at https://c3-lang.org/references/docs/examples/). 
+The following code shows [generic modules](https://c3-lang.org/generic-programming/generics/) (more examples can be found at https://c3-lang.org/language-overview/examples/). 

 ```cpp
-module stack (<Type>);
+module stack {Type};
 // Above: the parameterized type is applied to the entire module.

 struct Stack
@@ -80,13 +83,13 @@ import stack;

 // Define our new types, the first will implicitly create 
 // a complete copy of the entire Stack module with "Type" set to "int"
-def IntStack = Stack(<int>);
+alias IntStack = Stack {int};
 // The second creates another copy with "Type" set to "double"
-def 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
@@ -124,6 +127,7 @@ fn void main()
 - New semantic macro system
 - Module based name spacing
 - Slices
+- Operator overloading
 - Compile time reflection
 - Enhanced compile time execution
 - Generics based on generic modules
@@ -138,15 +142,16 @@ fn void main()

 ### Current status

-The current stable version of the compiler is **version 0.6.8**.
+The current stable version of the compiler is **version 0.7.8**.

-The the next version is 0.7.0 which will be a breaking release.
+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**

@@ -167,17 +172,21 @@ The compiler is currently verified to compile on Linux, Windows and MacOS.
 | 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              | 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*
+*\* 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.

@@ -193,34 +202,75 @@ More platforms will be supported in the future.

 ### Installing

+This installs the latest prerelease build, as opposed to the latest released version.
+
 #### Installing on Windows with precompiled binaries
-1. Download the zip file: [https://github.com/c3lang/c3c/releases/download/latest/c3-windows.zip](https://github.com/c3lang/c3c/releases/download/latest/c3-windows.zip) 
-(debug version [here](https://github.com/c3lang/c3c/releases/download/latest/c3-windows-debug.zip))
+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`.

+#### Installing on Windows with the install script
+
+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/c3-linux.tar.gz](https://github.com/c3lang/c3c/releases/download/latest/c3-linux.tar.gz)
-   (debug version [here](https://github.com/c3lang/c3c/releases/download/latest/c3-linux-debug.tar.gz))
+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/c3-ubuntu-20.tar.gz](https://github.com/c3lang/c3c/releases/download/latest/c3-ubuntu-20.tar.gz)
-   (debug version [here](https://github.com/c3lang/c3c/releases/download/latest/c3-ubuntu-20-debug.tar.gz))
+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/c3-macos.zip](https://github.com/c3lang/c3c/releases/download/latest/c3-macos.zip)
-   (debug version [here](https://github.com/c3lang/c3c/releases/download/latest/c3-macos-debug.zip))
+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
 Arch includes c3c in the official 'extra' repo. It can be easily installed the usual way:

@@ -247,33 +297,81 @@ cd c3c-git
 makepkg -si
 ```

+#### Installing via Nix
+
+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";
+    };
+  };
+
+  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
+        ];
+      };
+    }
+  );
+}
+```
+
+### 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 17+: `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 Windows using Scoop

@@ -314,28 +412,35 @@ called `hello_world` or `hello_world.exe`depending on platform.
 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 -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
+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.
+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`
+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`
+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. Create a build directory `mkdir build`
-6. Change directory to the build directory `cd build`
-7. Set up CMake build: `cmake ..`
-8. Build: `cmake --build .`
+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.

@@ -348,13 +453,12 @@ You can try it out by running some sample code: `./c3c compile ../resources/exam
 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 a build directory: `mkdir build`
-5. Enter the build directory: `cd build`
-6. Create the CMake build cache: `cmake ..`
-7. Build: `cmake --build .`
+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 sytem-wide installation, run the following as root: `cmake --install .`
+For a system-wide installation, run the following as root: `cmake --install .`


 #### Compiling on Fedora
@@ -364,12 +468,37 @@ For a sytem-wide installation, run the following as root: `cmake --install .`
 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 a build directory and navigate into it: `mkdir build && cd build`
-6. Create the CMake build cache. The Fedora repositories provide `.so` libraries for lld, so you need to set the C3_LINK_DYNAMIC flag: `cmake .. -DC3_LINK_DYNAMIC=1`
-7. Build the project: `cmake --build .`
+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

@@ -377,11 +506,10 @@ The c3c binary should be created in the build directory. You can try it out by r
 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. 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 .`
+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
@@ -389,8 +517,13 @@ this functionality is non-essential and it is perfectly fine to user the compile

 #### 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 your build your own C3 compiler.

 #### Editor plugins

@@ -409,4 +542,13 @@ Editor plugins can be found at https://github.com/c3lang/editor-plugins.

 A huge **THANK YOU** goes out to all contributors and sponsors.

-A special thank you to sponsors [Caleb-o](https://github.com/Caleb-o) and [devdad](https://github.com/devdad) for going the extra mile.
+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)
--- a/benchmarks/stdlib/collections/hashmap.c3
+++ b/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();
+}
--- a/benchmarks/stdlib/collections/linkedlist.c3
+++ b/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);
+}
--- a/benchmarks/stdlib/core/string_trim.c3
+++ b/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
--- a/benchmarks/stdlib/crypto/aes_bench.c3
+++ b/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);
+}
+
--- a/benchmarks/stdlib/hash/non_crypto_shootout.c3
+++ b/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);
--- a/build-with-docker.sh
+++ b/build-with-docker.sh
@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/usr/bin/env bash

 : ${DOCKER:=docker}
 : ${IMAGE:="c3c-builder"}
@@ -41,4 +41,4 @@ exec $DOCKER run -i --rm \
            -DCMAKE_DLLTOOL=llvm-dlltool-$LLVM_VERSION \
            -DC3_LLVM_VERSION=auto && \
    cmake --build build && \
-    cp -r build/c3c build/lib bin"
+    cp -r build/c3c build/lib bin"
--- a/docker/Dockerfile
+++ b/docker/Dockerfile
@@ -6,7 +6,7 @@ ENV LLVM_DEV_VERSION=20

 ARG CMAKE_VERSION=3.20

-RUN apt-get update && apt-get install -y wget gnupg software-properties-common zlib1g zlib1g-dev python3 ninja-build curl g++ && \
+RUN apt-get update && apt-get install -y wget gnupg software-properties-common zlib1g zlib1g-dev python3 ninja-build curl g++ libcurl4-openssl-dev && \
    wget https://github.com/Kitware/CMake/releases/download/v${CMAKE_VERSION}/cmake-$CMAKE_VERSION-linux-x86_64.sh && \
    mkdir -p /opt/cmake && \
    sh cmake-${CMAKE_VERSION}-linux-x86_64.sh --prefix=/opt/cmake --skip-license && \
@@ -46,4 +46,4 @@ RUN groupadd -g 1337 c3c && \
 USER c3c
 ENV PATH="/opt/cmake/bin:${PATH}"

-WORKDIR /home/c3c
+WORKDIR /home/c3c
--- a/flake.nix
+++ b/flake.nix
@@ -6,29 +6,27 @@
    flake-utils.url = "github:numtide/flake-utils";
  };

-  outputs = { self, ... } @ inputs: inputs.flake-utils.lib.eachDefaultSystem 
+  outputs = { self, ... }@inputs: inputs.flake-utils.lib.eachDefaultSystem 
  (system: 
    let pkgs = import inputs.nixpkgs { inherit system; }; 
-        call = set: pkgs.callPackage ./nix/default.nix ( 
-          set // { 
-            rev = self.rev or "unknown"; 
-          } 
-        );
+        c3cBuild = set: pkgs.callPackage ./nix/default.nix (set // { 
+          rev = self.rev or "unknown"; 
+        });
    in {
      packages = {
        default = self.packages.${system}.c3c;

-        c3c = call {};
+        c3c = c3cBuild {};
        
-        c3c-checks = pkgs.callPackage ./nix/default.nix { 
+        c3c-checks = c3cBuild { 
          checks = true; 
        };

-        c3c-debug = pkgs.callPackage ./nix/default.nix { 
+        c3c-debug = c3cBuild { 
          debug = true; 
        };

-        c3c-debug-checks = pkgs.callPackage ./nix/default.nix { 
+        c3c-debug-checks = c3cBuild { 
          debug = true; 
          checks = true; 
        };
--- a/install/install.ps1
+++ b/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"
+}
--- a/install/install.sh
+++ b/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__
--- a/lib/std/ascii.c3
+++ b/lib/std/ascii.c3
@@ -1,77 +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_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 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 is_lower(char c) => is_lower_m(c);
-fn bool is_upper(char c) => is_upper_m(c);
-fn bool is_digit(char c) => is_digit_m(c);
-fn bool is_bdigit(char c) => is_bdigit_m(c);
-fn bool is_odigit(char c) => is_odigit_m(c);
-fn bool is_xdigit(char c) => is_xdigit_m(c);
-fn bool is_alpha(char c) => is_alpha_m(c);
-fn bool is_print(char c) => is_print_m(c);
-fn bool is_graph(char c) => is_graph_m(c);
-fn bool is_space(char c) => is_space_m(c);
-fn bool is_alnum(char c) => is_alnum_m(c);
-fn bool is_punct(char c) => is_punct_m(c);
-fn bool is_blank(char c) => is_blank_m(c);
-fn bool is_cntrl(char c) => is_cntrl_m(c);
-fn char to_lower(char c) => (char)to_lower_m(c);
-fn char to_upper(char c) => (char)to_upper_m(c);

 fn bool char.in_range(char c, char start, char len) => in_range_m(c, start, len);
-fn bool char.is_lower(char c) => is_lower_m(c);
-fn bool char.is_upper(char c) => is_upper_m(c);
-fn bool char.is_digit(char c) => is_digit_m(c);
-fn bool char.is_bdigit(char c) => is_bdigit_m(c);
-fn bool char.is_odigit(char c) => is_odigit_m(c);
-fn bool char.is_xdigit(char c) => is_xdigit_m(c);
-fn bool char.is_alpha(char c) => is_alpha_m(c);
-fn bool char.is_print(char c) => is_print_m(c);
-fn bool char.is_graph(char c) => is_graph_m(c);
-fn bool char.is_space(char c) => is_space_m(c);
-fn bool char.is_alnum(char c) => is_alnum_m(c);
-fn bool char.is_punct(char c) => is_punct_m(c);
-fn bool char.is_blank(char c) => is_blank_m(c);
-fn bool char.is_cntrl(char c) => is_cntrl_m(c);
-fn char char.to_lower(char c) => (char)to_lower_m(c);
-fn char char.to_upper(char c) => (char)to_upper_m(c);
-<*
- @require c.is_xdigit()
-*>
-fn char char.from_hex(char c) => c.is_digit() ? c - '0' : 10 + (c | 0x20) - 'a';

 fn bool uint.in_range(uint c, uint start, uint len) => in_range_m(c, start, len);
-fn bool uint.is_lower(uint c) => is_lower_m(c);
-fn bool uint.is_upper(uint c) => is_upper_m(c);
-fn bool uint.is_digit(uint c) => is_digit_m(c);
-fn bool uint.is_bdigit(uint c) => is_bdigit_m(c);
-fn bool uint.is_odigit(uint c) => is_odigit_m(c);
-fn bool uint.is_xdigit(uint c) => is_xdigit_m(c);
-fn bool uint.is_alpha(uint c) => is_alpha_m(c);
-fn bool uint.is_print(uint c) => is_print_m(c);
-fn bool uint.is_graph(uint c) => is_graph_m(c);
-fn bool uint.is_space(uint c) => is_space_m(c);
-fn bool uint.is_alnum(uint c) => is_alnum_m(c);
-fn bool uint.is_punct(uint c) => is_punct_m(c);
-fn bool uint.is_blank(uint c) => is_blank_m(c);
-fn bool uint.is_cntrl(uint c) => is_cntrl_m(c);
-fn uint uint.to_lower(uint c) => (uint)to_lower_m(c);
-fn uint uint.to_upper(uint c) => (uint)to_upper_m(c);
+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);
--- a/lib/std/atomic.c3
+++ b/lib/std/atomic.c3
@@ -1,7 +1,7 @@
-// Copyright (c) 2023 Eduardo José Gómez Hernández. 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::types(<Type>);
+module std::atomic::types{Type};

 struct Atomic
 {
@@ -11,7 +11,7 @@ struct Atomic
 <*
 Loads data atomically, by default this uses SEQ_CONSISTENT ordering.

- @param ordering "The ordering, cannot be release or acquire-release."
+ @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)
@@ -31,7 +31,7 @@ macro Type Atomic.load(&self, AtomicOrdering ordering = SEQ_CONSISTENT)
 <*
 Stores data atomically, by default this uses SEQ_CONSISTENT ordering.

- @param ordering "The ordering, cannot be acquire or acquire-release."
+ @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)
@@ -76,7 +76,7 @@ macro Type Atomic.div(&self, Type value, AtomicOrdering ordering = SEQ_CONSISTEN
 macro Type Atomic.max(&self, Type value, AtomicOrdering ordering = SEQ_CONSISTENT)
 {
 	Type* data = &self.data;
-	return @atomic_exec(atomic::fetch_div, data, value, ordering);
+	return @atomic_exec(atomic::fetch_max, data, value, ordering);
 }

 macro Type Atomic.min(&self, Type value, AtomicOrdering ordering = SEQ_CONSISTENT)
@@ -85,36 +85,49 @@ macro Type Atomic.min(&self, Type value, AtomicOrdering ordering = SEQ_CONSISTEN
 	return @atomic_exec(atomic::fetch_min, data, value, ordering);
 }

-macro Type Atomic.or(&self, uint value, AtomicOrdering ordering = SEQ_CONSISTENT) @if(!types::is_float(Type))
+macro Type Atomic.or(&self, Type value, AtomicOrdering ordering = SEQ_CONSISTENT) @if(types::flat_kind(Type) != FLOAT)
 {
 	Type* data = &self.data;
 	return @atomic_exec(atomic::fetch_or, data, value, ordering);
 }

-fn Type Atomic.xor(&self, uint value, AtomicOrdering ordering = SEQ_CONSISTENT) @if(!types::is_float(Type))
+macro Type Atomic.xor(&self, Type value, AtomicOrdering ordering = SEQ_CONSISTENT) @if(types::flat_kind(Type) != FLOAT)
 {
 	Type* data = &self.data;
 	return @atomic_exec(atomic::fetch_xor, data, value, ordering);
 }

-macro Type Atomic.and(&self, uint value, AtomicOrdering ordering = SEQ_CONSISTENT) @if(!types::is_float(Type))
+macro Type Atomic.and(&self, Type value, AtomicOrdering ordering = SEQ_CONSISTENT) @if(types::flat_kind(Type) != FLOAT)
 {
 	Type* data = &self.data;
 	return @atomic_exec(atomic::fetch_and, data, value, ordering);
 }

-macro Type Atomic.shift_right(&self, uint amount, AtomicOrdering ordering = SEQ_CONSISTENT) @if(!types::is_float(Type))
+macro Type Atomic.shr(&self, Type amount, AtomicOrdering ordering = SEQ_CONSISTENT) @if(types::flat_kind(Type) != FLOAT)
 {
 	Type* data = &self.data;
 	return @atomic_exec(atomic::fetch_shift_right, data, amount, ordering);
 }

-macro Type Atomic.shift_left(&self, uint amount, AtomicOrdering ordering = SEQ_CONSISTENT) @if(!types::is_float(Type))
+macro Type Atomic.shl(&self, Type amount, AtomicOrdering ordering = SEQ_CONSISTENT) @if(types::flat_kind(Type) != FLOAT)
 {
 	Type* data = &self.data;
 	return @atomic_exec(atomic::fetch_shift_left, data, amount, ordering);
 }

+macro Type Atomic.set(&self, AtomicOrdering ordering = SEQ_CONSISTENT) @if(types::flat_kind(Type) == BOOL)
+{
+	Type* data = &self.data;
+	return @atomic_exec_no_arg(atomic::flag_set, data, ordering);
+}
+
+macro Type Atomic.clear(&self, AtomicOrdering ordering = SEQ_CONSISTENT) @if(types::flat_kind(Type) == BOOL)
+{
+	Type* data = &self.data;
+
+	return @atomic_exec_no_arg(atomic::flag_clear, data, ordering);
+}
+
 macro @atomic_exec(#func, data, value, ordering) @local
 {
 	switch(ordering) 
@@ -128,18 +141,60 @@ macro @atomic_exec(#func, data, value, ordering) @local
 	}
 }

+macro @atomic_exec_no_arg(#func, data, ordering) @local
+{
+	switch(ordering)
+	{
+		case RELAXED: return #func(data, RELAXED);
+		case ACQUIRE: return #func(data, ACQUIRE);
+		case RELEASE: return #func(data, RELEASE);
+		case ACQUIRE_RELEASE: return #func(data, ACQUIRE_RELEASE);
+		case SEQ_CONSISTENT: return #func(data, SEQ_CONSISTENT);
+		default: unreachable("Ordering may not be non-atomic or unordered.");
+	}
+}
+
 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 DISTINCT:
+			$case CONST_ENUM:
+				return is_native_atomic_type($Type.inner);
+			$default:
+				return false;
+		$endswitch
+	$endif
+}
+
 <*
- @param [&in] 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"
+ @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 types::is_int($typeof(*ptr)) || types::is_float($typeof(*ptr)) "Only integer/float pointers may be used."
- @require $ordering != AtomicOrdering.NOT_ATOMIC && $ordering != AtomicOrdering.UNORDERED "Acquire ordering is not valid."
+ @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)
 {
@@ -150,14 +205,16 @@ macro fetch_add(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT, bool $volatil
 }

 <*
- @param [&in] 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"
+ @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 types::is_int($typeof(*ptr)) || types::is_float($typeof(*ptr)) "Only integer/float pointers may be used."
- @require $ordering != AtomicOrdering.NOT_ATOMIC && $ordering != AtomicOrdering.UNORDERED "Acquire ordering is not valid."
+ @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)
 {
@@ -168,22 +225,24 @@ macro fetch_sub(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT, bool $volatil
 }

 <*
- @param [&in] 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"
+ @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 types::is_int($typeof(*ptr)) || types::is_float($typeof(*ptr)) "Only integer/float pointers may be used."
- @require $ordering != AtomicOrdering.NOT_ATOMIC && $ordering != AtomicOrdering.UNORDERED "Acquire ordering is not valid."
+ @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 = AtomicOrdering.SEQ_CONSISTENT;
+	    $load_ordering = SEQ_CONSISTENT;
 	$endif
 	
-	var $StorageType = $typefrom(types::lower_to_atomic_compatible_type($typeof(*ptr)));
+	var $StorageType = types::lower_to_atomic_compatible_type($typeof(*ptr));

 	$StorageType* storage_ptr = ($StorageType*)ptr;

@@ -193,34 +252,37 @@ macro fetch_mul(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT)
 	$StorageType storage_old_value;
 	$StorageType storage_new_value;

-
-	do {
+	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);
+	}
+	while (mem::compare_exchange(storage_ptr, storage_old_value, storage_new_value, $ordering, $load_ordering) != storage_old_value);

 	return old_value;
 }

 <*
- @param [&in] 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"
+ @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 types::is_int($typeof(*ptr)) || types::is_float($typeof(*ptr)) "Only integer/float pointers may be used."
- @require $ordering != AtomicOrdering.NOT_ATOMIC && $ordering != AtomicOrdering.UNORDERED "Acquire ordering is not valid."
+ @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 = AtomicOrdering.SEQ_CONSISTENT;
+	    $load_ordering = SEQ_CONSISTENT;
 	$endif
 	
-	var $StorageType = $typefrom(types::lower_to_atomic_compatible_type($typeof(*ptr)));
+	var $StorageType = types::lower_to_atomic_compatible_type($typeof(*ptr));

 	$StorageType* storage_ptr = ($StorageType*)ptr;

@@ -230,163 +292,89 @@ macro fetch_div(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT)
 	$StorageType storage_old_value;
 	$StorageType storage_new_value;
 	
-	do {
+	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);
+	}
+	while (mem::compare_exchange(storage_ptr, storage_old_value, storage_new_value, $ordering, $load_ordering) != storage_old_value);

 	return old_value;
 }

 <*
- @param [&in] 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"
+ @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 types::is_int($typeof(*ptr)) "Only integer pointers may be used."
- @require types::is_int($typeof(y)) "The value for or must be an int"
- @require $ordering != AtomicOrdering.NOT_ATOMIC && $ordering != AtomicOrdering.UNORDERED "Acquire ordering is not valid."
+ @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)
 {
-	$if	types::is_int($typeof(*ptr)):
-		return $$atomic_fetch_or(ptr, y, $volatile, $ordering.ordinal, $alignment);
-	$endif
-
-	var $load_ordering = $ordering;
-	$if $ordering == RELEASE || $ordering == ACQUIRE_RELEASE:
-	    $load_ordering = AtomicOrdering.SEQ_CONSISTENT;
-	$endif
-	
-	var $StorageType = $typefrom(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;
+	return $$atomic_fetch_or(ptr, y, $volatile, $ordering.ordinal, $alignment);
 }

 <*
- @param [&in] 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"
+ @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 types::is_int($typeof(*ptr)) "Only integer pointers may be used."
- @require types::is_int($typeof(y)) "The value for or must be an int"
- @require $ordering != AtomicOrdering.NOT_ATOMIC && $ordering != AtomicOrdering.UNORDERED "Acquire ordering is not valid."
+ @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)
 {
-	$if	types::is_int($typeof(*ptr)):
-		return $$atomic_fetch_xor(ptr, y, $volatile, $ordering.ordinal, $alignment);
-	$endif
-
-	var $load_ordering = $ordering;
-	$if $ordering == RELEASE || $ordering == ACQUIRE_RELEASE:
-	    $load_ordering = AtomicOrdering.SEQ_CONSISTENT;
-	$endif
-	
-	var $StorageType = $typefrom(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;
+	return $$atomic_fetch_xor(ptr, y, $volatile, $ordering.ordinal, $alignment);
 }

 <*
- @param [&in] 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"
+ @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 types::is_int($typeof(*ptr)) "Only integer pointers may be used."
- @require types::is_int($typeof(y)) "The value for or must be an int"
- @require $ordering != AtomicOrdering.NOT_ATOMIC && $ordering != AtomicOrdering.UNORDERED "Acquire ordering is not valid."
+ @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)
 {
-	$if	types::is_int($typeof(*ptr)):
-		return $$atomic_fetch_and(ptr, y, $volatile, $ordering.ordinal, $alignment);
-	$endif
-
-	var $load_ordering = $ordering;
-	$if $ordering == RELEASE || $ordering == ACQUIRE_RELEASE:
-	    $load_ordering = AtomicOrdering.SEQ_CONSISTENT;
-	$endif
-	
-	var $StorageType = $typefrom(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;
+	return $$atomic_fetch_and(ptr, y, $volatile, $ordering.ordinal, $alignment);
 }

 <*
- @param [&in] 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"
+ @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 types::is_int($typeof(*ptr)) "Only integer pointers may be used."
- @require types::is_int($typeof(y)) "The value for or must be an int"
- @require $ordering != AtomicOrdering.NOT_ATOMIC && $ordering != AtomicOrdering.UNORDERED "Acquire ordering is not valid."
+ @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 = AtomicOrdering.SEQ_CONSISTENT;
+	    $load_ordering = SEQ_CONSISTENT;
 	$endif
 	
-	var $StorageType = $typefrom(types::lower_to_atomic_compatible_type($typeof(*ptr)));
+	var $StorageType = types::lower_to_atomic_compatible_type($typeof(*ptr));

 	$StorageType* storage_ptr = ($StorageType*)ptr;

@@ -397,34 +385,38 @@ macro fetch_shift_right(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT)
 	$StorageType storage_new_value;
 	$StorageType storage_y = ($StorageType)y;
 	
-	do {
+	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);
+	}
+	while (mem::compare_exchange(storage_ptr, storage_old_value, storage_new_value, $ordering, $load_ordering) != storage_old_value);

 	return old_value;
 }

 <*
- @param [&in] 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"
+ @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 types::is_int($typeof(*ptr)) "Only integer pointers may be used."
- @require types::is_int($typeof(y)) "The value for or must be an int"
- @require $ordering != AtomicOrdering.NOT_ATOMIC && $ordering != AtomicOrdering.UNORDERED "Acquire ordering is not valid."
+ @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 = AtomicOrdering.SEQ_CONSISTENT;
+	    $load_ordering = SEQ_CONSISTENT;
 	$endif
 	
-	var $StorageType = $typefrom(types::lower_to_atomic_compatible_type($typeof(*ptr)));
+	var $StorageType = types::lower_to_atomic_compatible_type($typeof(*ptr));

 	$StorageType* storage_ptr = ($StorageType*)ptr;

@@ -435,64 +427,83 @@ macro fetch_shift_left(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT)
 	$StorageType storage_new_value;
 	$StorageType storage_y = ($StorageType)y;
 	
-	do {
+	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);
+	}
+	while (mem::compare_exchange(storage_ptr, storage_old_value, storage_new_value, $ordering, $load_ordering) != storage_old_value);

 	return old_value;
 }

 <*
- @param [&in] ptr "the variable or dereferenced pointer to the data."
- @param $ordering "atomic ordering of the load, defaults to SEQ_CONSISTENT"
+ @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 types::is_int($typeof(*ptr)) "Only integer pointers may be used."
- @require $ordering != AtomicOrdering.NOT_ATOMIC && $ordering != AtomicOrdering.UNORDERED "Acquire ordering is not valid."
+ @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);

-	do {
-		old_value = $$atomic_load(ptr, false, $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 $ordering "atomic ordering of the load, defaults to SEQ_CONSISTENT"
+ @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 types::is_int($typeof(*ptr)) "Only integer pointers may be used."
- @require $ordering != AtomicOrdering.NOT_ATOMIC && $ordering != AtomicOrdering.UNORDERED "Acquire ordering is not valid."
+ @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;
-
-	do {
-		old_value = $$atomic_load(ptr, false, $ordering.ordinal);
-	} while (mem::compare_exchange(ptr, old_value, new_value, $ordering, $load_ordering) != old_value);
+	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 added to ptr."
- @param $ordering "atomic ordering of the load, defaults to SEQ_CONSISTENT"
+ @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 types::is_int($typeof(*ptr)) || types::is_float($typeof(*ptr)) "Only integer/float pointers may be used."
- @require $ordering != AtomicOrdering.NOT_ATOMIC && $ordering != AtomicOrdering.UNORDERED "Acquire ordering is not valid."
+ @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)
 {
@@ -503,13 +514,15 @@ macro fetch_max(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT, bool $volatil
 }

 <*
- @param [&in] 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"
+ @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 types::is_int($typeof(*ptr)) || types::is_float($typeof(*ptr)) "Only integer/float pointers may be used."
- @require $ordering != AtomicOrdering.NOT_ATOMIC && $ordering != AtomicOrdering.UNORDERED "Acquire ordering is not valid."
+ @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)
 {
--- a/lib/std/atomic_nolibc.c3
+++ b/lib/std/atomic_nolibc.c3
@@ -3,8 +3,9 @@
 // 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)
+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);
@@ -16,7 +17,7 @@ macro @__atomic_compare_exchange_ordering_failure(ptr, expected, desired, $succe

 macro @__atomic_compare_exchange_ordering_success(ptr, expected, desired, success, failure, $alignment)
 {
-	switch(success)
+	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);
@@ -28,7 +29,7 @@ macro @__atomic_compare_exchange_ordering_success(ptr, expected, desired, succes
 	return 0;
 }

-fn CInt __atomic_compare_exchange(CInt size, any ptr, any expected, any desired, CInt success, CInt failure) @extern("__atomic_compare_exchange") @export
+fn CInt __atomic_compare_exchange(CInt size, any ptr, any expected, any desired, CInt success, CInt failure) @weak @export("__atomic_compare_exchange")
 {
 	switch (size)
 	{
@@ -57,7 +58,7 @@ fn CInt __atomic_compare_exchange(CInt size, any ptr, any expected, any desired,
 				nextcase;
 			$endif
 		default:
-			unreachable("Unsuported size (%d) for atomic_compare_exchange", size);
+			unreachable("Unsupported size (%d) for atomic_compare_exchange", size);
 	}
 	return 0;
-}
+}
--- a/lib/std/bits.c3
+++ b/lib/std/bits.c3
@@ -1,94 +1,94 @@
 module std::bits;

 <*
- @require types::is_intlike($typeof(i)) `The input must be an integer or integer vector`
+ @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`
+ @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 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 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 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 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 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 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 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 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 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 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);
--- a/lib/std/collections/anylist.c3
+++ b/lib/std/collections/anylist.c3
@@ -1,365 +1,103 @@
-// Copyright (c) 2024 Christoffer Lerno. All rights reserved.
+// 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::io,std::math;
-
-def AnyPredicate = fn bool(any value);
-def AnyTest = fn bool(any type, any context);
-
-struct AnyList (Printable)
-{
-	usz size;
-	usz capacity;
-	Allocator allocator;
-	any* entries;
-}
+import std::collections::interfacelist;

+alias AnyPredicate = InterfacePredicate {any};
+alias AnyTest = InterfaceTest {any};

 <*
- Use `init` for to use a custom allocator.
+ 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.

- @param initial_capacity "The initial capacity to reserve"
+ 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.
 *>
-fn AnyList* AnyList.new_init(&self, usz initial_capacity = 16, Allocator allocator = null) @deprecated("Use init(mem)")
+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 self.init(allocator ?: allocator::heap(), initial_capacity) @inline;
+	return *anycast(self.first_any(), $Type);
 }

 <*
- @param [&inout] allocator "The allocator to use"
- @param initial_capacity "The initial capacity to reserve"
+ Return the first element
+
+ @return "The first element"
+ @return? NO_MORE_ELEMENT
 *>
-fn AnyList* AnyList.init(&self, Allocator allocator, usz initial_capacity = 16)
+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)
 {
-	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, any, initial_capacity);
-	}
-	else
-	{
-		self.entries = null;
-	}
-	self.capacity = initial_capacity;
-	return self;
+	return *anycast(self.last_any(), $Type);
 }

 <*
- Initialize the list using the temp allocator.
+ Return the last element

- @param initial_capacity "The initial capacity to reserve"
+ @return "The last element"
+ @return? NO_MORE_ELEMENT
 *>
-fn AnyList* AnyList.temp_init(&self, usz initial_capacity = 16) @deprecated("Use tinit")
-{
-	return self.init(allocator::temp(), initial_capacity) @inline;
-}
-
+fn any? AnyList.last_any(&self) @inline => InterfaceList {any}.last(self);

 <*
- Initialize the list using the temp allocator.
+ Pop a value who's type is known. If the type is incorrect, this
+ will still pop the element.

- @param initial_capacity "The initial capacity to reserve"
+ @param $Type : "The type we assume the value has"
+ @return "The last value as the type given"
+ @return? TYPE_MISMATCH, NO_MORE_ELEMENT
 *>
-fn AnyList* AnyList.tinit(&self, usz initial_capacity = 16)
+macro AnyList.pop(&self, $Type)
 {
-	return self.init(allocator::temp(), initial_capacity) @inline;
-}
-
-fn usz! AnyList.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 AnyList.to_new_string(&self, Allocator allocator = null) @dynamic
-{
-	return string::format("%s", *self, allocator: allocator ?: allocator::heap());
-}
-
-
-fn String AnyList.to_string(&self, Allocator allocator) @dynamic
-{
-	return string::format("%s", *self, allocator: allocator);
-}
-
-fn String AnyList.to_tstring(&self) => string::tformat("%s", *self);
-
-<*
- Push an element on the list by cloning it.
-*>
-macro void AnyList.push(&self, element)
-{
-	if (!self.allocator) self.allocator = allocator::heap();
-	self.append_internal(allocator::clone(self.allocator, element));
-}
-
-fn void AnyList.append_internal(&self, any element) @local
-{
-	self.ensure_capacity();
-	self.entries[self.size++] = element;
-}
-
-<*
- Free a retained element removed using *_retained.
-*>
-fn void AnyList.free_element(&self, any element) @inline
-{
-	allocator::free(self.allocator, element.ptr);
+	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.

- @return! CastResult.TYPE_MISMATCH, IteratorResult.NO_MORE_ELEMENT
-*>
-macro AnyList.pop(&self, $Type)
-{
-	if (!self.size) return IteratorResult.NO_MORE_ELEMENT?;
-	defer self.free_element(self.entries[self.size]);
-	return *anycast(self.entries[--self.size], $Type);
-}
-
-<*
- Pop the last value and allocate the copy using the given allocator.
- @return! IteratorResult.NO_MORE_ELEMENT
-*>
-fn any! AnyList.copy_pop(&self, Allocator allocator = allocator::heap())
-{
-	if (!self.size) return IteratorResult.NO_MORE_ELEMENT?;
-	defer self.free_element(self.entries[self.size]);
-	return allocator::clone_any(allocator, self.entries[--self.size]);
-}
-
-<*
- Pop the last value and allocate the copy using the given allocator.
- @return! IteratorResult.NO_MORE_ELEMENT
- @deprecated `use copy_pop`
-*>
-fn any! AnyList.new_pop(&self, Allocator allocator = allocator::heap())
-{
-	return self.copy_pop(allocator);
-}
-
-<*
- Pop the last value and allocate the copy using the temp allocator
- @return! IteratorResult.NO_MORE_ELEMENT
- @deprecated `use tcopy_pop`
-*>
-fn any! AnyList.temp_pop(&self) => self.copy_pop(allocator::temp());
-
-<*
- Pop the last value and allocate the copy using the temp allocator
- @return! IteratorResult.NO_MORE_ELEMENT
-*>
-fn any! AnyList.tcopy_pop(&self) => self.copy_pop(allocator::temp());
-
-<*
- Pop the last value. It must later be released using list.free_element()
- @return! IteratorResult.NO_MORE_ELEMENT
-*>
-fn any! AnyList.pop_retained(&self)
-{
-	if (!self.size) return IteratorResult.NO_MORE_ELEMENT?;
-	return self.entries[--self.size];
-}
-
-fn void AnyList.clear(&self)
-{
-	for (usz i = 0; i < self.size; i++)
-	{
-		self.free_element(self.entries[i]);
-	}
-	self.size = 0;
-}
-
-<*
- Same as pop() but pops the first value instead.
+ @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 IteratorResult.NO_MORE_ELEMENT?;
+	if (!self.size) return NO_MORE_ELEMENT?;
 	defer self.remove_at(0);
 	return *anycast(self.entries[0], $Type);
 }

 <*
- Same as pop_retained() but pops the first value instead.
-*>
-fn any! AnyList.pop_first_retained(&self)
-{
-	if (!self.size) return IteratorResult.NO_MORE_ELEMENT?;
-	defer self.remove_at(0);
-	return self.entries[0];
-}
+ Return an element in the list by value, assuming it is the given type.

-<*
- Same as new_pop() but pops the first value instead.
- @deprecated `use copy_pop_first`
-*>
-fn any! AnyList.new_pop_first(&self, Allocator allocator = allocator::heap())
-{
-	return self.copy_pop_first(allocator) @inline;
-}
-
-<*
- Same as new_pop() but pops the first value instead.
-*>
-fn any! AnyList.copy_pop_first(&self, Allocator allocator = allocator::heap())
-{
-	if (!self.size) return IteratorResult.NO_MORE_ELEMENT?;
-	defer self.free_element(self.entries[self.size]);
-	defer self.remove_at(0);
-	return allocator::clone_any(allocator, self.entries[0]);
-}
-
-<*
- Same as temp_pop() but pops the first value instead.
-*>
-fn any! AnyList.tcopy_pop_first(&self) => self.copy_pop_first(allocator::temp());
-
-<*
- Same as temp_pop() but pops the first value instead.
- @deprecated `use tcopy_pop_first`
-*>
-fn any! AnyList.temp_pop_first(&self) => self.new_pop_first(allocator::temp());
-
-<*
- @require index < self.size
-*>
-fn void AnyList.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];
-}
-
-fn void AnyList.add_all(&self, AnyList* other_list)
-{
-	if (!other_list.size) return;
-	self.reserve(other_list.size);
-	foreach (value : other_list)
-	{
-		self.entries[self.size++] = allocator::clone_any(self.allocator, value);
-	}
-}
-
-<*
- Reverse the elements in a list.
-*>
-fn void AnyList.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);
-	}
-}
-
-fn any[] AnyList.array_view(&self)
-{
-	return self.entries[:self.size];
-}
-
-<*
- Push an element to the front of the list.
-*>
-macro void AnyList.push_front(&self, type)
-{
-	self.insert_at(0, type);
-}
-
-<*
- @require index < self.size
-*>
-macro void AnyList.insert_at(&self, usz index, type) @local
-{
-	any value = allocator::copy(self.allocator, type);
-	self.insert_at_internal(self, index, value);
-}
-
-<*
- @require index < self.size
-*>
-fn void AnyList.insert_at_internal(&self, usz index, any value) @local
-{
-	self.ensure_capacity();
-	for (usz i = self.size; i > index; i--)
-	{
-		self.entries[i] = self.entries[i - 1];
-	}
-	self.size++;
-	self.entries[index] = value;
-}
-
-
-<*
- @require self.size > 0
-*>
-fn void AnyList.remove_last(&self)
-{
-	self.free_element(self.entries[--self.size]);
-}
-
-<*
- @require self.size > 0
-*>
-fn void AnyList.remove_first(&self)
-{
-	self.remove_at(0);
-}
-
-macro AnyList.first(&self, $Type)
-{
-	return *anycast(self.first_any(), $Type);
-}
-
-fn any! AnyList.first_any(&self) @inline
-{
-	return self.size ? self.entries[0] : IteratorResult.NO_MORE_ELEMENT?;
-}
-
-macro AnyList.last(&self, $Type)
-{
-	return *anycast(self.last_any(), $Type);
-}
-
-fn any! AnyList.last_any(&self) @inline
-{
-	return self.size ? self.entries[self.size - 1] : IteratorResult.NO_MORE_ELEMENT?;
-}
-
-fn bool AnyList.is_empty(&self) @inline
-{
-	return !self.size;
-}
-
-fn usz AnyList.len(&self) @operator(len) @inline
-{
-	return self.size;
-}
-
-<*
- @require index < self.size "Index out of range"
+ @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)
 {
@@ -367,148 +105,18 @@ macro AnyList.get(&self, usz index, $Type)
 }

 <*
- @require index < self.size "Index out of range"
+ 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
-{
-	return self.entries[index];
-}
-
-fn void AnyList.free(&self)
-{
-	if (!self.allocator) return;
-	self.clear();
-	allocator::free(self.allocator, self.entries);
-	self.capacity = 0;
-	self.entries = null;
-}
-
-fn void AnyList.swap(&self, usz i, usz j)
-{
-	any temp = self.entries[i];
-	self.entries[i] = self.entries[j];
-	self.entries[j] = temp;
-}
+fn any AnyList.get_any(&self, usz index) @inline @operator([]) => InterfaceList {any}.get(self, index);

 <*
- @param filter "The function to determine if it should be removed or not"
- @return "the number of deleted elements"
+ Return the length of the list.
+
+ @return "The number of elements in the list"
 *>
-fn usz AnyList.remove_if(&self, AnyPredicate filter)
-{
-	return self._remove_if(filter, false);
-}
-
-<*
- @param selection "The function to determine if it should be kept or not"
- @return "the number of deleted elements"
-*>
-fn usz AnyList.retain_if(&self, AnyPredicate selection)
-{
-	return self._remove_if(selection, true);
-}
-
-macro usz AnyList._remove_if(&self, AnyPredicate 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;
-}
-
-fn usz AnyList.remove_using_test(&self, AnyTest filter, any context)
-{
-	return self._remove_using_test(filter, false, context);
-}
-
-fn usz AnyList.retain_using_test(&self, AnyTest filter, any context)
-{
-	return self._remove_using_test(filter, true, context);
-}
-
-macro usz AnyList._remove_using_test(&self, AnyTest 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;
-}
-
-<*
- Reserve at least min_capacity
-*>
-fn void AnyList.reserve(&self, usz min_capacity)
-{
-	if (!min_capacity) return;
-	if (self.capacity >= min_capacity) return;
-	if (!self.allocator) self.allocator = allocator::heap();
-	min_capacity = math::next_power_of_2(min_capacity);
-	self.entries = allocator::realloc(self.allocator, self.entries, any.sizeof * min_capacity);
-	self.capacity = min_capacity;
-}
-
-macro any AnyList.@item_at(&self, usz index) @operator([])
-{
-	return self.entries[index];
-}
-
-<*
- @require index <= self.size "Index out of range"
-*>
-macro void AnyList.set(&self, usz index, value)
-{
-	if (index == self.size)
-	{
-		self.push(value);
-		return;
-	}
-	self.free_element(self.entries[index]);
-	self.entries[index] = allocator::copy(self.allocator, value);
-}
-
-fn void AnyList.ensure_capacity(&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 usz AnyList.len(&self) @operator(len) @inline => InterfaceList {any}.len(self);
--- a/lib/std/collections/bitset.c3
+++ b/lib/std/collections/bitset.c3
@@ -1,18 +1,22 @@
+// 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
+ @require SIZE > 0 : "The size of the bitset in bits must be at least 1"
 *>
-module std::collections::bitset(<SIZE>);
+module std::collections::bitset {SIZE};

-def Type = uint;
-
-const BITS = Type.sizeof * 8;
+const BITS = uint.sizeof * 8;
 const SZ = (SIZE + BITS - 1) / BITS;

 struct BitSet
 {
-	Type[SZ] data;
+	uint[SZ] data;
 }

+<*
+ @return "The number of bits set"
+*>
 fn usz BitSet.cardinality(&self)
 {
 	usz n;
@@ -24,7 +28,11 @@ fn usz BitSet.cardinality(&self)
 }

 <*
- @require i < SIZE
+ 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)
 {
@@ -34,7 +42,86 @@ fn void BitSet.set(&self, usz i)
 }

 <*
- @require i < SIZE
+ 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)
 {
@@ -44,7 +131,12 @@ fn void BitSet.unset(&self, usz i)
 }

 <*
- @require i < SIZE
+ 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
 {
@@ -53,13 +145,23 @@ fn bool BitSet.get(&self, usz i) @operator([]) @inline
 	return self.data[q] & (1 << r) != 0;
 }

+<*
+ Return the number of bits.
+
+ @pure
+*>
 fn usz BitSet.len(&self) @operator(len) @inline
 {
 	return SZ * BITS;
 }

 <*
- @require i < SIZE
+ 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
 {
@@ -70,12 +172,12 @@ fn void BitSet.set_bool(&self, usz i, bool value) @operator([]=) @inline
 <*
 @require Type.kindof == UNSIGNED_INT
 *>
-module std::collections::growablebitset(<Type>);
+module std::collections::growablebitset{Type};
 import std::collections::list;

 const BITS = Type.sizeof * 8;

-def GrowableBitSetList = List(<Type>);
+alias GrowableBitSetList = List{Type};

 struct GrowableBitSet
 {
@@ -84,17 +186,7 @@ struct GrowableBitSet

 <*
 @param initial_capacity
- @param [&inout] allocator "The allocator to use, defaults to the heap allocator"
-*>
-fn GrowableBitSet* GrowableBitSet.new_init(&self, usz initial_capacity = 1, Allocator allocator = allocator::heap()) @deprecated("Use init(mem)")
-{
-	self.data.init(allocator, initial_capacity);
-	return self;
-}
-
-<*
- @param initial_capacity
- @param [&inout] allocator "The allocator to use, defaults to the heap allocator"
+ @param [&inout] allocator : "The allocator to use, defaults to the heap allocator"
 *>
 fn GrowableBitSet* GrowableBitSet.init(&self, Allocator allocator, usz initial_capacity = 1)
 {
@@ -102,14 +194,9 @@ fn GrowableBitSet* GrowableBitSet.init(&self, Allocator allocator, usz initial_c
 	return self;
 }

-fn GrowableBitSet* GrowableBitSet.temp_init(&self, usz initial_capacity = 1) @deprecated("Use tinit()")
-{
-	return self.init(allocator::temp(), initial_capacity) @inline;
-}
-
 fn GrowableBitSet* GrowableBitSet.tinit(&self, usz initial_capacity = 1)
 {
-	return self.init(allocator::temp(), initial_capacity) @inline;
+	return self.init(tmem, initial_capacity) @inline;
 }

 fn void GrowableBitSet.free(&self)
--- a/lib/std/collections/elastic_array.c3
+++ b/lib/std/collections/elastic_array.c3
@@ -2,16 +2,16 @@
 // 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.`
+ @require MAX_SIZE >= 1 : `The size must be at least 1 element big.`
 *>
-module std::collections::elastic_array(<Type, MAX_SIZE>);
+module std::collections::elastic_array {Type, MAX_SIZE};
 import std::io, std::math, std::collections::list_common;

-def ElementPredicate = fn bool(Type *type);
-def ElementTest = fn bool(Type *type, any context);
+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 type_is_overaligned() => Type.alignof > mem::DEFAULT_MEM_ALIGNMENT;
+macro bool type_is_overaligned() => Type.alignof > mem::DEFAULT_MEM_ALIGNMENT;

 struct ElasticArray (Printable)
 {
@@ -19,7 +19,7 @@ struct ElasticArray (Printable)
 	Type[MAX_SIZE] entries;
 }

-fn usz! ElasticArray.to_format(&self, Formatter* formatter) @dynamic
+fn usz? ElasticArray.to_format(&self, Formatter* formatter) @dynamic
 {
 	switch (self.size)
 	{
@@ -39,38 +39,28 @@ fn usz! ElasticArray.to_format(&self, Formatter* formatter) @dynamic
 	}
 }

-fn String ElasticArray.to_string(&self, Allocator allocator) @dynamic
-{
-	return string::format("%s", *self, allocator: allocator);
-}
-
-fn String ElasticArray.to_new_string(&self, Allocator allocator = nul) @dynamic
-{
-	return string::format("%s", *self, allocator: allocator ?: allocator::heap());
-}
-
 fn String ElasticArray.to_tstring(&self)
 {
 	return string::tformat("%s", *self);
 }

-fn void! ElasticArray.push_try(&self, Type element) @inline
+fn void? ElasticArray.push_try(&self, Type element) @inline
 {
-	if (self.size == MAX_SIZE) return AllocationFailure.OUT_OF_MEMORY?;
+	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`
+ @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)
+fn Type? ElasticArray.pop(&self)
 {
-	if (!self.size) return IteratorResult.NO_MORE_ELEMENT?;
+	if (!self.size) return NO_MORE_ELEMENT?;
 	return self.entries[--self.size];
 }

@@ -82,9 +72,9 @@ fn void ElasticArray.clear(&self)
 <*
 @require self.size > 0
 *>
-fn Type! ElasticArray.pop_first(&self)
+fn Type? ElasticArray.pop_first(&self)
 {
-	if (!self.size) return IteratorResult.NO_MORE_ELEMENT?;
+	if (!self.size) return NO_MORE_ELEMENT?;
 	defer self.remove_at(0);
 	return self.entries[0];
 }
@@ -131,7 +121,24 @@ fn usz ElasticArray.add_all_to_limit(&self, ElasticArray* other_list)

 @param [in] array
 *>
-fn usz ElasticArray.add_array_to_limit(&self, Type[] 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)
@@ -146,10 +153,26 @@ fn usz ElasticArray.add_array_to_limit(&self, Type[] array)
 Add the values of an array to this list.

 @param [in] array
- @require array.len + self.size <= MAX_SIZE `Size would exceed max.`
+ @require array.len + self.size <= MAX_SIZE : `Size would exceed max.`
 @ensure self.size >= array.len
 *>
-fn void ElasticArray.add_array(&self, Type[] array)
+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)
@@ -159,29 +182,12 @@ fn void ElasticArray.add_array(&self, Type[] array)
 }


-
-<*
- IMPORTANT The returned array must be freed using free_aligned.
-*>
-fn Type[] ElasticArray.to_new_aligned_array(&self)
-{
-	return list_common::list_to_new_aligned_array(Type, self, allocator::heap());
-}
-
 <*
 IMPORTANT The returned array must be freed using free_aligned.
 *>
 fn Type[] ElasticArray.to_aligned_array(&self, Allocator allocator)
 {
-	return list_common::list_to_new_aligned_array(Type, self, allocator);
-}
-
-<*
- @require !type_is_overaligned() : "This function is not available on overaligned types"
-*>
-macro Type[] ElasticArray.to_new_array(&self)
-{
-	return list_common::list_to_array(Type, self, allocator::heap());
+	return list_common::list_to_aligned_array(Type, self, allocator);
 }

 <*
@@ -189,15 +195,15 @@ macro Type[] ElasticArray.to_new_array(&self)
 *>
 macro Type[] ElasticArray.to_array(&self, Allocator allocator)
 {
-	return list_common::list_to_new_array(Type, self, 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(allocator::temp());
+	return self.to_aligned_array(tmem);
 	$else
-	return self.to_array(allocator::temp());
+	return self.to_array(tmem);
 	$endif;
 }

@@ -215,7 +221,7 @@ fn Type[] ElasticArray.array_view(&self)
 }

 <*
- @require self.size < MAX_SIZE `List would exceed max size`
+ @require self.size < MAX_SIZE : `List would exceed max size`
 *>
 fn void ElasticArray.push_front(&self, Type type) @inline
 {
@@ -223,9 +229,9 @@ fn void ElasticArray.push_front(&self, Type type) @inline
 }

 <*
- @require self.size < MAX_SIZE `List would exceed max size`
+ @require self.size < MAX_SIZE : `List would exceed max size`
 *>
-fn void! ElasticArray.push_front_try(&self, Type type) @inline
+fn void? ElasticArray.push_front_try(&self, Type type) @inline
 {
 	return self.insert_at_try(0, type);
 }
@@ -233,14 +239,14 @@ fn void! ElasticArray.push_front_try(&self, Type type) @inline
 <*
 @require index <= self.size
 *>
-fn void! ElasticArray.insert_at_try(&self, usz index, Type value)
+fn void? ElasticArray.insert_at_try(&self, usz index, Type value)
 {
-	if (self.size == MAX_SIZE) return AllocationFailure.OUT_OF_MEMORY?;
+	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 self.size < MAX_SIZE : `List would exceed max size`
 @require index <= self.size
 *>
 fn void ElasticArray.insert_at(&self, usz index, Type type)
@@ -261,27 +267,27 @@ fn void ElasticArray.set_at(&self, usz index, Type type)
 	self.entries[index] = type;
 }

-fn void! ElasticArray.remove_last(&self) @maydiscard
+fn void? ElasticArray.remove_last(&self) @maydiscard
 {
-	if (!self.size) return IteratorResult.NO_MORE_ELEMENT?;
+	if (!self.size) return NO_MORE_ELEMENT?;
 	self.size--;
 }

-fn void! ElasticArray.remove_first(&self) @maydiscard
+fn void? ElasticArray.remove_first(&self) @maydiscard
 {
-	if (!self.size) return IteratorResult.NO_MORE_ELEMENT?;
+	if (!self.size) return NO_MORE_ELEMENT?;
 	self.remove_at(0);
 }

-fn Type! ElasticArray.first(&self)
+fn Type? ElasticArray.first(&self)
 {
-	if (!self.size) return IteratorResult.NO_MORE_ELEMENT?;
+	if (!self.size) return NO_MORE_ELEMENT?;
 	return self.entries[0];
 }

-fn Type! ElasticArray.last(&self)
+fn Type? ElasticArray.last(&self)
 {
-	if (!self.size) return IteratorResult.NO_MORE_ELEMENT?;
+	if (!self.size) return NO_MORE_ELEMENT?;
 	return self.entries[self.size - 1];
 }

@@ -311,7 +317,7 @@ fn void ElasticArray.swap(&self, usz i, usz j)
 }

 <*
- @param filter "The function to determine if it should be removed or not"
+ @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)
@@ -320,7 +326,7 @@ fn usz ElasticArray.remove_if(&self, ElementPredicate filter)
 }

 <*
- @param selection "The function to determine if it should be kept or not"
+ @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)
@@ -356,22 +362,22 @@ fn void ElasticArray.set(&self, usz index, Type value) @operator([]=)


 // Functions for equatable types
-fn usz! ElasticArray.index_of(&self, Type type) @if(ELEMENT_IS_EQUATABLE)
+fn usz? ElasticArray.index_of(&self, Type type) @if(ELEMENT_IS_EQUATABLE)
 {
 	foreach (i, v : self)
 	{
 		if (equals(v, type)) return i;
 	}
-	return SearchResult.MISSING?;
+	return NOT_FOUND?;
 }

-fn usz! ElasticArray.rindex_of(&self, Type type) @if(ELEMENT_IS_EQUATABLE)
+fn usz? ElasticArray.rindex_of(&self, Type type) @if(ELEMENT_IS_EQUATABLE)
 {
 	foreach_r (i, v : self)
 	{
 		if (equals(v, type)) return i;
 	}
-	return SearchResult.MISSING?;
+	return NOT_FOUND?;
 }

 fn bool ElasticArray.equals(&self, ElasticArray other_list) @if(ELEMENT_IS_EQUATABLE)
@@ -387,8 +393,8 @@ fn bool ElasticArray.equals(&self, ElasticArray other_list) @if(ELEMENT_IS_EQUAT
 <*
 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"
+ @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)
@@ -401,8 +407,8 @@ fn bool ElasticArray.contains(&self, Type value) @if(ELEMENT_IS_EQUATABLE)
 }

 <*
- @param [&inout] self "The list to remove elements from"
- @param value "The value to remove"
+ @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)
@@ -411,8 +417,8 @@ fn bool ElasticArray.remove_last_item(&self, Type value) @if(ELEMENT_IS_EQUATABL
 }

 <*
- @param [&inout] self "The list to remove elements from"
- @param value "The value to remove"
+ @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)
@@ -421,8 +427,8 @@ fn bool ElasticArray.remove_first_item(&self, Type value) @if(ELEMENT_IS_EQUATAB
 }

 <*
- @param [&inout] self "The list to remove elements from"
- @param value "The value to remove"
+ @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)
@@ -452,4 +458,4 @@ fn usz ElasticArray.compact_count(&self) @if(ELEMENT_IS_POINTER)
 fn usz ElasticArray.compact(&self) @if(ELEMENT_IS_POINTER)
 {
 	return list_common::list_compact(self);
-}
+}
--- a/lib/std/collections/enummap.c3
+++ b/lib/std/collections/enummap.c3
@@ -1,11 +1,12 @@
 <*
 @require Enum.kindof == TypeKind.ENUM : "Only enums may be used with an enummap"
 *>
-module std::collections::enummap(<Enum, ValueType>);
+module std::collections::enummap{Enum, ValueType};
 import std::io;
+
 struct EnumMap (Printable)
 {
-	ValueType[Enum.len] values;
+	ValueType[Enum.values.len] values;
 }

 fn void EnumMap.init(&self, ValueType init_value)
@@ -16,7 +17,7 @@ fn void EnumMap.init(&self, ValueType init_value)
 	}
 }

-fn usz! EnumMap.to_format(&self, Formatter* formatter) @dynamic
+fn usz? EnumMap.to_format(&self, Formatter* formatter) @dynamic
 {
 	usz n = formatter.print("{ ")!;
 	foreach (i, &value : self.values)
@@ -28,21 +29,6 @@ fn usz! EnumMap.to_format(&self, Formatter* formatter) @dynamic
 	return n;
 }

-fn String EnumMap.to_string(&self, Allocator allocator) @dynamic
-{
-	return string::format("%s", *self, allocator: allocator);
-}
-
-fn String EnumMap.to_new_string(&self, Allocator allocator = null) @dynamic
-{
-	return string::format("%s", *self, allocator: allocator ?: allocator::heap());
-}
-
-fn String EnumMap.to_tstring(&self) @dynamic
-{
-	return string::tformat("%s", *self);
-}
-
 <*
 @return "The total size of this map, which is the same as the number of enum values"
 @pure
--- a/lib/std/collections/enumset.c3
+++ b/lib/std/collections/enumset.c3
@@ -5,13 +5,14 @@
 <*
 @require Enum.kindof == TypeKind.ENUM : "Only enums may be used with an enumset"
 *>
-module std::collections::enumset(<Enum>);
+module std::collections::enumset{Enum};
 import std::io;

-def EnumSetType = $typefrom(private::type_for_enum_elements(Enum.elements)) @private;
+const ENUM_COUNT @private = Enum.values.len;
+alias EnumSetType @private = $typefrom(type_for_enum_elements(ENUM_COUNT));

-const IS_CHAR_ARRAY = Enum.elements > 128;
-distinct EnumSet (Printable) = EnumSetType;
+const IS_CHAR_ARRAY = ENUM_COUNT > 128;
+typedef EnumSet (Printable) = EnumSetType;

 fn void EnumSet.add(&self, Enum v)
 {
@@ -126,7 +127,7 @@ fn EnumSet EnumSet.xor_of(&self, EnumSet s)
 	$endif
 }

-fn usz! EnumSet.to_format(&set, Formatter* formatter) @dynamic
+fn usz? EnumSet.to_format(&set, Formatter* formatter) @dynamic
 {
 	usz n = formatter.print("[")!;
 	bool found;
@@ -141,26 +142,9 @@ fn usz! EnumSet.to_format(&set, Formatter* formatter) @dynamic
 	return n;
 }

-fn String EnumSet.to_new_string(&set, Allocator allocator = allocator::heap()) @dynamic
+macro typeid type_for_enum_elements(usz $elements) @local
 {
-	return string::format("%s", *set, allocator: allocator);
-}
-
-fn String EnumSet.to_string(&set, Allocator allocator) @dynamic
-{
-	return string::format("%s", *set, allocator: allocator);
-}
-
-fn String EnumSet.to_tstring(&set) @dynamic
-{
-	return string::tformat("%s", *set);
-}
-
-module std::collections::enumset::private;
-
-macro typeid type_for_enum_elements(usz $elements)
-{
-	$switch
+	$switch:
 		$case ($elements > 128):
 			return char[($elements + 7) / 8].typeid;
 		$case ($elements > 64):
--- a/lib/std/collections/hashmap.c3
+++ b/lib/std/collections/hashmap.c3
@@ -2,39 +2,48 @@
 // 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`
+ @require $defined((Key){}.hash()) : `No .hash function found on the key`
 *>
-module std::collections::map(<Key, Value>);
+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;
-	uint count; // Number of elements
-	uint threshold; // Resize limit
+	<* 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.allocator "Map was already initialized"
- @require capacity < MAXIMUM_CAPACITY "Capacity cannot exceed maximum"
-*>
-fn HashMap* HashMap.new_init(&self, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR, Allocator allocator = null) @deprecated("Use init(mem)")
-{
-	return self.init(allocator ?: allocator::heap(), capacity, 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.allocator "Map was already initialized"
- @require capacity < MAXIMUM_CAPACITY "Capacity cannot exceed maximum"
+ @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)
 {
@@ -47,55 +56,56 @@ fn HashMap* HashMap.init(&self, Allocator allocator, uint capacity = DEFAULT_INI
 }

 <*
- @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.allocator "Map was already initialized"
- @require capacity < MAXIMUM_CAPACITY "Capacity cannot exceed maximum"
-*>
-fn HashMap* HashMap.temp_init(&self, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR) @deprecated("Use tinit()")
-{
-	return self.init(allocator::temp(), capacity, load_factor) @inline;
-}
-
-<*
- @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.allocator "Map was already initialized"
- @require capacity < MAXIMUM_CAPACITY "Capacity cannot exceed maximum"
+ @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(allocator::temp(), capacity, load_factor) @inline;
+	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.allocator "Map was already initialized"
- @require capacity < MAXIMUM_CAPACITY "Capacity cannot exceed maximum"
+ @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.new_init_with_key_values(&self, ..., uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR, Allocator allocator = allocator::heap()) @deprecated("Use init_with_key_values(mem)")
+macro HashMap* HashMap.init_with_key_values(&self, Allocator allocator, ..., uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
 {
-	self.init(capacity, load_factor, allocator);
-	$for (var $i = 0; $i < $vacount; $i += 2)
-		self.set($vaarg[$i], $vaarg[$i+1]);
+	self.init(allocator, capacity, load_factor);
+	$for var $i = 0; $i < $vacount; $i += 2:
+		self.set($vaarg[$i], $vaarg[$i + 1]);
 	$endfor
 	return self;
 }

 <*
- @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.allocator "Map was already initialized"
- @require capacity < MAXIMUM_CAPACITY "Capacity cannot exceed maximum"
+ @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"
 *>
-fn HashMap* HashMap.new_init_from_keys_and_values(&self, Key[] keys, Value[] values, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR, Allocator allocator = allocator::heap()) @deprecated("Use init_from_keys_and_values(mem)")
+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);
@@ -106,102 +116,36 @@ fn HashMap* HashMap.new_init_from_keys_and_values(&self, Key[] keys, Value[] val
 	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.allocator "Map was already initialized"
- @require capacity < MAXIMUM_CAPACITY "Capacity cannot exceed maximum"
-*>
-macro HashMap* HashMap.temp_init_with_key_values(&self, ..., uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR) @deprecated("Use tinit_with_key_values")
-{
-	self.tinit(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.allocator "Map was already initialized"
- @require capacity < MAXIMUM_CAPACITY "Capacity cannot exceed maximum"
+ @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"
 *>
-macro HashMap* HashMap.tinit_with_key_values(&self, ..., uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
+fn HashMap* HashMap.tinit_from_keys_and_values(&self, Key[] keys, Value[] values, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
 {
-	self.tinit(capacity, load_factor);
-	$for (var $i = 0; $i < $vacount; $i += 2)
-		self.set($vaarg[$i], $vaarg[$i+1]);
-	$endfor
-	return self;
-}
-
-<*
- @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.allocator "Map was already initialized"
- @require capacity < MAXIMUM_CAPACITY "Capacity cannot exceed maximum"
-*>
-fn HashMap* HashMap.temp_init_from_keys_and_values(&self, Key[] keys, Value[] values, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR, Allocator allocator = allocator::heap()) @deprecated("Use tinit_from_keys_and_values")
-{
-	assert(keys.len == values.len);
-	self.tinit(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"
- @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.allocator "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, Allocator allocator = allocator::heap())
-{
-	assert(keys.len == values.len);
-	self.tinit(capacity, load_factor);
-	for (usz i = 0; i < keys.len; i++)
-	{
-		self.set(keys[i], values[i]);
-	}
-	return self;
+	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"
+ @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 (bool)map.allocator;
+	return map.allocator && map.allocator.ptr != &dummy;
 }

 <*
- @param [&in] other_map "The map to copy from."
-*>
-fn HashMap* HashMap.new_init_from_map(&self, HashMap* other_map) @deprecated("Use init_from_map(mem, map)")
-{
-	return self.init_from_map(allocator::heap(), other_map) @inline;
-}
-
-<*
- @param [&inout] allocator "The allocator to use"
- @param [&in] other_map "The map to copy from."
+ @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)
 {
@@ -211,19 +155,12 @@ fn HashMap* HashMap.init_from_map(&self, Allocator allocator, HashMap* other_map
 }

 <*
- @param [&in] other_map "The map to copy from."
-*>
-fn HashMap* HashMap.temp_init_from_map(&map, HashMap* other_map) @deprecated("Use tinit_from_map")
-{
-	return map.init_from_map(allocator::temp(), other_map) @inline;
-}
-
-<*
- @param [&in] other_map "The map to copy from."
+ @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(allocator::temp(), other_map) @inline;
+	return map.init_from_map(tmem, other_map) @inline;
 }

 fn bool HashMap.is_empty(&map) @inline
@@ -236,31 +173,50 @@ fn usz HashMap.len(&map) @inline
 	return map.count;
 }

-fn Value*! HashMap.get_ref(&map, Key key)
+fn Value*? HashMap.get_ref(&map, Key key)
 {
-	if (!map.count) return SearchResult.MISSING?;
+	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 SearchResult.MISSING?;
+	return NOT_FOUND?;
 }

-fn Entry*! HashMap.get_entry(&map, Key key)
+fn Value* HashMap.get_or_create_ref(&map, Key key) @operator(&[])
 {
-	if (!map.count) return SearchResult.MISSING?;
+	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 SearchResult.MISSING?;
+	return NOT_FOUND?;
 }

 <*
- Get the value or update and
- @require $assignable(#expr, Value)
+ 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)
 {
@@ -281,7 +237,7 @@ macro Value HashMap.@get_or_set(&map, Key key, Value #expr)
 	return val;
 }

-fn Value! HashMap.get(&map, Key key) @operator([])
+fn Value? HashMap.get(&map, Key key) @operator([])
 {
 	return *map.get_ref(key) @inline;
 }
@@ -294,9 +250,14 @@ fn bool HashMap.has_key(&map, Key key)
 fn bool HashMap.set(&map, Key key, Value value) @operator([]=)
 {
 	// If the map isn't initialized, use the defaults to initialize it.
-	if (!map.allocator)
+	switch (map.allocator.ptr)
 	{
-		map.init(allocator::heap());
+		case &dummy:
+			map.init(mem);
+		case null:
+			map.tinit();
+		default:
+			break;
 	}
 	uint hash = rehash(key.hash());
 	uint index = index_for(hash, map.table.len);
@@ -312,9 +273,9 @@ fn bool HashMap.set(&map, Key key, Value value) @operator([]=)
 	return false;
 }

-fn void! HashMap.remove(&map, Key key) @maydiscard
+fn void? HashMap.remove(&map, Key key) @maydiscard
 {
-	if (!map.remove_entry_for_key(key)) return SearchResult.MISSING?;
+	if (!map.remove_entry_for_key(key)) return NOT_FOUND?;
 }

 fn void HashMap.clear(&map)
@@ -339,37 +300,24 @@ fn void HashMap.clear(&map)

 fn void HashMap.free(&map)
 {
-	if (!map.allocator) return;
+	if (!map.is_initialized()) return;
 	map.clear();
 	map.free_internal(map.table.ptr);
 	map.table = {};
 }

-fn Key[] HashMap.tcopy_keys(&map)
+fn Key[] HashMap.tkeys(&self)
 {
-	return map.copy_keys(allocator::temp()) @inline;
+	return self.keys(tmem) @inline;
 }

-fn Key[] HashMap.key_tlist(&map) @deprecated("Use 'tcopy_keys'")
+fn Key[] HashMap.keys(&self, Allocator allocator)
 {
-	return map.copy_keys(allocator::temp()) @inline;
-}
+	if (!self.count) return {};

-<*
- @deprecated "use copy_keys"
-*>
-fn Key[] HashMap.key_new_list(&map, Allocator allocator = allocator::heap())
-{
-	return map.copy_keys(allocator) @inline;
-}
-
-fn Key[] HashMap.copy_keys(&map, Allocator allocator = allocator::heap())
-{
-	if (!map.count) return {};
-
-	Key[] list = allocator::alloc_array(allocator, Key, map.count);
+	Key[] list = allocator::alloc_array(allocator, Key, self.count);
 	usz index = 0;
-	foreach (Entry* entry : map.table)
+	foreach (Entry* entry : self.table)
 	{
 		while (entry)
 		{
@@ -386,53 +334,33 @@ fn Key[] HashMap.copy_keys(&map, Allocator allocator = allocator::heap())

 macro HashMap.@each(map; @body(key, value))
 {
-	map.@each_entry(; Entry* entry) {
+	map.@each_entry(; Entry* entry)
+	{
 		@body(entry.key, entry.value);
 	};
 }

 macro HashMap.@each_entry(map; @body(entry))
 {
-	if (map.count)
+	if (!map.count) return;
+	foreach (Entry* entry : map.table)
 	{
-		foreach (Entry* entry : map.table)
+		while (entry)
 		{
-			while (entry)
-			{
-				@body(entry);
-				entry = entry.next;
-			}
+			@body(entry);
+			entry = entry.next;
 		}
 	}
 }

-<*
- @deprecated `use tcopy_values`
-*>
-fn Value[] HashMap.value_tlist(&map)
-{
-	return map.copy_values(allocator::temp()) @inline;
-}
+fn Value[] HashMap.tvalues(&self) => self.values(tmem) @inline;

-fn Value[] HashMap.tcopy_values(&map)
+fn Value[] HashMap.values(&self, Allocator allocator)
 {
-	return map.copy_values(allocator::temp()) @inline;
-}
-
-<*
- @deprecated `use copy_values`
-*>
-fn Value[] HashMap.value_new_list(&map, Allocator allocator = allocator::heap())
-{
-	return map.copy_values(allocator);
-}
-
-fn Value[] HashMap.copy_values(&map, Allocator allocator = allocator::heap())
-{
-	if (!map.count) return {};
-	Value[] list = allocator::alloc_array(allocator, Value, map.count);
+	if (!self.count) return {};
+	Value[] list = allocator::alloc_array(allocator, Value, self.count);
 	usz index = 0;
-	foreach (Entry* entry : map.table)
+	foreach (Entry* entry : self.table)
 	{
 		while (entry)
 		{
@@ -503,7 +431,7 @@ fn void HashMap.resize(&map, uint new_capacity) @private
 	map.threshold = (uint)(new_capacity * map.load_factor);
 }

-fn usz! HashMap.to_format(&self, Formatter* f) @dynamic
+fn usz? HashMap.to_format(&self, Formatter* f) @dynamic
 {
 	usz len;
 	len += f.print("{ ")!;
@@ -511,7 +439,7 @@ fn usz! HashMap.to_format(&self, Formatter* f) @dynamic
 	{
 		if (len > 2) len += f.print(", ")!;
 		len += f.printf("%s: %s", entry.key, entry.value)!;
-    };
+	};
 	return len + f.print(" }");
 }

@@ -625,8 +553,8 @@ struct HashMapIterator
 	Entry* current_entry;
 }

-distinct HashMapValueIterator = HashMapIterator;
-distinct HashMapKeyIterator = HashMapIterator;
+typedef HashMapValueIterator = HashMapIterator;
+typedef HashMapKeyIterator = HashMapIterator;


 <*
@@ -667,3 +595,16 @@ fn Key HashMapKeyIterator.get(&self, usz idx) @operator([])
 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;
--- a/lib/std/collections/hashset.c3
+++ b/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 int HashSet.len(&self) @operator(len) => (int) 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);
+	self.put_all_for_create(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;
+	}
+	set.add_entry(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 (!set.remove_entry_for_value(value)) return NOT_FOUND?;
+}
+
+fn usz HashSet.remove_all(&set, Value[] values)
+{
+	usz total;
+	foreach (v : values)
+	{
+		if (set.remove_entry_for_value(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 (set.remove_entry_for_value(val)) total++;
+    };
+    return total;
+}
+
+<*
+ Free all memory allocated by the hash set.
+*>
+fn void HashSet.free(&set)
+{
+	if (!set.is_initialized()) return;
+	set.clear();
+	set.free_internal(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;
+			set.free_entry(to_delete);
+		}
+
+		set.free_entry(entry);
+		*entry_ref = null;
+	}
+	set.count = 0;
+}
+
+fn void HashSet.reserve(&set, usz capacity)
+{
+	if (capacity > set.threshold)
+	{
+		set.resize(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(&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)
+	{
+		set.resize(set.table.len * 2);
+	}
+}
+
+fn void HashSet.resize(&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);
+	self.transfer(new_table);
+	self.table = new_table;
+	self.free_internal(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(&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(&set, HashSet* other_set) @private
+{
+	if (!other_set.count) return;
+	foreach (Entry *e : other_set.table)
+	{
+		while (e)
+		{
+			set.put_for_create(e.value);
+			e = e.next;
+		}
+	}
+}
+
+fn void HashSet.put_for_create(&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;
+		}
+	}
+	set.create_entry(hash, value, i);
+}
+
+fn void HashSet.free_internal(&self, void* ptr) @inline @private
+{
+	allocator::free(self.allocator, ptr);
+}
+
+fn void HashSet.create_entry(&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(&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;
+			}
+			set.free_entry(e);
+			return true;
+		}
+		prev = e;
+		e = next;
+	}
+
+	return false;
+}
+
+fn void HashSet.free_entry(&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;
--- a/lib/std/collections/interfacelist.c3
+++ b/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;
+	self._append(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 self._remove_if(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 self._remove_if(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 self._remove_using_test(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 self._remove_using_test(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(&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(&self, Type element) @local
+{
+	self.ensure_capacity();
+	self.entries[self.size++] = element;
+}
+
+<*
+ @require index < self.size
+*>
+fn void InterfaceList._insert_at(&self, usz index, Type value) @local
+{
+	self.ensure_capacity();
+	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(&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(&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;
+}
--- a/lib/std/collections/linked_blockingqueue.c3
+++ b/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;
+		}
+	};
+
+	(void)self.lock.destroy();
+	(void)self.not_empty.destroy();
+	(void)self.not_full.destroy();
+}
+
+fn void LinkedBlockingQueue.link_entry(&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(&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
+		});
+		self.link_entry(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 = self.unlink_head();
+		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 = self.unlink_head();
+		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 = self.unlink_head();
+		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
+		});
+		self.link_entry(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
+		});
+		self.link_entry(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;
+}
--- a/lib/std/collections/linked_hashmap.c3
+++ b/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);
+	self.put_all_for_create(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;
+		}
+	}
+	map.add_entry(hash, key, value, index);
+	return false;
+}
+
+fn void? LinkedHashMap.remove(&map, Key key) @maydiscard
+{
+	if (!map.remove_entry_for_key(key)) return NOT_FOUND?;
+}
+
+fn void LinkedHashMap.clear(&map)
+{
+	if (!map.count) return;
+
+	LinkedEntry* entry = map.head;
+	while (entry)
+	{
+		LinkedEntry* next = entry.after;
+		map.free_entry(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();
+	map.free_internal(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(&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)
+	{
+		map.resize(map.table.len * 2);
+	}
+}
+
+fn void LinkedHashMap.resize(&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;
+		}
+	}
+
+	map.free_internal(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(&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(&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(&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;
+		}
+	}
+	map.create_entry(hash, key, value, i);
+}
+
+fn void LinkedHashMap.free_internal(&map, void* ptr) @inline @private
+{
+	allocator::free(map.allocator, ptr);
+}
+
+fn bool LinkedHashMap.remove_entry_for_key(&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--;
+			map.free_entry(e);
+			return true;
+		}
+		prev = e;
+		e = e.next;
+	}
+	return false;
+}
+
+fn void LinkedHashMap.create_entry(&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(&self, LinkedEntry *entry) @local
+{
+	$if COPY_KEYS:
+	allocator::free(self.allocator, entry.key);
+	$endif
+	self.free_internal(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;
--- a/lib/std/collections/linked_hashset.c3
+++ b/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 int LinkedHashSet.len(&self) @operator(len) => (int) 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
+	{
+		self.put_for_create(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;
+	}
+	set.add_entry(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 (!set.remove_entry_for_value(value)) return NOT_FOUND?;
+}
+
+fn usz LinkedHashSet.remove_all(&set, Value[] values)
+{
+	usz total;
+	foreach (v : values)
+	{
+		if (set.remove_entry_for_value(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 (set.remove_entry_for_value(val)) total++;
+    };
+    return total;
+}
+
+<*
+ Free all memory allocated by the hash set.
+*>
+fn void LinkedHashSet.free(&set)
+{
+	if (!set.is_initialized()) return;
+	set.clear();
+	set.free_internal(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;
+		set.free_entry(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)
+	{
+		set.resize(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(&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)
+	{
+		set.resize(set.table.len * 2);
+	}
+}
+
+fn void LinkedHashSet.resize(&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;
+		}
+	}
+
+	set.free_internal(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 LinkedHashSet.transfer(&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(&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;
+		}
+	}
+	set.create_entry(hash, value, i);
+}
+
+fn void LinkedHashSet.free_internal(&set, void* ptr) @inline @private
+{
+	allocator::free(set.allocator, ptr);
+}
+
+fn void LinkedHashSet.create_entry(&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(&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--;
+			set.free_entry(e);
+			return true;
+		}
+		prev = e;
+		e = e.next;
+	}
+	return false;
+}
+
+fn void LinkedHashSet.free_entry(&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;
--- a/lib/std/collections/linkedlist.c3
+++ b/lib/std/collections/linkedlist.c3
@@ -1,14 +1,15 @@
 // 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>);
+module std::collections::linkedlist{Type};
+import std::io;

 const ELEMENT_IS_EQUATABLE = types::is_equatable_type(Type);

-struct Node @private
+struct Node
 {
-	Node *next;
-	Node *prev;
+	Node* next;
+	Node* prev;
 	Type value;
 }

@@ -16,12 +17,35 @@ struct LinkedList
 {
 	Allocator allocator;
 	usz size;
-	Node *_first;
-	Node *_last;
+	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.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"
+ @param [&inout] allocator : "The allocator to use, defaults to the heap allocator"
 @return "the initialized list"
 *>
 fn LinkedList* LinkedList.init(&self, Allocator allocator)
@@ -30,27 +54,15 @@ fn LinkedList* LinkedList.init(&self, Allocator allocator)
 	return self;
 }

-<*
- @return "the initialized list"
-*>
-fn LinkedList* LinkedList.new_init(&self) @deprecated("Use init(mem)")
-{
-	return self.init(allocator::heap()) @inline;
-}
-
-
-fn LinkedList* LinkedList.temp_init(&self) @deprecated("Use tinit()")
-{
-	return self.init(allocator::temp()) @inline;
-}
-
 fn LinkedList* LinkedList.tinit(&self)
 {
-	return self.init(allocator::temp()) @inline;
+	return self.init(tmem) @inline;
 }

+fn bool LinkedList.is_initialized(&self) @inline => self.allocator != null;
+
 <*
- @require self.allocator != null
+ @require self.is_initialized()
 *>
 macro void LinkedList.free_node(&self, Node* node) @private
 {
@@ -59,7 +71,7 @@ macro void LinkedList.free_node(&self, Node* node) @private

 macro Node* LinkedList.alloc_node(&self) @private
 {
-	if (!self.allocator) self.allocator = allocator::heap();
+	if (!self.allocator) self.allocator = tmem;
 	return allocator::alloc(self.allocator, Node);
 }

@@ -80,6 +92,11 @@ fn void LinkedList.push_front(&self, Type value)
 	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;
@@ -97,18 +114,23 @@ fn void LinkedList.push(&self, Type value)
 	self.size++;
 }

-fn Type! LinkedList.peek(&self) => self.first() @inline;
-fn Type! LinkedList.peek_last(&self) => self.last() @inline;
-
-fn Type! LinkedList.first(&self)
+fn void LinkedList.push_all(&self, Type[] value)
 {
-	if (!self._first) return IteratorResult.NO_MORE_ELEMENT?;
+	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)
+fn Type? LinkedList.last(&self)
 {
-	if (!self._last) return IteratorResult.NO_MORE_ELEMENT?;
+	if (!self._last) return NO_MORE_ELEMENT?;
 	return self._last.value;
 }

@@ -145,6 +167,7 @@ macro Node* LinkedList.node_at_index(&self, usz index)
 	while (index--) node = node.next;
 	return node;
 }
+
 <*
 @require index < self.size
 *>
@@ -153,6 +176,14 @@ 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
 *>
@@ -161,6 +192,26 @@ 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
 *>
@@ -243,9 +294,9 @@ fn usz LinkedList.remove(&self, Type t) @if(ELEMENT_IS_EQUATABLE)
 	return start - self.size;
 }

-fn Type! LinkedList.pop(&self)
+fn Type? LinkedList.pop(&self)
 {
-	if (!self._last) return IteratorResult.NO_MORE_ELEMENT?;
+	if (!self._last) return NO_MORE_ELEMENT?;
 	defer self.unlink_last();
 	return self._last.value;
 }
@@ -255,22 +306,22 @@ fn bool LinkedList.is_empty(&self)
 	return !self._first;
 }

-fn Type! LinkedList.pop_front(&self)
+fn Type? LinkedList.pop_front(&self)
 {
-	if (!self._first) return IteratorResult.NO_MORE_ELEMENT?;
+	if (!self._first) return NO_MORE_ELEMENT?;
 	defer self.unlink_first();
 	return self._first.value;
 }

-fn void! LinkedList.remove_last(&self) @maydiscard
+fn void? LinkedList.remove_last(&self) @maydiscard
 {
-	if (!self._first) return IteratorResult.NO_MORE_ELEMENT?;
+	if (!self._first) return NO_MORE_ELEMENT?;
 	self.unlink_last();
 }

-fn void! LinkedList.remove_first(&self) @maydiscard
+fn void? LinkedList.remove_first(&self) @maydiscard
 {
-	if (!self._first) return IteratorResult.NO_MORE_ELEMENT?;
+	if (!self._first) return NO_MORE_ELEMENT?;
 	self.unlink_first();
 }

@@ -346,3 +397,69 @@ fn void LinkedList.unlink(&self, Node* x) @private
 	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;
+}
--- a/lib/std/collections/list.c3
+++ b/lib/std/collections/list.c3
@@ -1,15 +1,19 @@
 // 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>);
+module std::collections::list{Type};
 import std::io, std::math, std::collections::list_common;

-def ElementPredicate = fn bool(Type *type);
-def ElementTest = fn bool(Type *type, any context);
+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 type_is_overaligned() => Type.alignof > mem::DEFAULT_MEM_ALIGNMENT;
+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)
 {
@@ -20,8 +24,8 @@ struct List (Printable)
 }

 <*
- @param initial_capacity "The initial capacity to reserve"
- @param [&inout] allocator "The allocator to use, defaults to the heap allocator"
+ @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)
 {
@@ -33,94 +37,47 @@ fn List* List.init(&self, Allocator allocator, usz initial_capacity = 16)
 	return self;
 }

-<*
- @param initial_capacity "The initial capacity to reserve"
- @param [&inout] allocator "The allocator to use, defaults to the heap allocator"
-*>
-fn List* List.new_init(&self, usz initial_capacity = 16, Allocator allocator = allocator::heap()) @deprecated("Use init(mem)")
-{
-	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.temp_init(&self, usz initial_capacity = 16) @deprecated("Use tinit()")
-{
-	return self.init(allocator::temp(), initial_capacity) @inline;
-}
-
-<*
- Initialize the list using the temp allocator.
-
- @param initial_capacity "The initial capacity to reserve"
+ @param initial_capacity : "The initial capacity to reserve"
 *>
 fn List* List.tinit(&self, usz initial_capacity = 16)
 {
-	return self.init(allocator::temp(), initial_capacity) @inline;
+	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.new_init_with_array(&self, Type[] values, Allocator allocator = allocator::heap()) @deprecated("Use init_with_array(mem)")
-{
-	return self.init_with_array(allocator, values);
-}
-
-<*
- 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"
+ @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.add_array(values) @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.temp_init_with_array(&self, Type[] values) @deprecated("Use tinit_with_array()")
-{
-	self.tinit(values.len) @inline;
-	self.add_array(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"
+ @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.add_array(values) @inline;
+	self.push_all(values) @inline;
 	return self;
 }

 <*
- @require self.capacity == 0 "The List must not be allocated"
+ @require !self.is_initialized() : "The List must not be allocated"
 *>
-fn void List.init_wrapping_array(&self, Type[] types, Allocator allocator = allocator::heap())
+fn void List.init_wrapping_array(&self, Allocator allocator, Type[] types)
 {
 	self.allocator = allocator;
 	self.capacity = types.len;
@@ -128,7 +85,9 @@ fn void List.init_wrapping_array(&self, Type[] types, Allocator allocator = allo
 	self.set_size(types.len);
 }

-fn usz! List.to_format(&self, Formatter* formatter) @dynamic
+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)
 	{
@@ -148,25 +107,15 @@ fn usz! List.to_format(&self, Formatter* formatter) @dynamic
 	}
 }

-fn String List.to_new_string(&self, Allocator allocator = allocator::heap()) @dynamic
-{
-	return string::format("%s", *self, allocator: allocator);
-}
-
-fn String List.to_tstring(&self)
-{
-	return string::tformat("%s", *self);
-}
-
 fn void List.push(&self, Type element) @inline
 {
 	self.reserve(1);
 	self.entries[self.set_size(self.size + 1)] = element;
 }

-fn Type! List.pop(&self)
+fn Type? List.pop(&self)
 {
-	if (!self.size) return IteratorResult.NO_MORE_ELEMENT?;
+	if (!self.size) return NO_MORE_ELEMENT?;
 	defer self.set_size(self.size - 1);
 	return self.entries[self.size - 1];
 }
@@ -176,21 +125,22 @@ fn void List.clear(&self)
 	self.set_size(0);
 }

-fn Type! List.pop_first(&self)
+fn Type? List.pop_first(&self)
 {
-	if (!self.size) return IteratorResult.NO_MORE_ELEMENT?;
+	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`
+ @require index < self.size : `Removed element out of bounds`
 *>
 fn void List.remove_at(&self, usz index)
 {
-	self.set_size(self.size - 1);
-	if (!self.size || index == self.size) return;
-	self.entries[index .. self.size - 1] = self.entries[index + 1 .. self.size];
+	usz new_size = self.size - 1;
+	defer self.set_size(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)
@@ -208,25 +158,25 @@ fn void List.add_all(&self, List* other_list)
 <*
 IMPORTANT The returned array must be freed using free_aligned.
 *>
-fn Type[] List.to_new_aligned_array(&self, Allocator allocator = allocator::heap())
+fn Type[] List.to_aligned_array(&self, Allocator allocator)
 {
-	return list_common::list_to_new_aligned_array(Type, self, 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_new_array(&self, Allocator allocator = allocator::heap())
+macro Type[] List.to_array(&self, Allocator allocator)
 {
-	return list_common::list_to_new_array(Type, self, allocator);
+	return list_common::list_to_array(Type, self, allocator);
 }

 fn Type[] List.to_tarray(&self)
 {
 	$if type_is_overaligned():
-	return self.to_new_aligned_array(allocator::temp());
+	return self.to_aligned_array(tmem);
 	$else
-	return self.to_new_array(allocator::temp());
+	return self.to_array(tmem);
 	$endif;
 }

@@ -249,7 +199,21 @@ fn Type[] List.array_view(&self)
 @param [in] array
 @ensure self.size >= array.len
 *>
-fn void List.add_array(&self, Type[] array)
+fn void List.add_array(&self, Type[] array) @deprecated("Use push_all")
+{
+	if (!array.len) return;
+	self.reserve(array.len);
+	usz index = self.set_size(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);
@@ -263,7 +227,7 @@ fn void List.push_front(&self, Type type) @inline
 }

 <*
- @require index <= self.size `Insert was out of bounds`
+ @require index <= self.size : `Insert was out of bounds`
 *>
 fn void List.insert_at(&self, usz index, Type type)
 {
@@ -284,27 +248,27 @@ fn void List.set_at(&self, usz index, Type type)
 	self.entries[index] = type;
 }

-fn void! List.remove_last(&self) @maydiscard
+fn void? List.remove_last(&self) @maydiscard
 {
-	if (!self.size) return IteratorResult.NO_MORE_ELEMENT?;
+	if (!self.size) return NO_MORE_ELEMENT?;
 	self.set_size(self.size - 1);
 }

-fn void! List.remove_first(&self) @maydiscard
+fn void? List.remove_first(&self) @maydiscard
 {
-	if (!self.size) return IteratorResult.NO_MORE_ELEMENT?;
+	if (!self.size) return NO_MORE_ELEMENT?;
 	self.remove_at(0);
 }

-fn Type! List.first(&self)
+fn Type? List.first(&self)
 {
-	if (!self.size) return IteratorResult.NO_MORE_ELEMENT?;
+	if (!self.size) return NO_MORE_ELEMENT?;
 	return self.entries[0];
 }

-fn Type! List.last(&self)
+fn Type? List.last(&self)
 {
-	if (!self.size) return IteratorResult.NO_MORE_ELEMENT?;
+	if (!self.size) return NO_MORE_ELEMENT?;
 	return self.entries[self.size - 1];
 }

@@ -324,7 +288,7 @@ fn usz List.len(&self) @operator(len) @inline
 }

 <*
- @require index < self.size `Access out of bounds`
+ @require index < self.size : `Access out of bounds`
 *>
 fn Type List.get(&self, usz index) @inline
 {
@@ -333,7 +297,7 @@ fn Type List.get(&self, usz index) @inline

 fn void List.free(&self)
 {
-	if (!self.allocator || !self.capacity) return;
+	if (!self.allocator || self.allocator.ptr == &dummy || !self.capacity) return;

 	self.pre_free(); // Remove sanitizer annotation

@@ -348,7 +312,7 @@ fn void List.free(&self)
 }

 <*
- @require i < self.size && j < self.size `Access out of bounds`
+ @require i < self.size && j < self.size : `Access out of bounds`
 *>
 fn void List.swap(&self, usz i, usz j)
 {
@@ -356,7 +320,7 @@ fn void List.swap(&self, usz i, usz j)
 }

 <*
- @param filter "The function to determine if it should be removed or not"
+ @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)
@@ -365,7 +329,7 @@ fn usz List.remove_if(&self, ElementPredicate filter)
 }

 <*
- @param selection "The function to determine if it should be kept or not"
+ @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)
@@ -398,7 +362,17 @@ fn void List.ensure_capacity(&self, usz min_capacity) @local
 {
 	if (!min_capacity) return;
 	if (self.capacity >= min_capacity) return;
-	if (!self.allocator) self.allocator = allocator::heap();
+
+	// Get a proper allocator
+	switch (self.allocator.ptr)
+	{
+		case &dummy:
+			self.allocator = mem;
+		case null:
+			self.allocator = tmem;
+		default:
+			break;
+	}

 	self.pre_free(); // Remove sanitizer annotation

@@ -414,7 +388,7 @@ fn void List.ensure_capacity(&self, usz min_capacity) @local
 }

 <*
- @require index < self.size `Access out of bounds`
+ @require index < self.size : `Access out of bounds`
 *>
 macro Type List.@item_at(&self, usz index) @operator([])
 {
@@ -422,7 +396,7 @@ macro Type List.@item_at(&self, usz index) @operator([])
 }

 <*
- @require index < self.size `Access out of bounds`
+ @require index < self.size : `Access out of bounds`
 *>
 fn Type* List.get_ref(&self, usz index) @operator(&[]) @inline
 {
@@ -430,7 +404,7 @@ fn Type* List.get_ref(&self, usz index) @operator(&[]) @inline
 }

 <*
- @require index < self.size `Access out of bounds`
+ @require index < self.size : `Access out of bounds`
 *>
 fn void List.set(&self, usz index, Type value) @operator([]=)
 {
@@ -451,10 +425,13 @@ fn void List.reserve(&self, usz added)
 fn void List._update_size_change(&self,usz old_size, usz new_size)
 {
 	if (old_size == new_size) return;
-	sanitizer::annotate_contiguous_container(self.entries,
+	$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
@@ -484,22 +461,22 @@ macro void List.post_alloc(&self) @private
 // Functions for equatable types


-fn usz! List.index_of(&self, Type type) @if(ELEMENT_IS_EQUATABLE)
+fn usz? List.index_of(&self, Type type) @if(ELEMENT_IS_EQUATABLE)
 {
 	foreach (i, v : self)
 	{
 		if (equals(v, type)) return i;
 	}
-	return SearchResult.MISSING?;
+	return NOT_FOUND?;
 }

-fn usz! List.rindex_of(&self, Type type) @if(ELEMENT_IS_EQUATABLE)
+fn usz? List.rindex_of(&self, Type type) @if(ELEMENT_IS_EQUATABLE)
 {
 	foreach_r (i, v : self)
 	{
 		if (equals(v, type)) return i;
 	}
-	return SearchResult.MISSING?;
+	return NOT_FOUND?;
 }

 fn bool List.equals(&self, List other_list) @if(ELEMENT_IS_EQUATABLE)
@@ -515,8 +492,8 @@ fn bool List.equals(&self, List other_list) @if(ELEMENT_IS_EQUATABLE)
 <*
 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"
+ @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)
@@ -529,8 +506,8 @@ fn bool List.contains(&self, Type value) @if(ELEMENT_IS_EQUATABLE)
 }

 <*
- @param [&inout] self "The list to remove elements from"
- @param value "The value to remove"
+ @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)
@@ -539,8 +516,8 @@ fn bool List.remove_last_item(&self, Type value) @if(ELEMENT_IS_EQUATABLE)
 }

 <*
- @param [&inout] self "The list to remove elements from"
- @param value "The value to remove"
+ @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)
@@ -548,14 +525,15 @@ 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"
+ @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 {
+	defer
+	{
 		if (old_size != self.size) self._update_size_change(old_size, self.size);
 	}
 	return list_common::list_remove_item(self, value);
@@ -593,35 +571,4 @@ fn usz List.compact(&self) @if(ELEMENT_IS_POINTER)
 	return list_common::list_compact(self);
 }

-// --> Deprecated
-
-<*
- @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_match(&self, Type value) @if(ELEMENT_IS_EQUATABLE) @deprecated
-{
-	return self.remove_last_item(value) @inline;
-}
-
-<*
- @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_match(&self, Type value) @if(ELEMENT_IS_EQUATABLE) @deprecated
-{
-	return self.remove_first_item(value) @inline;
-}
-
-
-<*
- @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_all_matches(&self, Type value) @if(ELEMENT_IS_EQUATABLE) @deprecated
-{
-	return self.remove_item(value) @inline;
-}
+int dummy @local;
--- a/lib/std/collections/list_common.c3
+++ b/lib/std/collections/list_common.c3
@@ -3,7 +3,7 @@ module std::collections::list_common;
 <*
 IMPORTANT The returned array must be freed using free_aligned.
 *>
-macro list_to_new_aligned_array($Type, self, Allocator allocator)
+macro list_to_aligned_array($Type, self, Allocator allocator)
 {
 	if (!self.size) return ($Type[]){};
 	$Type[] result = allocator::alloc_array_aligned(allocator, $Type, self.size);
@@ -11,7 +11,7 @@ macro list_to_new_aligned_array($Type, self, Allocator allocator)
 	return result;
 }

-macro list_to_new_array($Type, self, Allocator allocator)
+macro list_to_array($Type, self, Allocator allocator)
 {
 	if (!self.size) return ($Type[]){};
 	$Type[] result = allocator::alloc_array(allocator, $Type, self.size);
--- a/lib/std/collections/map.c3
+++ b/lib/std/collections/map.c3
@@ -1,508 +0,0 @@
-// 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::map(<Key, Value>);
-import std::math;
-
-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);
-
-distinct Map = void*;
-
-struct MapImpl
-{
-	Entry*[] table;
-	Allocator allocator;
-	uint count; // Number of elements
-	uint threshold; // Resize limit
-	float load_factor;
-}
-
-<*
- @require capacity > 0 "The capacity must be 1 or higher"
- @require load_factor > 0.0 "The load factor must be higher than 0"
- @require capacity < MAXIMUM_CAPACITY "Capacity cannot exceed maximum"
-*>
-fn Map new(uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR, Allocator allocator = allocator::heap())
-{
-	MapImpl* map = allocator::alloc(allocator, MapImpl);
-	_init(map, capacity, load_factor, allocator);
-	return (Map)map;
-}
-
-<*
- @require capacity > 0 "The capacity must be 1 or higher"
- @require load_factor > 0.0 "The load factor must be higher than 0"
- @require capacity < MAXIMUM_CAPACITY "Capacity cannot exceed maximum"
-*>
-fn Map temp(uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
-{
-	MapImpl* map = mem::temp_alloc(MapImpl);
-	_init(map, capacity, load_factor, allocator::temp());
-	return (Map)map;
-}
-
-<*
- @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 capacity < MAXIMUM_CAPACITY "Capacity cannot exceed maximum"
-*>
-macro Map new_init_with_key_values(..., uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR, Allocator allocator = allocator::heap())
-{
-	Map map = new(capacity, load_factor, allocator);
-	$for (var $i = 0; $i < $vacount; $i += 2)
-		map.set($vaarg[$i], $vaarg[$i+1]);
-	$endfor
-	return map;
-}
-
-<*
- @param [in] keys "Array of keys for the Map entries"
- @param [in] values "Array of values for the Map 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 capacity < MAXIMUM_CAPACITY "Capacity cannot exceed maximum"
-*>
-fn Map new_init_from_keys_and_values(Key[] keys, Value[] values, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR, Allocator allocator = allocator::heap())
-{
-	assert(keys.len == values.len);
-	Map map = new(capacity, load_factor, allocator);
-	for (usz i = 0; i < keys.len; i++)
-	{
-		map.set(keys[i], values[i]);
-	}
-	return map;
-}
-
-<*
- @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 capacity < MAXIMUM_CAPACITY "Capacity cannot exceed maximum"
-*>
-macro Map temp_new_with_key_values(..., uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
-{
-	Map map = temp(capacity, load_factor);
-	$for (var $i = 0; $i < $vacount; $i += 2)
-		map.set($vaarg[$i], $vaarg[$i+1]);
-	$endfor
-	return map;
-}
-
-<*
- @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 capacity < MAXIMUM_CAPACITY "Capacity cannot exceed maximum"
-*>
-fn Map temp_init_from_keys_and_values(Key[] keys, Value[] values, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR, Allocator allocator = allocator::heap())
-{
-	assert(keys.len == values.len);
-	Map map = temp(capacity, load_factor);
-	for (usz i = 0; i < keys.len; i++)
-	{
-		map.set(keys[i], values[i]);
-	}
-	return map;
-}
-
-<*
- @param [&in] other_map "The map to copy from."
-*>
-fn Map new_from_map(Map other_map, Allocator allocator = null)
-{
-	MapImpl* other_map_impl = (MapImpl*)other_map;
-	if (!other_map_impl)
-	{
-		if (allocator) return new(allocator: allocator);
-		return null;
-	}
-	MapImpl* map = (MapImpl*)new(other_map_impl.table.len, other_map_impl.load_factor, allocator ?: allocator::heap());
-	if (!other_map_impl.count) return (Map)map;
-	foreach (Entry *e : other_map_impl.table)
-	{
-		while (e)
-		{
-			map._put_for_create(e.key, e.value);
-			e = e.next;
-		}
-	}
-	return (Map)map;
-}
-
-<*
- @param [&in] other_map "The map to copy from."
-*>
-fn Map temp_from_map(Map other_map)
-{
-	return new_from_map(other_map, allocator::temp());
-}
-
-fn bool Map.is_empty(map) @inline
-{
-	return !map || !((MapImpl*)map).count;
-}
-
-fn usz Map.len(map) @inline
-{
-	return map ? ((MapImpl*)map).count : 0;
-}
-
-fn Value*! Map.get_ref(self, Key key)
-{
-	MapImpl *map = (MapImpl*)self;
-	if (!map || !map.count) return SearchResult.MISSING?;
-	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 SearchResult.MISSING?;
-}
-
-fn Entry*! Map.get_entry(map, Key key)
-{
-	MapImpl *map_impl = (MapImpl*)map;
-	if (!map_impl || !map_impl.count) return SearchResult.MISSING?;
-	uint hash = rehash(key.hash());
-	for (Entry *e = map_impl.table[index_for(hash, map_impl.table.len)]; e != null; e = e.next)
-	{
-		if (e.hash == hash && equals(key, e.key)) return e;
-	}
-	return SearchResult.MISSING?;
-}
-
-<*
- Get the value or update and
- @require $assignable(#expr, Value)
-*>
-macro Value Map.@get_or_set(&self, Key key, Value #expr)
-{
-	MapImpl *map = (MapImpl*)*self;
-	if (!map || !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;
-	map.add_entry(hash, key, val, index);
-	return val;
-}
-
-fn Value! Map.get(map, Key key) @operator([])
-{
-	return *map.get_ref(key) @inline;
-}
-
-fn bool Map.has_key(map, Key key)
-{
-	return @ok(map.get_ref(key));
-}
-
-macro Value Map.set_value_return(&map, Key key, Value value) @operator([]=)
-{
-	map.set(key, value);
-	return value;
-}
-
-fn bool Map.set(&self, Key key, Value value)
-{
-	// If the map isn't initialized, use the defaults to initialize it.
-	if (!*self) *self = new();
-	MapImpl* map = (MapImpl*)*self;
-	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;
-		}
-	}
-	map._add_entry(hash, key, value, index);
-	return false;
-}
-
-fn void! Map.remove(map, Key key) @maydiscard
-{
-	if (!map || !((MapImpl*)map)._remove_entry_for_key(key)) return SearchResult.MISSING?;
-}
-
-fn void Map.clear(self)
-{
-	MapImpl* map = (MapImpl*)self;
-	if (!map || !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;
-			map._free_entry(to_delete);
-		}
-		map._free_entry(entry);
-		*entry_ref = null;
-	}
-	map.count = 0;
-}
-
-fn void Map.free(self)
-{
-	if (!self) return;
-	MapImpl* map = (MapImpl*)self;
-	self.clear();
-	map._free_internal(map.table.ptr);
-	map.table = {};
-	allocator::free(map.allocator, map);
-}
-
-fn Key[] Map.temp_keys_list(map)
-{
-	return map.new_keys_list(allocator::temp()) @inline;
-}
-
-fn Key[] Map.new_keys_list(self, Allocator allocator = allocator::heap())
-{
-	MapImpl* map = (MapImpl*)self;
-	if (!map || !map.count) return {};
-
-	Key[] list = allocator::alloc_array(allocator, Key, map.count);
-	usz index = 0;
-	foreach (Entry* entry : map.table)
-	{
-		while (entry)
-		{
-			list[index++] = entry.key;
-			entry = entry.next;
-		}
-	}
-	return list;
-}
-
-macro Map.@each(map; @body(key, value))
-{
-	map.@each_entry(; Entry* entry) {
-		@body(entry.key, entry.value);
-	};
-}
-
-macro Map.@each_entry(self; @body(entry))
-{
-	MapImpl *map = (MapImpl*)self;
-	if (!map || !map.count) return;
-	foreach (Entry* entry : map.table)
-	{
-		while (entry)
-		{
-			@body(entry);
-			entry = entry.next;
-		}
-	}
-}
-
-fn Value[] Map.temp_values_list(map)
-{
-	return map.new_values_list(allocator::temp()) @inline;
-}
-
-fn Value[] Map.new_values_list(self, Allocator allocator = allocator::heap())
-{
-	MapImpl* map = (MapImpl*)self;
-	if (!map || !map.count) return {};
-	Value[] list = allocator::alloc_array(allocator, Value, map.count);
-	usz index = 0;
-	foreach (Entry* entry : map.table)
-	{
-		while (entry)
-		{
-			list[index++] = entry.value;
-			entry = entry.next;
-		}
-	}
-	return list;
-}
-
-fn bool Map.has_value(self, Value v) @if(VALUE_IS_EQUATABLE)
-{
-	MapImpl* map = (MapImpl*)self;
-	if (!map || !map.count) return false;
-	foreach (Entry* entry : map.table)
-	{
-		while (entry)
-		{
-			if (equals(v, entry.value)) return true;
-			entry = entry.next;
-		}
-	}
-	return false;
-}
-
-// --- private methods
-
-fn void MapImpl._add_entry(&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)
-	{
-		map._resize(map.table.len * 2);
-	}
-}
-
-fn void MapImpl._resize(&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);
-	map._transfer(new_table);
-	map.table = new_table;
-	map._free_internal(old_table.ptr);
-	map.threshold = (uint)(new_capacity * map.load_factor);
-}
-
-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);
-}
-
-fn void MapImpl._transfer(&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 _init(MapImpl* impl, uint capacity, float load_factor, Allocator allocator) @private
-{
-	capacity = math::next_power_of_2(capacity);
-	*impl = {
-		.allocator = allocator,
-		.load_factor = load_factor,
-		.threshold = (uint)(capacity * load_factor),
-		.table = allocator::new_array(allocator, Entry*, capacity)
-	};
-}
-
-fn void MapImpl._put_for_create(&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;
-		}
-	}
-	map._create_entry(hash, key, value, i);
-}
-
-fn void MapImpl._free_internal(&map, void* ptr) @inline @private
-{
-	allocator::free(map.allocator, ptr);
-}
-
-fn bool MapImpl._remove_entry_for_key(&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;
-			}
-			map._free_entry(e);
-			return true;
-		}
-		prev = e;
-		e = next;
-	}
-	return false;
-}
-
-fn void MapImpl._create_entry(&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 MapImpl._free_entry(&self, Entry *entry) @local
-{
-	$if COPY_KEYS:
-	allocator::free(self.allocator, entry.key);
-	$endif
-	self._free_internal(entry);
-}
-
-struct Entry
-{
-	uint hash;
-	Key key;
-	Value value;
-	Entry* next;
-}
--- a/lib/std/collections/maybe.c3
+++ b/lib/std/collections/maybe.c3
@@ -1,4 +1,4 @@
-module std::collections::maybe(<Type>);
+module std::collections::maybe{Type};
 import std::io;

 struct Maybe (Printable)
@@ -7,7 +7,7 @@ struct Maybe (Printable)
 	bool has_value;
 }

-fn usz! Maybe.to_format(&self, Formatter* f) @dynamic
+fn usz? Maybe.to_format(&self, Formatter* f) @dynamic
 {
 	if (self.has_value) return f.printf("[%s]", self.value);
 	return f.printf("[EMPTY]");
@@ -28,19 +28,18 @@ fn Maybe value(Type val)
 	return { .value = val, .has_value = true };
 }

-fn Maybe Maybe.with_value(Type val) @deprecated("Use maybe::value instead.") @operator(construct)
-{
-	return { .value = val, .has_value = true };
-}
-
-fn Maybe Maybe.empty() @deprecated("Use maybe::EMPTY instead.") @operator(construct)
-{
-	return { };
-}
-
 const Maybe EMPTY = { };

-macro Type! Maybe.get(self)
+macro Type? Maybe.get(self)
 {
-	return self.has_value ? self.value : SearchResult.MISSING?;
+	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;
 }
--- a/lib/std/collections/object.c3
+++ b/lib/std/collections/object.c3
@@ -25,7 +25,7 @@ struct Object (Printable)
 }


-fn usz! Object.to_format(&self, Formatter* formatter) @dynamic
+fn usz? Object.to_format(&self, Formatter* formatter) @dynamic
 {
 	switch (self.type)
 	{
@@ -50,7 +50,7 @@ fn usz! Object.to_format(&self, Formatter* formatter) @dynamic
 			usz n = formatter.printf("{")!;
 			@stack_mem(1024; Allocator mem)
 			{
-				foreach (i, key : self.map.copy_keys(mem))
+				foreach (i, key : self.map.keys(mem))
 				{
 					if (i > 0) n += formatter.printf(",")!;
 					n += formatter.printf(`"%s":`, key)!;
@@ -178,18 +178,19 @@ fn void Object.init_array_if_needed(&self) @private
 fn void Object.set_object(&self, String key, Object* new_object) @private
 {
 	self.init_map_if_needed();
-	ObjectInternalMapEntry*! entry = self.map.get_entry(key);
-	defer
-	{
-		(void)entry.value.free();
-	}
+	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
+	$switch:
 		$case types::is_int($Type):
 			return new_int(value, self.allocator);
 		$case types::is_float($Type):
@@ -201,9 +202,8 @@ macro Object* Object.object_from_value(&self, value) @private
 		$case $Type.typeid == Object*.typeid:
 			return value;
 		$case $Type.typeid == void*.typeid:
-			if (value != null) return CastResult.TYPE_MISMATCH?;
 			return &NULL_OBJECT;
-		$case $assignable(value, String):
+		$case $defined(String x = value):
 			return new_string(value, self.allocator);
 		$default:
 			$error "Unsupported object type.";
@@ -242,7 +242,7 @@ macro Object* Object.push(&self, value)
 <*
 @require self.is_keyable()
 *>
-fn Object*! Object.get(&self, String key) => self.is_empty() ? SearchResult.MISSING? : self.map.get(key);
+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);
@@ -292,7 +292,7 @@ fn void Object.set_object_at(&self, usz index, Object* to_set)
 }

 <*
- @require $Type.kindof.is_int() "Expected an integer type."
+ @require $Type.kindof.is_int() : "Expected an integer type."
 *>
 macro get_integer_value(Object* value, $Type)
 {
@@ -308,7 +308,7 @@ macro get_integer_value(Object* value, $Type)
 			return ($Type)value.s.to_uint128();
 		$endif
 	}
-	if (!value.is_int()) return NumberConversion.MALFORMED_INTEGER?;
+	if (!value.is_int()) return string::MALFORMED_INTEGER?;
 	return ($Type)value.i;
 }

@@ -331,77 +331,77 @@ 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(&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 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(&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);
+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)
+fn String? Object.get_string(&self, String key)
 {
 	Object* value = self.get(key)!;
-	if (!value.is_string()) return CastResult.TYPE_MISMATCH?;
+	if (!value.is_string()) return TYPE_MISMATCH?;
 	return value.s;
 }

 <*
 @require self.is_indexable()
 *>
-fn String! Object.get_string_at(&self, usz index)
+fn String? Object.get_string_at(&self, usz index)
 {
 	Object* value = self.get_at(index);
-	if (!value.is_string()) return CastResult.TYPE_MISMATCH?;
+	if (!value.is_string()) return TYPE_MISMATCH?;
 	return value.s;
 }

 <*
 @require self.is_keyable()
 *>
-macro String! Object.get_enum(&self, $EnumType, String key)
+macro String? Object.get_enum(&self, $EnumType, String key)
 {
 	Object value = self.get(key)!;
-	if ($EnumType.typeid != value.type) return CastResult.TYPE_MISMATCH?;
+	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)
+macro String? Object.get_enum_at(&self, $EnumType, usz index)
 {
 	Object value = self.get_at(index);
-	if ($EnumType.typeid != value.type) return CastResult.TYPE_MISMATCH?;
+	if ($EnumType.typeid != value.type) return TYPE_MISMATCH?;
 	return ($EnumType)value.i;
 }

 <*
 @require self.is_keyable()
 *>
-fn bool! Object.get_bool(&self, String key)
+fn bool? Object.get_bool(&self, String key)
 {
 	Object* value = self.get(key)!;
-	if (!value.is_bool()) return CastResult.TYPE_MISMATCH?;
+	if (!value.is_bool()) return TYPE_MISMATCH?;
 	return value.b;
 }

@@ -409,17 +409,17 @@ fn bool! Object.get_bool(&self, String key)
 <*
 @require self.is_indexable()
 *>
-fn bool! Object.get_bool_at(&self, usz index)
+fn bool? Object.get_bool_at(&self, usz index)
 {
 	Object* value = self.get_at(index);
-	if (!value.is_bool()) return CastResult.TYPE_MISMATCH?;
+	if (!value.is_bool()) return TYPE_MISMATCH?;
 	return value.b;
 }

 <*
 @require self.is_keyable()
 *>
-fn double! Object.get_float(&self, String key)
+fn double? Object.get_float(&self, String key)
 {
 	Object* value = self.get(key)!;
 	switch (value.type.kindof)
@@ -431,14 +431,14 @@ fn double! Object.get_float(&self, String key)
 		case FLOAT:
 			return value.f;
 		default:
-			return CastResult.TYPE_MISMATCH?;
+			return TYPE_MISMATCH?;
 	}
 }

 <*
 @require self.is_indexable()
 *>
-fn double! Object.get_float_at(&self, usz index)
+fn double? Object.get_float_at(&self, usz index)
 {
 	Object* value = self.get_at(index);
 	switch (value.type.kindof)
@@ -450,7 +450,7 @@ fn double! Object.get_float_at(&self, usz index)
 		case FLOAT:
 			return value.f;
 		default:
-			return CastResult.TYPE_MISMATCH?;
+			return TYPE_MISMATCH?;
 	}
 }

@@ -462,7 +462,7 @@ fn Object* Object.get_or_create_obj(&self, String key)
 	return container;
 }

-def ObjectInternalMap = HashMap(<String, Object*>) @private;
-def ObjectInternalList = List(<Object*>) @private;
-def ObjectInternalMapEntry = Entry(<String, Object*>) @private;
+alias ObjectInternalMap      @private = HashMap {String, Object*};
+alias ObjectInternalList     @private = List {Object*};
+alias ObjectInternalMapEntry @private = Entry {String, Object*};

--- a/lib/std/collections/priorityqueue.c3
+++ b/lib/std/collections/priorityqueue.c3
@@ -1,7 +1,7 @@
 //  priorityqueue.c3
 //  A priority queue using a classic binary heap for C3.
 //
-//  Copyright (c) 2022 David Kopec
+//  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
@@ -20,35 +20,30 @@
 //  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(<Type>);
+module std::collections::priorityqueue{Type};
 import std::collections::priorityqueue::private;

-distinct PriorityQueue = inline PrivatePriorityQueue(<Type, false>);
-distinct PriorityQueueMax = inline PrivatePriorityQueue(<Type, true>);
+typedef PriorityQueue = inline PrivatePriorityQueue{Type, false};
+typedef PriorityQueueMax = inline PrivatePriorityQueue{Type, true};

-module std::collections::priorityqueue::private(<Type, MAX>);
+module std::collections::priorityqueue::private{Type, MAX};
 import std::collections::list, std::io;

-def Heap = List(<Type>);
-
 struct PrivatePriorityQueue (Printable)
 {
-	Heap heap;
+	List{Type} heap;
 }

-fn void PrivatePriorityQueue.init(&self, Allocator allocator, usz initial_capacity = 16, ) @inline
+fn PrivatePriorityQueue* PrivatePriorityQueue.init(&self, Allocator allocator, usz initial_capacity = 16, ) @inline
 {
 	self.heap.init(allocator, initial_capacity);
+	return self;
 }

-fn void PrivatePriorityQueue.new_init(&self, usz initial_capacity = 16, Allocator allocator = allocator::heap()) @inline
+fn PrivatePriorityQueue* PrivatePriorityQueue.tinit(&self, usz initial_capacity = 16) @inline
 {
-	self.heap.init(allocator, initial_capacity);
-}
-
-fn void PrivatePriorityQueue.temp_init(&self, usz initial_capacity = 16) @inline
-{
-	self.heap.init(allocator::temp(), initial_capacity) @inline;
+	self.init(tmem, initial_capacity);
+	return self;
 }


@@ -72,6 +67,9 @@ fn void PrivatePriorityQueue.push(&self, Type element)
 	}
 }

+<*
+ @require index < self.len() : "Index out of range"
+*>
 fn void PrivatePriorityQueue.remove_at(&self, usz index)
 {
 	if (index == 0)
@@ -84,11 +82,11 @@ fn void PrivatePriorityQueue.remove_at(&self, usz index)
 <*
 @require self != null
 *>
-fn Type! PrivatePriorityQueue.pop(&self)
+fn Type? PrivatePriorityQueue.pop(&self)
 {
 	usz i = 0;
 	usz len = self.heap.len();
-	if (!len) return IteratorResult.NO_MORE_ELEMENT?;
+	if (!len) return NO_MORE_ELEMENT?;
 	usz new_count = len - 1;
 	self.heap.swap(0, new_count);
 	while OUTER: ((2 * i + 1) < new_count)
@@ -122,10 +120,9 @@ fn Type! PrivatePriorityQueue.pop(&self)
 	return self.heap.pop();
 }

-fn Type! PrivatePriorityQueue.first(&self)
+fn Type? PrivatePriorityQueue.first(&self)
 {
-	if (!self.len()) return IteratorResult.NO_MORE_ELEMENT?;
-	return self.heap.get(0);
+	return self.heap.first();
 }

 fn void PrivatePriorityQueue.free(&self)
@@ -135,12 +132,12 @@ fn void PrivatePriorityQueue.free(&self)

 fn usz PrivatePriorityQueue.len(&self) @operator(len)
 {
-	return self.heap.len();
+	return self.heap.len() @inline;
 }

 fn bool PrivatePriorityQueue.is_empty(&self)
 {
-	return self.heap.is_empty();
+	return self.heap.is_empty() @inline;
 }

 <*
@@ -151,13 +148,8 @@ fn Type PrivatePriorityQueue.get(&self, usz index) @operator([])
 	return self.heap[index];
 }

-fn usz! PrivatePriorityQueue.to_format(&self, Formatter* formatter) @dynamic
+fn usz? PrivatePriorityQueue.to_format(&self, Formatter* formatter) @dynamic
 {
 	return self.heap.to_format(formatter);
 }

-fn String PrivatePriorityQueue.to_new_string(&self, Allocator allocator = allocator::heap()) @dynamic
-{
-	return self.heap.to_new_string(allocator);
-}
-
--- a/lib/std/collections/range.c3
+++ b/lib/std/collections/range.c3
@@ -1,7 +1,7 @@
 <*
 @require Type.is_ordered : "The type must be ordered"
 *>
-module std::collections::range(<Type>);
+module std::collections::range{Type};
 import std::io;

 struct Range (Printable)
@@ -29,22 +29,7 @@ fn Type Range.get(&self, usz index) @operator([])
 	return (Type)(self.start + (usz)index);
 }

-fn String Range.to_new_string(&self, Allocator allocator = allocator::heap()) @dynamic @deprecated
-{
-	return string::format("[%s..%s]", self.start, self.end, allocator: allocator);
-}
-
-fn String Range.to_string(&self, Allocator allocator) @dynamic
-{
-	return string::format("[%s..%s]", self.start, self.end, allocator: allocator);
-}
-
-fn String Range.to_tstring(&self)
-{
-	return self.to_string(allocator::temp());
-}
-
-fn usz! Range.to_format(&self, Formatter* formatter) @dynamic
+fn usz? Range.to_format(&self, Formatter* formatter) @dynamic
 {
 	return formatter.printf("[%s..%s]", self.start, self.end)!;
 }
@@ -66,26 +51,11 @@ fn bool ExclusiveRange.contains(&self, Type value) @inline
 	return value >= self.start && value < self.end;
 }

-fn usz! ExclusiveRange.to_format(&self, Formatter* formatter) @dynamic
+fn usz? ExclusiveRange.to_format(&self, Formatter* formatter) @dynamic
 {
 	return formatter.printf("[%s..<%s]", self.start, self.end)!;
 }

-fn String ExclusiveRange.to_new_string(&self, Allocator allocator = null) @dynamic
-{
-	return self.to_string(allocator ?: allocator::heap());
-}
-
-fn String ExclusiveRange.to_string(&self, Allocator allocator) @dynamic
-{
-	return string::format("[%s..<%s]", self.start, self.end, allocator: allocator);
-}
-
-fn String ExclusiveRange.to_tstring(&self)
-{
-	return self.to_new_string(allocator::temp());
-}
-
 <*
 @require index < self.len() : "Can't index into an empty range"
 *>
--- a/lib/std/collections/ringbuffer.c3
+++ b/lib/std/collections/ringbuffer.c3
@@ -1,11 +1,14 @@
 <*
- @require values::@is_int(SIZE) &&& SIZE > 0 "The size must be positive integer"
+ @require Type.kindof == ARRAY : "Required an array type"
 *>
-module std::collections::ringbuffer(<Type, SIZE>);
+module std::collections::ringbuffer{Type};
+import std::io;

-struct RingBuffer
+alias Element = $typeof((Type){}[0]);
+
+struct RingBuffer (Printable)
 {
-	Type[SIZE] buf;
+	Type buf;
 	usz written;
 	usz head;
 }
@@ -15,9 +18,9 @@ fn void RingBuffer.init(&self) @inline
 	*self = {};
 }

-fn void RingBuffer.push(&self, Type c)
+fn void RingBuffer.push(&self, Element c)
 {
-	if (self.written < SIZE)
+	if (self.written < self.buf.len)
 	{
 		self.buf[self.written] = c;
 		self.written++;
@@ -25,14 +28,14 @@ fn void RingBuffer.push(&self, Type c)
 	else
 	{
 		self.buf[self.head] = c;
-		self.head = (self.head + 1) % SIZE;
+		self.head = (self.head + 1) % self.buf.len;
 	}
 }

-fn Type RingBuffer.get(&self, usz index) @operator([])
+fn Element RingBuffer.get(&self, usz index) @operator([])
 {
-	index %= SIZE;
-	usz avail = SIZE - self.head;
+	index %= self.buf.len;
+	usz avail = self.buf.len - self.head;
 	if (index < avail)
 	{
 		return self.buf[self.head + index];
@@ -40,25 +43,31 @@ fn Type RingBuffer.get(&self, usz index) @operator([])
 	return self.buf[index - avail];
 }

-fn Type! RingBuffer.pop(&self)
+fn Element? RingBuffer.pop(&self)
 {
 	switch
 	{
 		case self.written == 0:
-			return SearchResult.MISSING?;
-		case self.written < SIZE:
+			return NO_MORE_ELEMENT?;
+		case self.written < self.buf.len:
 			self.written--;
 			return self.buf[self.written];
 		default:
-			self.head = (self.head - 1) % SIZE;
+			self.head = (self.head - 1) % self.buf.len;
 			return self.buf[self.head];
 	}
 }

-fn usz RingBuffer.read(&self, usz index, Type[] buffer)
+fn usz? RingBuffer.to_format(&self, Formatter* format) @dynamic
 {
-	index %= SIZE;
-	if (self.written < SIZE)
+	// 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;
@@ -66,7 +75,7 @@ fn usz RingBuffer.read(&self, usz index, Type[] buffer)
 		buffer[:n] = self.buf[index:n];
 		return n;
 	}
-	usz end = SIZE - self.head;
+	usz end = self.buf.len - self.head;
 	if (index >= end)
 	{
 		index -= end;
@@ -75,13 +84,13 @@ fn usz RingBuffer.read(&self, usz index, Type[] buffer)
 		buffer[:n] = self.buf[index:n];
 		return n;
 	}
-	if (buffer.len <= SIZE - index)
+	if (buffer.len <= self.buf.len - index)
 	{
 		usz n = buffer.len;
 		buffer[:n] = self.buf[self.head + index:n];
 		return n;
 	}
-	usz n1 = SIZE - index;
+	usz n1 = self.buf.len - index;
 	buffer[:n1] = self.buf[self.head + index:n1];
 	buffer = buffer[n1..];
 	index -= n1;
@@ -90,10 +99,10 @@ fn usz RingBuffer.read(&self, usz index, Type[] buffer)
 	return n1 + n2;
 }

-fn void RingBuffer.write(&self, Type[] buffer)
+fn void RingBuffer.write(&self, Element[] buffer)
 {
 	usz i;
-	while (self.written < SIZE && i < buffer.len)
+	while (self.written < self.buf.len && i < buffer.len)
 	{
 		self.buf[self.written] = buffer[i++];
 		self.written++;
@@ -101,6 +110,6 @@ fn void RingBuffer.write(&self, Type[] buffer)
 	foreach (c : buffer[i..])
 	{
 		self.buf[self.head] = c;
-		self.head = (self.head + 1) % SIZE;
+		self.head = (self.head + 1) % self.buf.len;
 	}
 }
--- a/lib/std/collections/tuple.c3
+++ b/lib/std/collections/tuple.c3
@@ -1,16 +1,75 @@
-module std::collections::tuple(<Type1, Type2>);
+module std::collections::pair{Type1, Type2};
+import std::io;

-struct Tuple
+struct Pair (Printable)
 {
 	Type1 first;
 	Type2 second;
 }

-module std::collections::triple(<Type1, Type2, Type3>);
+fn usz? Pair.to_format(&self, Formatter* f) @dynamic
+{
+	return f.printf("{ %s, %s }", self.first, self.second);
+}

-struct Triple
+<*
+ @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;
+}
--- a/lib/std/compression/qoi.c3
+++ b/lib/std/compression/qoi.c3
@@ -7,10 +7,12 @@ const uint PIXELS_MAX = 400000000;
 Purely informative. It will be saved to the file header,
 but does not affect how chunks are en-/decoded.
 *>
-enum QOIColorspace : char (char id)
+enum QOIColorspace : const char
 {
-	SRGB = 0, 	// sRGB with linear alpha
-	LINEAR = 1 	// all channels linear
+	<* sRGB with linear alpha *>
+	SRGB = 0,
+	<* all channels linear *>
+	LINEAR = 1
 }

 <*
@@ -19,7 +21,7 @@ enum QOIColorspace : char (char id)
 AUTO can be used when decoding to automatically determine
 the channels from the file's header.
 *>
-enum QOIChannels : char (char id)
+enum QOIChannels : const inline char
 {
 	AUTO = 0,
 	RGB = 3,
@@ -37,19 +39,11 @@ struct QOIDesc
 	QOIChannels channels;
 	QOIColorspace colorspace;
 }
-
 <*
 QOI Errors.
 These are all the possible bad outcomes.
 *>
-fault QOIError
-{
-	INVALID_PARAMETERS,
-	FILE_OPEN_FAILED,
-	FILE_WRITE_FAILED,
-	INVALID_DATA,
-	TOO_MANY_PIXELS
-}
+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
@@ -67,25 +61,17 @@ import std::io;
 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`
+ @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()
+fn usz? write(String filename, char[] input, QOIDesc* desc) => @pool()
 {
 	// encode data
-	char[] output = new_encode(input, desc, allocator: allocator::temp())!;
+	char[] output = encode(tmem, input, desc)!;

-	// open file
-	File! f = file::open(filename, "wb");
-	if (catch f) return QOIError.FILE_OPEN_FAILED?;
-
-	// write data to file and close it
-	usz! written = f.write(output);
-	if (catch written) return QOIError.FILE_WRITE_FAILED?;
-	if (catch f.close()) return QOIError.FILE_WRITE_FAILED?;
-
-	return written;
+	file::save(filename, output)!;
+	return output.len;
 }


@@ -106,33 +92,25 @@ fn usz! write(String filename, char[] input, QOIDesc* desc) => @pool()
 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`
+ @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[]! new_read(String filename, QOIDesc* desc, QOIChannels channels = AUTO, Allocator allocator = allocator::heap()) => @pool(allocator)
+fn char[]? read(Allocator allocator, String filename, QOIDesc* desc, QOIChannels channels = AUTO) => @pool()
 {
 	// read file
-	char[] data = file::load_temp(filename) ?? QOIError.FILE_OPEN_FAILED?!;
+	char[] data = file::load_temp(filename) ?? FILE_OPEN_FAILED?!;
 	// pass data to decode function
-	return new_decode(data, desc, channels, allocator);
+	return decode(allocator, data, desc, channels);
 }

-fn char[]! read(String filename, QOIDesc* desc, QOIChannels channels = AUTO, Allocator allocator = allocator::heap()) @deprecated("Use new_read")
-{
-	return new_read(filename, desc, channels, allocator);
-}


 // Back to basic non-stdio mode
 module std::compression::qoi;
 import std::bits;

-fn char[]! encode(char[] input, QOIDesc* desc, Allocator allocator = allocator::heap()) @deprecated("use encode_new")
-{
-	return new_encode(input, desc, allocator);
-}
-
 <*
 Encode raw RGB or RGBA pixels into a QOI image in memory.

@@ -143,20 +121,21 @@ fn char[]! encode(char[] input, QOIDesc* desc, Allocator allocator = allocator::
 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`
+ @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[]! new_encode(char[] input, QOIDesc* desc, Allocator allocator = allocator::heap()) @nodiscard
+fn char[]? encode(Allocator allocator, char[] input, QOIDesc* desc) @nodiscard
 {
 	// check info in desc
-	if (desc.width == 0 || desc.height == 0) return QOIError.INVALID_PARAMETERS?;
-	if (desc.channels == AUTO) return QOIError.INVALID_PARAMETERS?;
+	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 QOIError.TOO_MANY_PIXELS?;
+	if (pixels > PIXELS_MAX) return TOO_MANY_PIXELS?;
 	
 	// check input data size
-	uint image_size = pixels * desc.channels.id;
-	if (image_size != input.len) return QOIError.INVALID_DATA?;
+	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
@@ -169,13 +148,13 @@ fn char[]! new_encode(char[] input, QOIDesc* desc, Allocator allocator = allocat
 		.be_magic = bswap('qoif'),
 		.be_width = bswap(desc.width),
 		.be_height = bswap(desc.height),
-		.channels = desc.channels.id,
-		.colorspace = desc.colorspace.id
+		.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.id; // End of image data
+	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
@@ -186,7 +165,7 @@ fn char[]! new_encode(char[] input, QOIDesc* desc, Allocator allocator = allocat
 	ichar[<3>] luma; // ...and luma

 	// write chunks
-	for (loc = 0; loc < image_size; loc += desc.channels.id)
+	for (loc = 0; loc < image_size; loc += desc.channels)
 	{
 		// set previous pixel
 		prev = p;
@@ -271,17 +250,13 @@ fn char[]! new_encode(char[] input, QOIDesc* desc, Allocator allocator = allocat
 	}

 	// write end of stream
-	output[pos:END_OF_STREAM.len] = END_OF_STREAM;
+	output[pos:END_OF_STREAM.len] = END_OF_STREAM[..];
 	pos += END_OF_STREAM.len;
 	
 	return output[:pos];
 }


-fn char[]! decode(char[] data, QOIDesc* desc, QOIChannels channels = AUTO, Allocator allocator = allocator::heap())
-{
-	return new_decode(data, desc, channels, allocator);
-}

 <*
 Decode a QOI image from memory.
@@ -300,34 +275,35 @@ fn char[]! decode(char[] data, QOIDesc* desc, QOIChannels channels = AUTO, Alloc
 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`
+ @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[]! new_decode(char[] data, QOIDesc* desc, QOIChannels channels = AUTO, Allocator allocator = allocator::heap()) @nodiscard
+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 QOIError.INVALID_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 QOIError.INVALID_DATA?;
+	if (bswap(header.be_magic) != 'qoif') return INVALID_DATA?;

 	// copy header data to desc
 	desc.width = bswap(header.be_width);
 	desc.height = bswap(header.be_height);
-	desc.channels = @enumcast(QOIChannels, header.channels)!; 			// Rethrow if invalid
-	desc.colorspace = @enumcast(QOIColorspace, header.colorspace)!;	// Rethrow if invalid
-	if (desc.channels == AUTO) return QOIError.INVALID_DATA?; // Channels must be specified in the header
+	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 (desc.width == 0 || desc.height == 0) return QOIError.INVALID_DATA?;
+	if (desc.width == 0 || desc.height == 0) return INVALID_DATA?;

 	// check pixel count
 	ulong pixels = (ulong)desc.width * (ulong)desc.height;
-	if (pixels > PIXELS_MAX) return QOIError.TOO_MANY_PIXELS?;
+	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)
@@ -340,11 +316,11 @@ fn char[]! new_decode(char[] data, QOIDesc* desc, QOIChannels channels = AUTO, A
 	if (channels == AUTO) channels = desc.channels;
 	
 	// allocate memory for image data
-	usz image_size = (usz)pixels * channels.id;
+	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.id)
+	for (loc = 0; loc < image_size; loc += channels)
 	{
 		// get chunk tag
 		tag = data[pos];
@@ -390,7 +366,7 @@ fn char[]! new_decode(char[] data, QOIDesc* desc, QOIChannels channels = AUTO, A
 		}

 		// draw the pixel
-		if (channels == RGBA) { image[loc:4] = p.rgba; } else { image[loc:3] = p.rgb; }
+		if (channels == RGBA) { image[loc:4] = p.rgba[..]; } else { image[loc:3] = p.rgb[..]; }
 	}
 	
 	return image;
@@ -417,28 +393,23 @@ const OP_RUN = 0b11;

 struct Header @packed
 {
-	uint be_magic;	// magic bytes "qoif"
-	uint be_width;	// image width in pixels (BE)
-	uint be_height;	// image height in pixels (BE)
+	<* magic bytes "qoif" *>
+	uint be_magic;
+	<* image width in pixels (BE) *>
+	uint be_width;
+	<* image height in pixels (BE) *>
+	uint be_height;

 	// informative fields
-	char channels;	// 3 = RGB, 4 = RGB
-	char colorspace;	// 0 = sRGB with linear alpha, 1 = all channels linear
+	<* 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};
+const char[*] END_OF_STREAM = {0, 0, 0, 0, 0, 0, 0, 1};

-// inefficient, but it's only run once at a time
-macro @enumcast($Type, raw)
-{
-	foreach (value : $Type.values)
-	{
-		if (value.id == raw) return value;
-	}
-	return QOIError.INVALID_DATA?;
-}
-
-distinct Pixel = inline char[<4>];
+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;
--- a/lib/std/core/allocators/arena_allocator.c3
+++ b/lib/std/core/allocators/arena_allocator.c3
@@ -1,9 +1,13 @@
-// Copyright (c) 2023 Christoffer Lerno. All rights reserved.
+// 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;
@@ -12,6 +16,8 @@ struct ArenaAllocator (Allocator)

 <*
 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)
 {
@@ -20,23 +26,44 @@ fn ArenaAllocator* ArenaAllocator.init(&self, char[] data)
 	return self;
 }

+<*
+ Reset the usage completely.
+*>
 fn void ArenaAllocator.clear(&self)
 {
 	self.used = 0;
 }

-struct ArenaAllocatorHeader @local
-{
-	usz size;
-	char[?] data;
-}
+<*
+ 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
@@ -50,24 +77,25 @@ fn void ArenaAllocator.release(&self, void* ptr, bool) @dynamic
 	}
 }

-fn usz ArenaAllocator.mark(&self) @dynamic => self.used;
-fn void ArenaAllocator.reset(&self, usz mark) @dynamic => self.used = mark;

 <*
+ Implements the Allocator interface method.
+
 @require !alignment || math::is_power_of_2(alignment)
- @require alignment <= mem::MAX_MEMORY_ALIGNMENT `alignment too big`
+ @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
+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 AllocationFailure.CHUNK_TOO_LARGE?;
+	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 AllocationFailure.OUT_OF_MEMORY?;
+	if (end > total_len) return mem::OUT_OF_MEMORY?;
 	self.used = end;
 	ArenaAllocatorHeader* header = mem - ArenaAllocatorHeader.sizeof;
 	header.size = size;
@@ -76,17 +104,20 @@ fn void*! ArenaAllocator.acquire(&self, usz size, AllocInitType init_type, usz a
 }

 <*
+ Implements the Allocator interface method.
+
 @require !alignment || math::is_power_of_2(alignment)
- @require alignment <= mem::MAX_MEMORY_ALIGNMENT `alignment too big`
+ @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
+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 AllocationFailure.CHUNK_TOO_LARGE?;
+	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?
@@ -99,7 +130,7 @@ fn void*! ArenaAllocator.resize(&self, void *old_pointer, usz size, usz alignmen
 		else
 		{
 			usz new_used = self.used + size - old_size;
-			if (new_used > total_len) return AllocationFailure.OUT_OF_MEMORY?;
+			if (new_used > total_len) return mem::OUT_OF_MEMORY?;
 			self.used = new_used;
 		}
 		header.size = size;
@@ -107,6 +138,14 @@ fn void*! ArenaAllocator.resize(&self, void *old_pointer, usz size, usz alignmen
 	}
 	// Otherwise just allocate new memory.
 	void* mem = self.acquire(size, NO_ZERO, alignment)!;
-	mem::copy(mem, old_pointer, old_size, mem::DEFAULT_MEM_ALIGNMENT, mem::DEFAULT_MEM_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;
+}
--- a/lib/std/core/allocators/backed_arena_allocator.c3
+++ b/lib/std/core/allocators/backed_arena_allocator.c3
@@ -1,43 +1,51 @@
 module std::core::mem::allocator;
 import std::io, std::math;

-struct TempAllocatorChunk @local
-{
-	usz size;
-	char[?] data;
-}
+<*
+ 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`.

-struct TempAllocator (Allocator)
+ 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;
-	TempAllocatorPage* last_page;
+	ExtraPage* last_page;
 	usz used;
 	usz capacity;
-	char[?] data;
+	char[*] data;
 }

-const usz PAGE_IS_ALIGNED @private = (usz)isz.max + 1u;
-
-
-struct TempAllocatorPage
+struct AllocChunk @local
 {
-	TempAllocatorPage* prev_page;
+	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;
+	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;
+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 TempAllocator*! new_temp_allocator(usz size, Allocator allocator)
+fn BackedArenaAllocator*? new_backed_allocator(usz size, Allocator allocator)
 {
-	TempAllocator* temp = allocator::alloc_with_padding(allocator, TempAllocator, size)!;
+	BackedArenaAllocator* temp = allocator::alloc_with_padding(allocator, BackedArenaAllocator, size)!;
 	temp.last_page = null;
 	temp.backing_allocator = allocator;
 	temp.used = 0;
@@ -45,16 +53,16 @@ fn TempAllocator*! new_temp_allocator(usz size, Allocator allocator)
 	return temp;
 }

-fn void TempAllocator.destroy(&self)
+fn void BackedArenaAllocator.destroy(&self)
 {
 	self.reset(0);
 	if (self.last_page) (void)self._free_page(self.last_page);
 	allocator::free(self.backing_allocator, self);
 }

-fn usz TempAllocator.mark(&self) @dynamic => self.used;
+fn usz BackedArenaAllocator.mark(&self) => self.used;

-fn void TempAllocator.release(&self, void* old_pointer, bool) @dynamic
+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])
@@ -63,13 +71,13 @@ fn void TempAllocator.release(&self, void* old_pointer, bool) @dynamic
 		asan::poison_memory_region(&self.data[self.used], old_size);
 	}
 }
-fn void TempAllocator.reset(&self, usz mark) @dynamic
+fn void BackedArenaAllocator.reset(&self, usz mark)
 {
-	TempAllocatorPage *last_page = self.last_page;
+	ExtraPage *last_page = self.last_page;
 	while (last_page && last_page.mark > mark)
 	{
 		self.used = last_page.mark;
-		TempAllocatorPage *to_free = last_page;
+		ExtraPage *to_free = last_page;
 		last_page = last_page.prev_page;
 		self._free_page(to_free)!!;
 	}
@@ -90,19 +98,19 @@ fn void TempAllocator.reset(&self, usz mark) @dynamic
 	self.used = mark;
 }

-fn void! TempAllocator._free_page(&self, TempAllocatorPage* page) @inline @local
+fn void? BackedArenaAllocator._free_page(&self, ExtraPage* page) @inline @local
 {
 	void* mem = page.start;
 	return self.backing_allocator.release(mem, page.is_aligned());
 }

-fn void*! TempAllocator._realloc_page(&self, TempAllocatorPage* page, usz size, usz alignment) @inline @local
+fn void*? BackedArenaAllocator._realloc_page(&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.
-	TempAllocatorPage **pointer_to_prev = &self.last_page;
+	ExtraPage **pointer_to_prev = &self.last_page;
 	// Remove the page from the list
 	while (*pointer_to_prev != page)
 	{
@@ -117,19 +125,19 @@ fn void*! TempAllocator._realloc_page(&self, TempAllocatorPage* page, usz size,
 	return data;
 }

-fn void*! TempAllocator.resize(&self, void* pointer, usz size, usz alignment) @dynamic
+fn void*? BackedArenaAllocator.resize(&self, void* pointer, usz size, usz alignment) @dynamic
 {
-	TempAllocatorChunk *chunk = pointer - TempAllocatorChunk.sizeof;
+	AllocChunk *chunk = pointer - AllocChunk.sizeof;
 	if (chunk.size == (usz)-1)
 	{
-		assert(self.last_page, "Realloc of non temp pointer");
+		assert(self.last_page, "Realloc of unrelated pointer");
 		// First grab the page
-		TempAllocatorPage *page = pointer - TempAllocatorPage.sizeof;
+		ExtraPage *page = pointer - ExtraPage.sizeof;
 		return self._realloc_page(page, size, alignment);
 	}

-	TempAllocatorChunk* data = self.acquire(size, NO_ZERO, alignment)!;
-	mem::copy(data, pointer, chunk.size, mem::DEFAULT_MEM_ALIGNMENT, mem::DEFAULT_MEM_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;
 }
@@ -137,16 +145,16 @@ fn void*! TempAllocator.resize(&self, void* pointer, usz size, usz alignment) @d
 <*
 @require size > 0
 @require !alignment || math::is_power_of_2(alignment)
- @require alignment <= mem::MAX_MEMORY_ALIGNMENT `alignment too big`
+ @require alignment <= mem::MAX_MEMORY_ALIGNMENT : `alignment too big`
 *>
-fn void*! TempAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic
+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, TempAllocatorChunk.alignof);
-	void* mem = aligned_header_start + TempAllocatorChunk.sizeof;
-	if (alignment > TempAllocatorChunk.alignof)
+	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);
 	}
@@ -156,7 +164,7 @@ fn void*! TempAllocator.acquire(&self, usz size, AllocInitType init_type, usz al
 	if (new_usage <= self.capacity)
 	{
 		asan::unpoison_memory_region(starting_ptr, new_usage - self.used);
-		TempAllocatorChunk* chunk_start = mem - TempAllocatorChunk.sizeof;
+		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);
@@ -164,13 +172,13 @@ fn void*! TempAllocator.acquire(&self, usz size, AllocInitType init_type, usz al
 	}

 	// Fallback to backing allocator
-	TempAllocatorPage* page;
+	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(TempAllocatorPage.sizeof + size, alignment);
+		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)!;
@@ -180,21 +188,21 @@ fn void*! TempAllocator.acquire(&self, usz size, AllocInitType init_type, usz al
 			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;
+		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(TempAllocatorPage.sizeof, mem::DEFAULT_MEM_ALIGNMENT);
+		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 - TempAllocatorPage.sizeof;
-		assert(mem::ptr_is_aligned(page, TempAllocator.alignof));
+		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;
@@ -209,22 +217,3 @@ fn void*! TempAllocator.acquire(&self, usz size, AllocInitType init_type, usz al
 	self.last_page = page;
 	return &page.data[0];
 }
-
-fn void! TempAllocator.print_pages(&self, File* f)
-{
-	TempAllocatorPage *last_page = self.last_page;
-	if (!last_page)
-	{
-		io::fprintf(f, "No pages.\n")!;
-		return;
-	}
-	io::fprintf(f, "---Pages----\n")!;
-	uint index = 0;
-	while (last_page)
-	{
-		bool is_not_aligned = !(last_page.size & (1u64 << 63));
-		io::fprintf(f, "%d. Alloc: %d %d at %p%s\n", ++index,
-				last_page.size & ~(1u64 << 63), last_page.mark, &last_page.data[0], is_not_aligned ? "" : " [aligned]")!;
-		last_page = last_page.prev_page;
-	}
-}
--- a/lib/std/core/allocators/dynamic_arena.c3
+++ b/lib/std/core/allocators/dynamic_arena.c3
@@ -4,6 +4,17 @@
 module std::core::mem::allocator;
 import std::math;

+<*
+ 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;
@@ -16,7 +27,7 @@ struct DynamicArenaAllocator (Allocator)
 @param [&inout] allocator
 @require page_size >= 128
 *>
-fn void DynamicArenaAllocator.init(&self, usz page_size, Allocator allocator)
+fn void DynamicArenaAllocator.init(&self, Allocator allocator, usz page_size)
 {
 	self.page = null;
 	self.unused_page = null;
@@ -62,7 +73,7 @@ struct DynamicArenaChunk @local

 <*
 @require ptr != null
- @require self.page != null  `tried to free pointer on invalid allocator`
+ @require self.page != null  : `tried to free pointer on invalid allocator`
 *>
 fn void DynamicArenaAllocator.release(&self, void* ptr, bool) @dynamic
 {
@@ -75,11 +86,12 @@ fn void DynamicArenaAllocator.release(&self, void* ptr, bool) @dynamic
 }

 <*
- @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`
+ @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
+fn void*? DynamicArenaAllocator.resize(&self, void* old_pointer, usz size, usz alignment) @dynamic
 {
 	DynamicArenaPage* current_page = self.page;
 	alignment = alignment_for_allocation(alignment);
@@ -105,13 +117,12 @@ fn void*! DynamicArenaAllocator.resize(&self, void* old_pointer, usz size, usz a
 		return old_pointer;
 	}
 	void* new_mem = self.acquire(size, NO_ZERO, alignment)!;
-	mem::copy(new_mem, old_pointer, old_size, mem::DEFAULT_MEM_ALIGNMENT);
+	mem::copy(new_mem, old_pointer, math::min(old_size, size), mem::DEFAULT_MEM_ALIGNMENT);
 	return new_mem;
 }

-fn void DynamicArenaAllocator.reset(&self, usz mark = 0) @dynamic
+fn void DynamicArenaAllocator.reset(&self)
 {
-	assert(mark == 0, "Unexpectedly reset dynamic arena allocator with mark %d", mark);
 	DynamicArenaPage* page = self.page;
 	DynamicArenaPage** unused_page_ptr = &self.unused_page;
 	while (page)
@@ -129,15 +140,16 @@ fn void DynamicArenaAllocator.reset(&self, usz mark = 0) @dynamic
 <*
 @require math::is_power_of_2(alignment)
 @require size > 0
+ @return? mem::INVALID_ALLOC_SIZE, mem::OUT_OF_MEMORY
 *>
-fn void*! DynamicArenaAllocator._alloc_new(&self, usz size, usz alignment) @local
+fn void*? DynamicArenaAllocator._alloc_new(&self, usz size, usz alignment) @local
 {
 	// 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);
+	DynamicArenaPage*? page = allocator::new_try(self.backing_allocator, DynamicArenaPage);
 	if (catch err = page)
 	{
 		allocator::free(self.backing_allocator, mem);
@@ -157,10 +169,11 @@ fn void*! DynamicArenaAllocator._alloc_new(&self, usz size, usz alignment) @loca
 }

 <*
- @require size > 0 `acquire expects size > 0`
+ @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
+fn void*? DynamicArenaAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic
 {
 	alignment = alignment_for_allocation(alignment);
 	DynamicArenaPage* page = self.page;
--- a/lib/std/core/allocators/heap_allocator.c3
+++ b/lib/std/core/allocators/heap_allocator.c3
@@ -1,10 +1,17 @@
-// Copyright (c) 2021-2024 Christoffer Lerno. All rights reserved.
+// 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;
@@ -12,8 +19,8 @@ struct SimpleHeapAllocator (Allocator)
 }

 <*
- @require allocator != null  "An underlying memory provider must be given"
- @require !self.free_list "The allocator may not be already initialized"
+ @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)
 {
@@ -21,7 +28,7 @@ fn void SimpleHeapAllocator.init(&self, MemoryAllocFn allocator)
 	self.free_list = null;
 }

-fn void*! SimpleHeapAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic
+fn void*? SimpleHeapAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic
 {
 	if (init_type == ZERO)
 	{
@@ -30,7 +37,7 @@ fn void*! SimpleHeapAllocator.acquire(&self, usz size, AllocInitType init_type,
 	return alignment > 0 ? @aligned_alloc(self._alloc, size, alignment) : self._alloc(size);
 }

-fn void*! SimpleHeapAllocator.resize(&self, void* old_pointer, usz size, usz alignment) @dynamic
+fn void*? SimpleHeapAllocator.resize(&self, void* old_pointer, usz size, usz alignment) @dynamic
 {
 	return alignment > 0
 		? @aligned_realloc(self._calloc, self._free, old_pointer, size, alignment)
@@ -52,7 +59,7 @@ fn void SimpleHeapAllocator.release(&self, void* old_pointer, bool aligned) @dyn
 <*
 @require old_pointer && bytes > 0
 *>
-fn void*! SimpleHeapAllocator._realloc(&self, void* old_pointer, usz bytes) @local
+fn void*? SimpleHeapAllocator._realloc(&self, void* old_pointer, usz bytes) @local
 {
 	// Find the block header.
 	Header* block = (Header*)old_pointer - 1;
@@ -64,14 +71,14 @@ fn void*! SimpleHeapAllocator._realloc(&self, void* old_pointer, usz bytes) @loc
 	return new;
 }

-fn void*! SimpleHeapAllocator._calloc(&self, usz bytes) @local
+fn void*? SimpleHeapAllocator._calloc(&self, usz bytes) @local
 {
 	void* data = self._alloc(bytes)!;
 	mem::clear(data, bytes, mem::DEFAULT_MEM_ALIGNMENT);
 	return data;
 }

-fn void*! SimpleHeapAllocator._alloc(&self, usz bytes) @local
+fn void*? SimpleHeapAllocator._alloc(&self, usz bytes) @local
 {
 	usz aligned_bytes = mem::aligned_offset(bytes, mem::DEFAULT_MEM_ALIGNMENT);
 	if (!self.free_list)
@@ -120,7 +127,7 @@ fn void*! SimpleHeapAllocator._alloc(&self, usz bytes) @local
 	return self._alloc(aligned_bytes);
 }

-fn void! SimpleHeapAllocator.add_block(&self, usz aligned_bytes) @local
+fn void? SimpleHeapAllocator.add_block(&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)!;
--- a/lib/std/core/allocators/libc_allocator.c3
+++ b/lib/std/core/allocators/libc_allocator.c3
@@ -1,45 +1,44 @@
-// Copyright (c) 2021-2024 Christoffer Lerno. All rights reserved.
+// 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 = {};
-distinct LibcAllocator (Allocator, Printable) = uptr;
-
-fn String LibcAllocator.to_string(&self, Allocator allocator) @dynamic => "Libc allocator".copy(allocator);
-fn usz! LibcAllocator.to_format(&self, Formatter *format) @dynamic => format.print("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
+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 AllocationFailure.OUT_OF_MEMORY?;
+			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) ?: AllocationFailure.OUT_OF_MEMORY?;
+		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 AllocationFailure.OUT_OF_MEMORY?;
+			if (posix::posix_memalign(&data, alignment, bytes)) return mem::OUT_OF_MEMORY?;
 		}
 		else
 		{
-			if (!(data = libc::malloc(bytes))) return AllocationFailure.OUT_OF_MEMORY?;
+			if (!(data = libc::malloc(bytes))) return mem::OUT_OF_MEMORY?;
 		}
 		$if env::TESTING:
 			for (usz i = 0; i < bytes; i++) ((char*)data)[i] = 0xAA;
@@ -48,13 +47,13 @@ fn void*! LibcAllocator.acquire(&self, usz bytes, AllocInitType init_type, usz a
 	}
 }

-fn void*! LibcAllocator.resize(&self, void* old_ptr, usz new_bytes, usz alignment) @dynamic
+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) ?: AllocationFailure.OUT_OF_MEMORY?;
+	if (alignment <= mem::DEFAULT_MEM_ALIGNMENT) return libc::realloc(old_ptr, new_bytes) ?: mem::OUT_OF_MEMORY?;
 	void* new_ptr;
-	if (posix::posix_memalign(&new_ptr, alignment, new_bytes)) return AllocationFailure.OUT_OF_MEMORY?;
+	if (posix::posix_memalign(&new_ptr, alignment, new_bytes)) return mem::OUT_OF_MEMORY?;

-	$switch
+	$switch:
 	$case env::DARWIN:
 		usz old_usable_size = darwin::malloc_size(old_ptr);
 	$case env::LINUX:
@@ -78,31 +77,31 @@ 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
+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) ?: AllocationFailure.OUT_OF_MEMORY?;
+			return win32::_aligned_recalloc(null, 1, bytes, alignment) ?: mem::OUT_OF_MEMORY?;
 		}
-		return libc::calloc(1, bytes) ?: AllocationFailure.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 AllocationFailure.OUT_OF_MEMORY?;
+	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
+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) ?: AllocationFailure.OUT_OF_MEMORY?;
+		return win32::_aligned_realloc(old_ptr, new_bytes, alignment) ?: mem::OUT_OF_MEMORY?;
 	}
-	return libc::realloc(old_ptr, new_bytes) ?: AllocationFailure.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
@@ -118,17 +117,17 @@ fn void LibcAllocator.release(&self, void* old_ptr, bool aligned) @dynamic
 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
+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 ?: AllocationFailure.OUT_OF_MEMORY?;
+		return data ?: mem::OUT_OF_MEMORY?;
 	}
 	else
 	{
 		void* data = alignment ? @aligned_alloc(libc::malloc, bytes, alignment)!! : libc::malloc(bytes);
-		if (!data) return AllocationFailure.OUT_OF_MEMORY?;
+		if (!data) return mem::OUT_OF_MEMORY?;
 		$if env::TESTING:
 			for (usz i = 0; i < bytes; i++) ((char*)data)[i] = 0xAA;
 		$endif
@@ -137,14 +136,14 @@ fn void*! LibcAllocator.acquire(&self, usz bytes, AllocInitType init_type, usz a
 }


-fn void*! LibcAllocator.resize(&self, void* old_ptr, usz new_bytes, usz alignment) @dynamic
+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 ?: AllocationFailure.OUT_OF_MEMORY?;
+		return data ?: mem::OUT_OF_MEMORY?;
 	}
-	return libc::realloc(old_ptr, new_bytes) ?: AllocationFailure.OUT_OF_MEMORY?;
+	return libc::realloc(old_ptr, new_bytes) ?: mem::OUT_OF_MEMORY?;
 }


--- a/lib/std/core/allocators/on_stack_allocator.c3
+++ b/lib/std/core/allocators/on_stack_allocator.c3
@@ -1,5 +1,14 @@
 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;
@@ -8,7 +17,6 @@ struct OnStackAllocator (Allocator)
 	OnStackAllocatorExtraChunk* chunk;
 }

-
 struct OnStackAllocatorExtraChunk @local
 {
 	bool is_aligned;
@@ -52,7 +60,7 @@ fn void OnStackAllocator.free(&self)
 struct OnStackAllocatorHeader
 {
 	usz size;
-	char[?] data;
+	char[*] data;
 }

 <*
@@ -102,9 +110,9 @@ fn OnStackAllocatorExtraChunk* on_stack_allocator_find_chunk(OnStackAllocator* a
 <*
 @require size > 0
 @require old_pointer != null
- @require alignment <= mem::MAX_MEMORY_ALIGNMENT `alignment too big`
+ @require alignment <= mem::MAX_MEMORY_ALIGNMENT : `alignment too big`
 *>
-fn void*! OnStackAllocator.resize(&self, void* old_pointer, usz size, usz alignment) @dynamic
+fn void*? OnStackAllocator.resize(&self, void* old_pointer, usz size, usz alignment) @dynamic
 {
 	if (!allocation_in_stack_mem(self, old_pointer))
 	{
@@ -116,15 +124,15 @@ fn void*! OnStackAllocator.resize(&self, void* old_pointer, usz size, usz alignm
 	OnStackAllocatorHeader* header = old_pointer - OnStackAllocatorHeader.sizeof;
 	usz old_size = header.size;
 	void* mem = self.acquire(size, NO_ZERO, alignment)!;
-	mem::copy(mem, old_pointer, old_size, mem::DEFAULT_MEM_ALIGNMENT, mem::DEFAULT_MEM_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 alignment <= mem::MAX_MEMORY_ALIGNMENT : `alignment too big`
 @require size > 0
 *>
-fn void*! OnStackAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic
+fn void*? OnStackAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic
 {
 	bool aligned = alignment > 0;
 	alignment = alignment_for_allocation(alignment);
--- a/lib/std/core/allocators/temp_allocator.c3
+++ b/lib/std/core/allocators/temp_allocator.c3
@@ -1,58 +1,172 @@
-module std::core::mem::allocator;
+module std::core::mem::allocator @if(!(env::POSIX || env::WIN32) || !$feature(VMEM_TEMP));
 import std::io, std::math;

-struct TempAllocatorChunk @local
-{
-	usz size;
-	char[?] data;
-}
+// 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;
-	char[?] data;
+	usz original_capacity;
+	char[*] data;
 }

-const usz PAGE_IS_ALIGNED @private = (usz)isz.max + 1u;
+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 mark;
 	usz size;
 	usz ident;
-	char[?] data;
+	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 >= 16
+ @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(usz size, Allocator allocator)
+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.capacity = size;
+	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;
 }
-
-fn void TempAllocator.destroy(&self)
+<*
+ @require !self.derived
+*>
+fn TempAllocator*? TempAllocator.derive_allocator(&self, usz reserve = 0)
 {
-	self.reset(0);
-	if (self.last_page) (void)self._free_page(self.last_page);
-	allocator::free(self.backing_allocator, self);
+	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;
 }

-fn usz TempAllocator.mark(&self) @dynamic => self.used;
+<*
+ 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;
+		old.destroy();
+	}
+	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();
+	self.destroy();
+}
+
+fn void TempAllocator.destroy(&self) @local
+{
+	TempAllocatorPage *last_page = self.last_page;
+	while (last_page)
+	{
+		TempAllocatorPage *to_free = last_page;
+		last_page = last_page.prev_page;
+		self._free_page(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
 {
@@ -63,40 +177,15 @@ fn void TempAllocator.release(&self, void* old_pointer, bool) @dynamic
 		asan::poison_memory_region(&self.data[self.used], old_size);
 	}
 }
-fn void TempAllocator.reset(&self, usz mark) @dynamic
-{
-	TempAllocatorPage *last_page = self.last_page;
-	while (last_page && last_page.mark > mark)
-	{
-		self.used = last_page.mark;
-		TempAllocatorPage *to_free = last_page;
-		last_page = last_page.prev_page;
-		self._free_page(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! TempAllocator._free_page(&self, TempAllocatorPage* page) @inline @local
+
+fn void? TempAllocator._free_page(&self, TempAllocatorPage* page) @inline @local
 {
 	void* mem = page.start;
 	return self.backing_allocator.release(mem, page.is_aligned());
 }

-fn void*! TempAllocator._realloc_page(&self, TempAllocatorPage* page, usz size, usz alignment) @inline @local
+fn void*? TempAllocator._realloc_page(&self, TempAllocatorPage* page, usz size, usz alignment) @inline @local
 {
 	// Then the actual start pointer:
 	void* real_pointer = page.start;
@@ -112,12 +201,13 @@ fn void*! TempAllocator._realloc_page(&self, TempAllocatorPage* page, usz size,
 	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;
 }

-fn void*! TempAllocator.resize(&self, void* pointer, usz size, usz alignment) @dynamic
+fn void*? TempAllocator.resize(&self, void* pointer, usz size, usz alignment) @dynamic
 {
 	TempAllocatorChunk *chunk = pointer - TempAllocatorChunk.sizeof;
 	if (chunk.size == (usz)-1)
@@ -127,19 +217,47 @@ fn void*! TempAllocator.resize(&self, void* pointer, usz size, usz alignment) @d
 		TempAllocatorPage *page = pointer - TempAllocatorPage.sizeof;
 		return self._realloc_page(page, size, alignment);
 	}
-
-	TempAllocatorChunk* data = self.acquire(size, NO_ZERO, alignment)!;
-	mem::copy(data, pointer, chunk.size, mem::DEFAULT_MEM_ALIGNMENT, mem::DEFAULT_MEM_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`
+ @require alignment <= mem::MAX_MEMORY_ALIGNMENT : `alignment too big`
 *>
-fn void*! TempAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic
+fn void*? TempAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic
 {
 	alignment = alignment_for_allocation(alignment);
 	void* start_mem = &self.data;
@@ -202,29 +320,87 @@ fn void*! TempAllocator.acquire(&self, usz size, AllocInitType init_type, usz al

 	// 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];
 }

-fn void! TempAllocator.print_pages(&self, File* f)
+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)
 {
-	TempAllocatorPage *last_page = self.last_page;
-	if (!last_page)
-	{
-		io::fprintf(f, "No pages.\n")!;
-		return;
-	}
-	io::fprintf(f, "---Pages----\n")!;
-	uint index = 0;
-	while (last_page)
-	{
-		bool is_not_aligned = !(last_page.size & (1u64 << 63));
-		io::fprintf(f, "%d. Alloc: %d %d at %p%s\n", ++index,
-				last_page.size & ~(1u64 << 63), last_page.mark, &last_page.data[0], is_not_aligned ? "" : " [aligned]")!;
-		last_page = last_page.prev_page;
-	}
+	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)
+{
+	self.destroy();
+}
+
+fn void TempAllocator.destroy(&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;
+}
--- a/lib/std/core/allocators/tracking_allocator.c3
+++ b/lib/std/core/allocators/tracking_allocator.c3
@@ -1,4 +1,4 @@
-// Copyright (c) 2021-2024 Christoffer Lerno. All rights reserved.
+// 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.

@@ -13,11 +13,15 @@ struct Allocation
 	void*[MAX_BACKTRACE] backtrace;
 }

-def AllocMap = HashMap(<uptr, Allocation>);
+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;
@@ -29,7 +33,7 @@ struct TrackingAllocator (Allocator)
 <*
 Initialize a tracking allocator to wrap (and track) another allocator.

- @param [&inout] allocator "The allocator to track"
+ @param [&inout] allocator : "The allocator to track"
 *>
 fn void TrackingAllocator.init(&self, Allocator allocator)
 {
@@ -52,7 +56,7 @@ fn void TrackingAllocator.free(&self)
 fn usz TrackingAllocator.allocated(&self) => @pool()
 {
 	usz allocated = 0;
-	foreach (&allocation : self.map.value_tlist()) allocated += allocation.size;
+	foreach (&allocation : self.map.tvalues()) allocated += allocation.size;
 	return allocated;
 }

@@ -68,7 +72,7 @@ fn usz TrackingAllocator.total_allocation_count(&self) => self.allocs_total;

 fn Allocation[] TrackingAllocator.allocations_tlist(&self, Allocator allocator)
 {
-	return self.map.value_tlist();
+	return self.map.tvalues();
 }

 <*
@@ -76,7 +80,7 @@ fn Allocation[] TrackingAllocator.allocations_tlist(&self, Allocator allocator)
 *>
 fn usz TrackingAllocator.allocation_count(&self) => self.map.count;

-fn void*! TrackingAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic
+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++;
@@ -87,7 +91,7 @@ fn void*! TrackingAllocator.acquire(&self, usz size, AllocInitType init_type, us
 	return data;
 }

-fn void*! TrackingAllocator.resize(&self, void* old_pointer, usz size, usz alignment) @dynamic
+fn void*? TrackingAllocator.resize(&self, void* old_pointer, usz size, usz alignment) @dynamic
 {
 	void* data = self.inner_allocator.resize(old_pointer, size, alignment)!;
 	self.map.remove((uptr)old_pointer);
@@ -121,13 +125,13 @@ fn bool TrackingAllocator.has_leaks(&self)
 fn void TrackingAllocator.print_report(&self) => self.fprint_report(io::stdout())!!;


-fn void! TrackingAllocator.fprint_report(&self, OutStream out) => @pool()
+fn void? TrackingAllocator.fprint_report(&self, OutStream out) => @pool()
 {
 	usz total = 0;
 	usz entries = 0;
 	bool leaks = false;

-	Allocation[] allocs = self.map.value_tlist();
+	Allocation[] allocs = self.map.tvalues();
 	if (allocs.len)
 	{
 		if (!allocs[0].backtrace[0])
@@ -155,7 +159,7 @@ fn void! TrackingAllocator.fprint_report(&self, OutStream out) => @pool()
 				Backtrace trace = backtrace::BACKTRACE_UNKNOWN;
 				if (allocation.backtrace[3])
 				{
-					trace = backtrace::symbolize_backtrace(allocation.backtrace[3:1], allocator::temp()).get(0) ?? backtrace::BACKTRACE_UNKNOWN;
+					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,
@@ -194,7 +198,7 @@ fn void! TrackingAllocator.fprint_report(&self, OutStream out) => @pool()
 					break;
 				}
 			}
-			BacktraceList list = backtrace::symbolize_backtrace(allocation.backtrace[3..(end - 1)], allocator::temp())!;
+			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)
 			{
@@ -212,4 +216,4 @@ fn void! TrackingAllocator.fprint_report(&self, OutStream out) => @pool()
 			}
 		}
 	}
-}
+}
--- a/lib/std/core/allocators/vmem.c3
+++ b/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;
+}
--- a/lib/std/core/ansi.c3
+++ b/lib/std/core/ansi.c3
@@ -0,0 +1,133 @@
+module std::core::string::ansi;
+
+enum Ansi : const 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",
+}
+
+<*
+ 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)
+{
+	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)
+{
+	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)
+{
+	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)
+{
+	return string::format(tmem, "\e[%s8;2;%s;%s;%sm", bg ? 4 : 3, r, g, b);
+}
--- a/lib/std/core/array.c3
+++ b/lib/std/core/array.c3
@@ -1,62 +1,96 @@
 module std::core::array;
-import std::core::array::slice;
+import std::collections::pair, std::io;

 <*
+ Returns true if the array contains at least one element, else false
+
 @param [in] array
 @param [in] element
- @return "the first index of the element"
- @return! SearchResult.MISSING
+ @require $kindof(array) == SLICE || $kindof(array) == ARRAY
+ @require @typematch(array[0], element) : "array and element must have the same type"
 *>
-macro index_of(array, element)
+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 SearchResult.MISSING?;
+	return NOT_FOUND?;
 }

+
 <*
- @require @typekind(array_ptr) == POINTER
- @require @typekind(*array_ptr) == VECTOR || @typekind(*array_ptr) == ARRAY
- @require @typekind((*array_ptr)[0]) == VECTOR || @typekind((*array_ptr)[0]) == ARRAY
+ 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 (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! SearchResult.MISSING
+ @return? NOT_FOUND
 *>
-macro rindex_of(array, element)
+macro usz? rindex_of(array, element)
 {
 	foreach_r (i, &e : array)
 	{
 		if (*e == element) return i;
 	}
-	return SearchResult.MISSING?;
+	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 @typekind(arr1) == SLICE || @typekind(arr1) == ARRAY
- @require @typekind(arr2) == SLICE || @typekind(arr2) == ARRAY
- @require @typeis(arr1[0], $typeof(arr2[0])) "Arrays must have the same type"
+ @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(arr1, arr2, Allocator allocator) @nodiscard
+macro concat(Allocator allocator, arr1, arr2) @nodiscard
 {
 	var $Type = $typeof(arr1[0]);
 	$Type[] result = allocator::alloc_array(allocator, $Type, arr1.len + arr2.len);
@@ -70,21 +104,6 @@ macro concat(arr1, arr2, Allocator allocator) @nodiscard
 	}
 	return result;
 }
-<*
- 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 @typekind(arr1) == SLICE || @typekind(arr1) == ARRAY
- @require @typekind(arr2) == SLICE || @typekind(arr2) == ARRAY
- @require @typeis(arr1[0], $typeof(arr2[0])) "Arrays must have the same type"
- @ensure return.len == arr1.len + arr2.len
-*>
-macro concat_new(arr1, arr2, Allocator allocator = allocator::heap()) @nodiscard
-{
-	return concat(arr1, arr2, allocator);
-}

 <*
 Concatenate two arrays or slices, returning a slice containing the concatenation of them,
@@ -92,102 +111,443 @@ macro concat_new(arr1, arr2, Allocator allocator = allocator::heap()) @nodiscard

 @param [in] arr1
 @param [in] arr2
- @require @typekind(arr1) == SLICE || @typekind(arr1) == ARRAY
- @require @typekind(arr2) == SLICE || @typekind(arr2) == ARRAY
- @require @typeis(arr1[0], $typeof(arr2[0])) "Arrays must have the same type"
+ @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(arr1, arr2, allocator::temp());
+macro tconcat(arr1, arr2) @nodiscard => concat(tmem, arr1, arr2);

-module std::core::array::slice(<Type>);

-struct Slice2d
+<*
+ 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)
 {
-	Type* ptr;
-	usz inner_len;
-	usz ystart;
-	usz ylen;
-	usz xstart;
-	usz xlen;
-}
-
-fn usz Slice2d.len(&self) @operator(len)
-{
-	return self.ylen;
-}
-
-fn usz Slice2d.count(&self)
-{
-	return self.ylen * self.xlen;
-}
-
-macro void Slice2d.@each(&self; @body(usz[<2>], Type))
-{
-	foreach (y, line : *self)
-	{
-		foreach (x, val : line)
-		{
-			@body({ x, y }, val);
-		}
-	}
-}
-
-macro void Slice2d.@each_ref(&self; @body(usz[<2>], Type*))
-{
-	foreach (y, line : *self)
-	{
-		foreach (x, &val : line)
-		{
-			@body({ x, y }, val);
-		}
-	}
+	$typefrom(@reduce_fn(array, identity)) $func = #operation;
+	foreach (index, element : array) identity = $func(identity, element, index);
+	return identity;
 }

 <*
- @require idy >= 0 && idy < self.ylen
+ 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 Type[] Slice2d.get_row(self, usz idy) @operator([])
+macro @sum(array, identity_value = 0)
 {
-	return (self.ptr + self.inner_len * (idy + self.ystart))[self.xstart:self.xlen];
-}
-
-macro Type Slice2d.get_coord(self, usz[<2>] coord)
-{
-	return *self.get_coord_ref(coord);
-}
-
-macro Type Slice2d.get_xy(self, x, y)
-{
-	return *self.get_xy_ref(x, y);
-}
-
-macro Type* Slice2d.get_xy_ref(self, x, y)
-{
-	return self.ptr + self.inner_len * (y + self.ystart) + self.xstart + x;
-}
-
-macro Type* Slice2d.get_coord_ref(self, usz[<2>] coord)
-{
-	return self.get_xy_ref(coord.x, coord.y);
-}
-
-macro void Slice2d.set_coord(self, usz[<2>] coord, Type value)
-{
-	*self.get_coord_ref(coord) = value;
-}
-
-macro void Slice2d.set_xy(self, x, y, Type value)
-{
-	*self.get_xy_ref(x, y) = value;
+	return @reduce(array, ($typeof(array[0]))identity_value, fn (acc, e, u) => acc + e);
 }

 <*
- @require y >= 0 && y < self.ylen
- @require x >= 0 && x < self.xlen
+ 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"
 *>
-fn Slice2d Slice2d.slice(&self, isz x = 0, isz xlen = 0, isz y = 0, isz ylen = 0)
+macro @product(array, identity_value = 1)
 {
-	if (xlen < 1) xlen = self.xlen + xlen;
-	if (ylen < 1) ylen = self.ylen + ylen;
-	return { self.ptr, self.inner_len, y + self.ystart, ylen, x + self.xstart, xlen };
+	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;
+}
+
+
+<*
+ 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
 }
--- a/lib/std/core/ascii.c3
+++ b/lib/std/core/ascii.c3
@@ -0,0 +1,138 @@
+<*
+ 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) => !!(c < 128) & !!(set & (AsciiCharset)(1ULL << c));
+
+const AsciiCharset WHITESPACE_SET = @create_set("\t\n\v\f\r ");
+const AsciiCharset NUMBER_SET = @create_set("0123456789");
+
+
--- a/lib/std/core/bitorder.c3
+++ b/lib/std/core/bitorder.c3
@@ -1,4 +1,4 @@
-// Copyright (c) 2023 Christoffer Lerno and contributors. All rights reserved.
+// 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;
@@ -88,93 +88,97 @@ bitstruct UInt128LE : uint128 @littleendian
 }

 <*
- @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 @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"
 *>
 macro read(bytes, $Type)
 {
 	char[] s;
-	$switch (@typekind(bytes))
-	$case POINTER:
-		s = (*bytes)[:$Type.sizeof];
-	$default:
-		s = bytes[:$Type.sizeof];
+	$switch $kindof(bytes):
+		$case POINTER:
+			s = (*bytes)[:$Type.sizeof];
+		$default:
+			s = bytes[:$Type.sizeof];
 	$endswitch
 	return bitcast(*(char[$Type.sizeof]*)s.ptr, $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 @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"
 *>
 macro write(x, bytes, $Type)
 {
 	char[] s;
-	$switch (@typekind(bytes))
-	$case POINTER:
-		s = (*bytes)[:$Type.sizeof];
-	$default:
-		s = bytes[:$Type.sizeof];
+	$switch $kindof(bytes):
+		$case POINTER:
+			s = (*bytes)[:$Type.sizeof];
+		$default:
+			s = bytes[:$Type.sizeof];
 	$endswitch
 	*($typeof(x)*)s.ptr = bitcast(x, $Type).val;
 }

-macro is_bitorder($Type)
+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;
+	$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)
+macro bool is_array_or_slice_of_char(bytes) @deprecated("Use @is_array_or_slice_of_char")
 {
-	$switch (@typekind(bytes))
-	$case POINTER:
-		var $Inner = $typefrom($typeof(bytes).inner);
-		$if $Inner.kindof == ARRAY:
-			var $Inner2 = $typefrom($Inner.inner);
-			return $Inner2.typeid == char.typeid;
-		$endif
-	$case ARRAY:
-	$case SLICE:
-		var $Inner = $typefrom($typeof(bytes).inner);
-		return $Inner.typeid == char.typeid;
-	$default:
-		return false;
+	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)
+macro bool is_arrayptr_or_slice_of_char(bytes) @deprecated("Use @is_arrayptr_or_slice_of_char")
 {
-	$switch (@typekind(bytes))
-	$case POINTER:
-		var $Inner = $typefrom($typeof(bytes).inner);
-		$if $Inner.kindof == ARRAY:
-			var $Inner2 = $typefrom($Inner.inner);
-			return $Inner2.typeid == char.typeid;
-		$endif
-	$case SLICE:
-		var $Inner = $typefrom($typeof(bytes).inner);
-		return $Inner.typeid == char.typeid;
-	$default:
-		return false;
+	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
-}
+}
--- a/lib/std/core/builtin.c3
+++ b/lib/std/core/builtin.c3
@@ -4,30 +4,72 @@
 module std::core::builtin;
 import libc, std::hash, std::io, std::os::backtrace;

-/*
- Use `IteratorResult` when reading the end of an iterator, or accessing a result out of bounds.
-*/
-fault IteratorResult { NO_MORE_ELEMENT }
+
+<*
+ EMPTY_MACRO_SLOT is a value used for implementing optional arguments for macros in an efficient
+ way. It relies on the fact that distinct types are not implicitly convertible.
+
+ You can use `@is_empty_macro_slot()` and `@is_valid_macro_slot()` to figure out whether
+ the argument has been used or not.
+
+ An example:
+
+```c3
+macro foo(a, #b = EMPTY_MACRO_SLOT)
+{
+	$if @is_valid_macro_slot(#b):
+		return invoke_foo2(a, #b);
+	$else
+		return invoke_foo1(a);
+	$endif
+}
+*>
+const EmptySlot EMPTY_MACRO_SLOT @builtin = null;
+
+typedef EmptySlot = void*;
+macro bool @is_empty_macro_slot(#arg) @const @builtin => $typeof(#arg) == EmptySlot;
+macro bool @is_valid_macro_slot(#arg) @const @builtin => $typeof(#arg) != EmptySlot;
+
+<*
+ Returns a random value at compile time.
+
+ @ensure return >= 0.0 && return < 1.0
+ @return "A compile time random"
+*>
+macro @rnd() @const @builtin => $$rnd();

 /*
- Use `SearchResult` when trying to return a value from some collection but the element is missing.
+ Use `NO_MORE_ELEMENT` when reading the end of an iterator, or accessing a result out of bounds.
 */
-fault SearchResult { MISSING }
+faultdef NO_MORE_ELEMENT @builtin;

 /*
- Use `CastResult` when an attempt at conversion fails.
+ Use `NOT_FOUND` when trying to return a value from some collection but the element is missing.
 */
-fault CastResult { TYPE_MISMATCH }
+faultdef NOT_FOUND @builtin;

+/*
+ Use `TYPE_MISMATCH` when an attempt at conversion fails.
+*/
+faultdef TYPE_MISMATCH @builtin;

-def VoidFn = fn void();
+/*
+ Use `CAPACITY_EXCEEDED` when trying to add to a bounded list or similar.
+*/
+faultdef CAPACITY_EXCEEDED @builtin;
+/*
+ Use `NOT_IMPLEMENTED` when something is conditionally available.
+*/
+faultdef NOT_IMPLEMENTED @builtin;
+
+alias VoidFn = fn void();

 <*
 Stores a variable on the stack, then restores it at the end of the
 macro scope.

- @param #variable `the variable to store and restore`
- @require values::@is_lvalue(#variable)
+ @param #variable : `the variable to store and restore`
+ @require $defined(#variable = #variable) : `Expected an actual variable`
 *>
 macro void @scope(#variable; @body) @builtin
 {
@@ -38,7 +80,7 @@ macro void @scope(#variable; @body) @builtin

 <*
 Swap two variables
- @require $defined(#a = #b, #b = #a) `The values must be mutually assignable`
+ @require $defined(#a = #b, #b = #a) : `The values must be mutually assignable`
 *>
 macro void @swap(#a, #b) @builtin
 {
@@ -47,65 +89,102 @@ macro void @swap(#a, #b) @builtin
 	#b = temp;
 }

+macro usz bitsizeof($Type) @builtin @const => $Type.sizeof * 8u;
+
+macro usz @bitsizeof(#expr) @builtin @const => $sizeof(#expr) * 8u;
+
 <*
 Convert an `any` type to a type, returning an failure if there is a type mismatch.

- @param v `the any to convert to the given type.`
- @param $Type `the type to convert to`
+ @param v : `the any to convert to the given type.`
+ @param $Type : `the type to convert to`
 @return `The any.ptr converted to its type.`
- @ensure @typeis(return, $Type*)
- @return! CastResult.TYPE_MISMATCH
+ @ensure $typeof(return) == $Type*
+ @return? TYPE_MISMATCH
 *>
 macro anycast(any v, $Type) @builtin
 {
-	if (v.type != $Type.typeid) return CastResult.TYPE_MISMATCH?;
+	if (v.type != $Type.typeid) return TYPE_MISMATCH?;
 	return ($Type*)v.ptr;
 }

-fn bool print_backtrace(String message, int backtraces_to_ignore) @if(env::NATIVE_STACKTRACE) => @pool()
+macro bool @assignable_to(#foo, $Type) @const @builtin @deprecated("use '$defined($Type x = #foo)'") => $defined(*&&($Type){} = #foo);
+
+macro @addr(#val) @builtin
+{
+	$if $defined(&#val):
+		return &#val;
+	$else
+		return &&#val;
+	$endif
+}
+
+macro typeid @typeid(#value) @const @builtin
+{
+	return $typeof(#value).typeid;
+}
+
+macro TypeKind @typekind(#value) @const @builtin @deprecated("Use `$kindof(#value)`.")
+{
+	return $kindof(#value);
+}
+
+macro bool @typeis(#value, $Type) @const @builtin @deprecated("Use `$typeof(#value) == $Type` instead.")
+{
+	return $typeof(#value).typeid == $Type.typeid;
+}
+
+
+fn bool print_backtrace(String message, int backtraces_to_ignore, void *added_backtrace = null) @if (env::NATIVE_STACKTRACE) => @stack_mem(0x1100; Allocator smem)
 {
 	void*[256] buffer;
 	void*[] backtraces = backtrace::capture_current(&buffer);
-	backtraces_to_ignore++;
-	BacktraceList! backtrace = backtrace::symbolize_backtrace(backtraces, allocator::temp());
-	if (catch backtrace) return false;
-	if (backtrace.len() <= backtraces_to_ignore) return false;
-	io::eprint("\nERROR: '");
-	io::eprint(message);
-	io::eprintn("'");
-	foreach (i, &trace : backtrace)
+	if (added_backtrace)
 	{
-		if (i < backtraces_to_ignore) continue;
-		String inline_suffix = trace.is_inline ? " [inline]" : "";
-		if (trace.is_unknown())
-		{
-			io::eprintfn("  in ???%s", inline_suffix);
-			continue;
-		}
-		if (trace.has_file())
-		{
-			io::eprintfn("  in %s (%s:%d) [%s]%s", trace.function, trace.file, trace.line, trace.object_file, inline_suffix);
-			continue;
-		}
-		io::eprintfn("  in %s (source unavailable) [%s]%s", trace.function, trace.object_file, inline_suffix);
+		backtraces[++backtraces_to_ignore] = added_backtrace;
 	}
+	@stack_mem(2048; Allocator mem)
+	{
+		BacktraceList? backtrace = backtrace::symbolize_backtrace(mem, backtraces);
+		if (catch backtrace) return false;
+		if (backtrace.len() <= backtraces_to_ignore) return false;
+		io::eprint("\nERROR: '");
+		io::eprint(message);
+		io::eprintn("'");
+		foreach (i, &trace : backtrace)
+		{
+			if (i < backtraces_to_ignore) continue;
+			String inline_suffix = trace.is_inline ? " [inline]" : "";
+			if (trace.is_unknown())
+			{
+				io::eprintfn("  in ???%s", inline_suffix);
+				continue;
+			}
+			if (trace.has_file())
+			{
+				io::eprintfn("  in %s (%s:%d) [%s]%s", trace.function, trace.file, trace.line, trace.object_file, inline_suffix);
+				continue;
+			}
+			io::eprintfn("  in %s (source unavailable) [%s]%s", trace.function, trace.object_file, inline_suffix);
+		}
+	};
 	return true;

 }

 fn void default_panic(String message, String file, String function, uint line) @if(env::NATIVE_STACKTRACE)
 {
-	$if $defined(io::stderr):
-	if (!print_backtrace(message, 2))
-	{
-		io::eprintfn("\nERROR: '%s', in %s (%s:%d)", message, function, file, line);
-	}
+	$if $defined(io::stderr) && env::PANIC_MSG:
+		if (!print_backtrace(message, 2))
+		{
+			io::eprintfn("\nERROR: '%s', in %s (%s:%d)", message, function, file, line);
+		}
 	$endif
 	$$trap();

 }

-macro void abort(String string = "Unrecoverable error reached", ...) @builtin @noreturn
+macro void abort(String string = "Unrecoverable error reached", ...) @format(0) @builtin @noreturn
 {
 	panicf(string, $$FILE, $$FUNC, $$LINE, $vasplat);
 	$$trap();
@@ -113,62 +192,67 @@ macro void abort(String string = "Unrecoverable error reached", ...) @builtin @n

 bool in_panic @local = false;

-fn void default_panic(String message, String file, String function, uint line) @if(!env::NATIVE_STACKTRACE)
+fn void default_panic(String message, String file, String function, uint line) @if (!env::NATIVE_STACKTRACE)
 {
-	if (in_panic)
-	{
-		io::eprintn("Panic inside of panic.");
-		return;
-	}
-	in_panic = true;
-	$if $defined(io::stderr):
-	io::eprint("\nERROR: '");
-	io::eprint(message);
-	io::eprintfn("', in %s (%s:%d)", function, file, line);
+	$if $defined(io::stderr) && env::PANIC_MSG:
+		if (in_panic)
+		{
+			io::eprintn("Panic inside of panic.");
+			return;
+		}
+		in_panic = true;
+		$if $defined(io::stderr):
+		io::eprint("\nERROR: '");
+		io::eprint(message);
+		io::eprintfn("', in %s (%s:%d)", function, file, line);
+		$endif
+		in_panic = false;
 	$endif
-	in_panic = false;
 	$$trap();
 }

-def PanicFn = fn void(String message, String file, String function, uint line);
+alias PanicFn = fn void(String message, String file, String function, uint line);

 PanicFn panic = &default_panic;

 fn void panicf(String fmt, String file, String function, uint line, args...)
 {
-	if (in_panic)
-	{
-		io::eprint("Panic inside of panic: ");
-		io::eprintn(fmt);
-		return;
-	}
-	in_panic = true;
-	@stack_mem(512; Allocator allocator)
-	{
-		DString s;
-		s.init(allocator);
-		s.appendf(fmt, ...args);
-		in_panic = false;
-		panic(s.str_view(), file, function, line);
-	};
+	$if $defined(io::stderr) && env::PANIC_MSG:
+		if (in_panic)
+		{
+			io::eprint("Panic inside of panic: ");
+			io::eprintn(fmt);
+			return;
+		}
+		in_panic = true;
+		@stack_mem(512; Allocator allocator)
+		{
+			DString s;
+			s.init(allocator);
+			s.appendf(fmt, ...args);
+			in_panic = false;
+			panic(s.str_view(), file, function, line);
+		};
+	$endif
 }

 <*
 Marks the path as unreachable. This will panic in safe mode, and in fast will simply be assumed
 never happens.
- @param [in] string "The panic message or format string"
+ @param [in] string : "The panic message or format string"
 *>
 macro void unreachable(String string = "Unreachable statement reached.", ...) @builtin @noreturn
 {
 	$if env::COMPILER_SAFE_MODE:
 	panicf(string, $$FILE, $$FUNC, $$LINE, $vasplat);
-	$endif;
+	$else
 	$$unreachable();
+	$endif
 }

 <*
 Marks the path as unsupported, this is similar to unreachable.
- @param [in] string "The error message"
+ @param [in] string : "The error message"
 *>
 macro void unsupported(String string = "Unsupported function invoked") @builtin @noreturn
 {
@@ -200,11 +284,11 @@ macro any.as_inner(&self)
 }

 <*
- @param expr "the expression to cast"
- @param $Type "the type to cast to"
+ @param expr : "the expression to cast"
+ @param $Type : "the type to cast to"

- @require $sizeof(expr) == $Type.sizeof  "Cannot bitcast between types of different size."
- @ensure @typeis(return, $Type)
+ @require $sizeof(expr) == $Type.sizeof  : "Cannot bitcast between types of different size."
+ @ensure $typeof(return) == $Type*
 *>
 macro bitcast(expr, $Type) @builtin
 {
@@ -218,11 +302,11 @@ macro bitcast(expr, $Type) @builtin
 }

 <*
- @param $Type `The type of the enum`
- @param [in] enum_name `The name of the enum to search for`
- @require $Type.kindof == ENUM `Only enums may be used`
- @ensure @typeis(return, $Type)
- @return! SearchResult.MISSING
+ @param $Type : `The type of the enum`
+ @param [in] enum_name : `The name of the enum to search for`
+ @require $Type.kindof == ENUM : `Only enums may be used`
+ @ensure $typeof(return) == $Type*
+ @return? NOT_FOUND
 *>
 macro enum_by_name($Type, String enum_name) @builtin
 {
@@ -231,37 +315,36 @@ macro enum_by_name($Type, String enum_name) @builtin
 	{
 		if (name == enum_name) return $Type.from_ordinal(i);
 	}
-	return SearchResult.MISSING?;
+	return NOT_FOUND?;
 }

 <*
- @param $Type `The type of the enum`
- @require $Type.kindof == ENUM `Only enums may be used`
- @require $defined($Type.#value) `Expected '#value' to match an enum associated value`
- @require $assignable(value, $typeof(($Type){}.#value)) `Expected the value to match the type of the associated value`
- @ensure @typeis(return, $Type)
- @return! SearchResult.MISSING
+ @param $Type : `The type of the enum`
+ @require $Type.kindof == ENUM : `Only enums may be used`
+ @require $defined($Type.#value) : `Expected '#value' to match an enum associated value`
+ @require $defined($typeof(($Type){}.#value) v = value) : `Expected the value to match the type of the associated value`
+ @ensure $typeof(return) == $Type*
+ @return? NOT_FOUND
 *>
-macro @enum_from_value($Type, #value, value) @builtin
+macro @enum_from_value($Type, #value, value) @builtin @deprecated("Use Enum.lookup_field and Enum.lookup")
 {
-	usz elements = $Type.elements;
 	foreach (e : $Type.values)
 	{
 		if (e.#value == value) return e;
 	}
-	return SearchResult.MISSING?;
+	return NOT_FOUND?;
 }

 <*
 Mark an expression as likely to be true

- @param #value "expression to be marked likely"
- @param $probability "in the range 0 - 1"
+ @param #value : "expression to be marked likely"
+ @param $probability : "in the range 0 - 1"
 @require $probability >= 0 && $probability <= 1.0
 *>
 macro bool @likely(bool #value, $probability = 1.0) @builtin
 {
-	$switch
+	$switch:
 	$case env::BUILTIN_EXPECT_IS_DISABLED:
 	return #value;
 	$case $probability == 1.0:
@@ -274,13 +357,13 @@ macro bool @likely(bool #value, $probability = 1.0) @builtin
 <*
 Mark an expression as unlikely to be true

- @param #value "expression to be marked unlikely"
- @param $probability "in the range 0 - 1"
+ @param #value : "expression to be marked unlikely"
+ @param $probability : "in the range 0 - 1"
 @require $probability >= 0 && $probability <= 1.0
 *>
 macro bool @unlikely(bool #value, $probability = 1.0) @builtin
 {
-	$switch
+	$switch:
 	$case env::BUILTIN_EXPECT_IS_DISABLED:
 	return #value;
 	$case $probability == 1.0:
@@ -292,12 +375,12 @@ macro bool @unlikely(bool #value, $probability = 1.0) @builtin

 <*
 @require values::@is_int(#value) || values::@is_bool(#value)
- @require $assignable(expected, $typeof(#value))
+ @require $defined($typeof(#value) v = expected)
 @require $probability >= 0 && $probability <= 1.0
 *>
 macro @expect(#value, expected, $probability = 1.0) @builtin
 {
-	$switch
+	$switch:
 	$case env::BUILTIN_EXPECT_IS_DISABLED:
 	return #value == expected;
 	$case $probability == 1.0:
@@ -322,9 +405,9 @@ enum PrefetchLocality
 <*
 Prefetch a pointer.

- @param [in] ptr `Pointer to prefetch`
- @param $locality `Locality ranging from none to extremely local`
- @param $write `Prefetch for write, otherwise prefetch for read.`
+ @param [in] ptr : `Pointer to prefetch`
+ @param $locality : `Locality ranging from none to extremely local`
+ @param $write : `Prefetch for write, otherwise prefetch for read.`
 *>
 macro @prefetch(void* ptr, PrefetchLocality $locality = VERY_NEAR, bool $write = false) @builtin
 {
@@ -342,13 +425,41 @@ macro swizzle2(v, v2, ...) @builtin
 {
 	return $$swizzle2(v, v2, $vasplat);
 }
+
+
+<*
+ Returns the count of leading zero bits from an integer at compile-time.
+
+ @require types::is_int($typeof($value)) : "Input value must be an integer"
+ @require $sizeof($value) * 8 <= 128 : "Input value must be 128 bits wide or lower"
+*>
+macro uint @clz($value) @builtin @const
+{
+	$if $value == 0:
+		return $sizeof($value) * 8;   // it's all leading zeroes
+	$endif
+
+	usz $n = 0;
+	uint128 $x = (uint128)$value;
+
+	$if $x <= 0x0000_0000_0000_0000_FFFF_FFFF_FFFF_FFFF: $n += 64; $x <<= 64; $endif
+	$if $x <= 0x0000_0000_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF: $n += 32; $x <<= 32; $endif
+	$if $x <= 0x0000_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF: $n += 16; $x <<= 16; $endif
+	$if $x <= 0x00FF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF: $n += 8;  $x <<= 8;  $endif
+	$if $x <= 0x0FFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF: $n += 4;  $x <<= 4;  $endif
+	$if $x <= 0x3FFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF: $n += 2;  $x <<= 2;  $endif
+	$if $x <= 0x7FFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF: $n += 1;             $endif
+
+	return $n % ($sizeof($value) * 8);   // mod by the bitsize of the input value to go back from uint128 -> it's-type
+}
+
 <*
 Return the excuse in the Optional if it is Empty, otherwise
 return a null fault.

- @require @typekind(#expr) == OPTIONAL : `@catch expects an Optional value`
+ @require $kindof(#expr) == OPTIONAL : `@catch expects an Optional value`
 *>
-macro anyfault @catch(#expr) @builtin
+macro fault @catch(#expr) @builtin
 {
 	if (catch f = #expr) return f;
 	return {};
@@ -358,7 +469,7 @@ macro anyfault @catch(#expr) @builtin
 Check if an Optional expression holds a value or is empty, returning true
 if it has a value.

- @require @typekind(#expr) == OPTIONAL : `@ok expects an Optional value`
+ @require $kindof(#expr) == OPTIONAL : `@ok expects an Optional value`
 *>
 macro bool @ok(#expr) @builtin
 {
@@ -367,7 +478,68 @@ macro bool @ok(#expr) @builtin
 }

 <*
- @require $defined(&#value, (char*)&#value) "This must be a value that can be viewed as a char array"
+ Check if an Optional expression evaluates to a fault. If so, return it;
+ else, assign the result to an expression.
+
+ @require $defined(#v = #v) : "#v must be a variable"
+ @require $defined(#expr!) : "Expected an optional expression"
+ @require $defined(#v = #expr!!)  : `Type of #expr must be an optional of #v's type`
+*>
+macro void? @try(#v, #expr) @builtin @maydiscard
+{
+	var res = #expr;
+	if (catch err = res) return err?;
+	#v = res;
+}
+
+<*
+ Check if an Optional expression evaluates to a fault. If so, return true if it is the
+ expected fault, the optional if it is unexpected, or false if there was no fault and
+ the assign happened.
+
+ This can be used in like this:
+
+  while (true)
+  {
+	char[] data;
+	// Read until end of file
+	if (@try_catch(data, load_line(), io::EOF)!) break;
+	.. use data ..
+  }
+
+ In this example we read until we reach an EOF, which is expected. However, if we encounter some other
+ fault, we rethrow is. Without this macro, the code is instead written like:
+
+  while (true)
+  {
+	char[]? data;
+	data = load_line();
+	if (catch err = data)
+	{
+	  if (err = io::EOF) break;
+	  return err?
+	}
+	.. use data ..
+  }
+
+ @require $defined(#v = #v) : "#v must be a variable"
+ @require $defined(#expr!) : "Expected an optional expression"
+ @require $defined(#v = #expr!!)  : `Type of #expr must be an optional of #v's type`
+ @return "True if it was the expected fault, false if the variable was assigned, otherwise returns an optional."
+*>
+macro bool? @try_catch(#v, #expr, fault expected_fault) @builtin
+{
+	var res = #expr;
+	if (catch err = res)
+	{
+		return err == expected_fault ? true : err?;
+	}
+	#v = res;
+	return false;
+}
+
+<*
+ @require $defined(&#value, (char*)&#value) : "This must be a value that can be viewed as a char array"
 *>
 macro char[] @as_char_view(#value) @builtin
 {
@@ -378,6 +550,27 @@ macro isz @str_find(String $string, String $needle) @builtin => $$str_find($stri
 macro String @str_upper(String $str) @builtin => $$str_upper($str);
 macro String @str_lower(String $str) @builtin => $$str_lower($str);
 macro uint @str_hash(String $str) @builtin => $$str_hash($str);
+macro String @str_pascalcase(String $str) @builtin => $$str_pascalcase($str);
+macro String @str_snakecase(String $str) @builtin => $$str_snakecase($str);
+macro String @str_camelcase(String $str) @builtin => @str_capitalize($$str_pascalcase($str));
+macro String @str_constantcase(String $str) @builtin => @str_upper($$str_snakecase($str));
+macro String @str_replace(String $str, String $pattern, String $replace, uint $limit = 0) @builtin => $$str_replace($str, $pattern, $replace, $limit);
+macro String @str_capitalize(String $str) @builtin
+{
+	$switch $str.len:
+		$case 0: return $str;
+		$case 1: return $$str_upper($str);
+		$default: return $$str_upper($str[0:1]) +++ $str[1..];
+	$endswitch
+}
+macro String @str_uncapitalize(String $str) @builtin
+{
+	$switch $str.len:
+		$case 0: return $str;
+		$case 1: return $$str_lower($str);
+		$default: return $$str_lower($str[0:1]) +++ $str[1..];
+	$endswitch
+}

 macro @generic_hash_core(h, value)
 {
@@ -387,36 +580,85 @@ macro @generic_hash_core(h, value)
 	return h;
 }

-macro @generic_hash(value)
+macro uint @generic_hash(value)
 {
 	uint h = @generic_hash_core((uint)0x3efd4391, value);
-	$for (var $cnt = 4; $cnt < $sizeof(value); $cnt += 4)
+	$for var $cnt = 4; $cnt < $sizeof(value); $cnt += 4:
 		value >>= 32; // reduce value
 		h = @generic_hash_core(h, value);
 	$endfor
 	return h;
 }

-macro uint int.hash(int i) => @generic_hash(i);
-macro uint uint.hash(uint i) => @generic_hash(i);
-macro uint short.hash(short s) => @generic_hash(s);
-macro uint ushort.hash(ushort s) => @generic_hash(s);
-macro uint char.hash(char c) => @generic_hash(c);
-macro uint ichar.hash(ichar c) => @generic_hash(c);
-macro uint long.hash(long i) => @generic_hash(i);
-macro uint ulong.hash(ulong i) => @generic_hash(i);
-macro uint int128.hash(int128 i) => @generic_hash(i);
-macro uint uint128.hash(uint128 i) => @generic_hash(i);
-macro uint bool.hash(bool b) => @generic_hash(b);
+
+macro uint int128.hash(self)       => @generic_hash(self);
+macro uint uint128.hash(self)      => @generic_hash(self);
+macro uint long.hash(self)         => @generic_hash(self);
+macro uint ulong.hash(self)        => @generic_hash(self);
+macro uint int.hash(self)          => @generic_hash(self);
+macro uint uint.hash(self)         => @generic_hash(self);
+macro uint short.hash(self)        => @generic_hash(self);
+macro uint ushort.hash(self)       => @generic_hash(self);
+macro uint ichar.hash(self)        => @generic_hash(self);
+macro uint char.hash(self)         => @generic_hash(self);
+macro uint bool.hash(self)         => @generic_hash(self);
+
+macro uint int128[*].hash(&self)   => hash_array(self);
+macro uint uint128[*].hash(&self)  => hash_array(self);
+macro uint long[*].hash(&self)     => hash_array(self);
+macro uint ulong[*].hash(&self)    => hash_array(self);
+macro uint int[*].hash(&self)      => hash_array(self);
+macro uint uint[*].hash(&self)     => hash_array(self);
+macro uint short[*].hash(&self)    => hash_array(self);
+macro uint ushort[*].hash(&self)   => hash_array(self);
+macro uint char[*].hash(&self)     => hash_array(self);
+macro uint ichar[*].hash(&self)    => hash_array(self);
+macro uint bool[*].hash(&self)     => hash_array(self);
+
+macro uint int128[<*>].hash(self)  => hash_vec(self);
+macro uint uint128[<*>].hash(self) => hash_vec(self);
+macro uint long[<*>].hash(self)    => hash_vec(self);
+macro uint ulong[<*>].hash(self)   => hash_vec(self);
+macro uint int[<*>].hash(self)     => hash_vec(self);
+macro uint uint[<*>].hash(self)    => hash_vec(self);
+macro uint short[<*>].hash(self)   => hash_vec(self);
+macro uint ushort[<*>].hash(self)  => hash_vec(self);
+macro uint char[<*>].hash(self)    => hash_vec(self);
+macro uint ichar[<*>].hash(self)   => hash_vec(self);
+macro uint bool[<*>].hash(self)    => hash_vec(self);
+
 macro uint typeid.hash(typeid t) => @generic_hash(((ulong)(uptr)t));
-macro uint String.hash(String c) => (uint)fnv32a::encode(c);
-macro uint char[].hash(char[] c) => (uint)fnv32a::encode(c);
+macro uint String.hash(String c) => (uint)a5hash::hash(c);
+macro uint char[].hash(char[] c) => (uint)a5hash::hash(c);
 macro uint void*.hash(void* ptr) => @generic_hash(((ulong)(uptr)ptr));

-distinct EmptySlot = void*;
-const EmptySlot EMPTY_MACRO_SLOT @builtin = null;
-macro @is_empty_macro_slot(#arg) @builtin => @typeis(#arg, EmptySlot);
-macro @is_valid_macro_slot(#arg) @builtin => !@typeis(#arg, EmptySlot);
+<*
+ @require $kindof(array_ptr) == POINTER &&& $kindof(*array_ptr) == ARRAY
+*>
+macro uint hash_array(array_ptr) @local
+{
+	var $len = $sizeof(*array_ptr);
+
+	$if $len > 16:
+		return (uint)komi::hash(((char*)array_ptr)[:$len]);
+	$else
+		return (uint)wyhash2::hash(((char*)array_ptr)[:$len]);
+	$endif
+}
+
+<*
+ @require $kindof(vec) == VECTOR
+*>
+macro uint hash_vec(vec) @local
+{
+	var $len = $sizeof(vec.len * $typeof(vec).inner.sizeof);
+
+	$if $len > 16:
+		return (uint)komi::hash(((char*)&&vec)[:$len]);
+	$else
+		return (uint)wyhash2::hash(((char*)&&vec)[:$len]);
+	$endif
+}

 const MAX_FRAMEADDRESS = 128;
 <*
@@ -701,24 +943,21 @@ macro void* get_returnaddress(int n)
 	}
 }

-module std::core::builtin @if((env::LINUX || env::DARWIN) && env::COMPILER_SAFE_MODE && env::DEBUG_SYMBOLS);
-import libc, std::io;
+module std::core::builtin @if((env::LINUX || env::ANDROID || env::DARWIN) && env::COMPILER_SAFE_MODE && env::DEBUG_SYMBOLS);
+import libc, std::io, std::os::posix;

 fn void sig_panic(String message)
 {
 	default_panic(message, "???", "???", 0);
 }

-SignalFunction old_bus_error;
-SignalFunction old_segmentation_fault;
-
-fn void sig_bus_error(CInt i)
+fn void sig_bus_error(CInt i, void* info, void* context)
 {
 	$if !env::NATIVE_STACKTRACE:
 		sig_panic("Illegal memory access.");
 	$else
 		$if $defined(io::stderr):
-			if (!print_backtrace("Illegal memory access.", 1))
+			if (!print_backtrace("Illegal memory access.", 2, posix::stack_instruction(context)))
 			{
 				io::eprintn("\nERROR: 'Illegal memory access'.");
 			}
@@ -727,13 +966,13 @@ fn void sig_bus_error(CInt i)
 	$$trap();
 }

-fn void sig_segmentation_fault(CInt i)
+fn void sig_segmentation_fault(CInt i, void* p1, void* context)
 {
 	$if !env::NATIVE_STACKTRACE:
 		sig_panic("Out of bounds memory access.");
 	$else
 		$if $defined(io::stderr):
-			if (!print_backtrace("Out of bounds memory access.", 1))
+			if (!print_backtrace("Out of bounds memory access.", 2, posix::stack_instruction(context)))
 			{
 				io::eprintn("\nERROR: Memory error without backtrace, possible stack overflow.");
 			}
@@ -742,17 +981,12 @@ fn void sig_segmentation_fault(CInt i)
 	$$trap();
 }

-fn void install_signal_handler(CInt signal, SignalFunction func) @local
-{
-	SignalFunction old = libc::signal(signal, func);
-	// Restore
-	if ((iptr)old > 1024) libc::signal(signal, old);
-}
+

 // Clean this up
 fn void install_signal_handlers() @init(101) @local @if(env::BACKTRACE)
 {
-	install_signal_handler(libc::SIGBUS, &sig_bus_error);
-	install_signal_handler(libc::SIGSEGV, &sig_segmentation_fault);
+	posix::install_signal_handler(libc::SIGBUS, &sig_bus_error);
+	posix::install_signal_handler(libc::SIGSEGV, &sig_segmentation_fault);
 }

--- a/lib/std/core/builtin_comparison.c3
+++ b/lib/std/core/builtin_comparison.c3
@@ -6,9 +6,9 @@ module std::core::builtin;
 <*
 @require types::@comparable_value(a) && types::@comparable_value(b)
 *>
-macro less(a, b) @builtin
+macro bool less(a, b) @builtin
 {
-	$switch
+	$switch:
 	$case $defined(a.less):
 		return a.less(b);
 	$case $defined(a.compare_to):
@@ -21,9 +21,9 @@ macro less(a, b) @builtin
 <*
 @require types::@comparable_value(a) && types::@comparable_value(b)
 *>
-macro less_eq(a, b) @builtin
+macro bool less_eq(a, b) @builtin
 {
-	$switch
+	$switch:
 	$case $defined(a.less):
 		return !b.less(a);
 	$case $defined(a.compare_to):
@@ -36,9 +36,9 @@ macro less_eq(a, b) @builtin
 <*
 @require types::@comparable_value(a) && types::@comparable_value(b)
 *>
-macro greater(a, b) @builtin
+macro bool greater(a, b) @builtin
 {
-	$switch
+	$switch:
 	$case $defined(a.less):
 		return b.less(a);
 	$case $defined(a.compare_to):
@@ -53,7 +53,7 @@ macro greater(a, b) @builtin
 *>
 macro int compare_to(a, b) @builtin
 {
-	$switch
+	$switch:
 	$case $defined(a.compare_to):
 		return a.compare_to(b);
 	$case $defined(a.less):
@@ -65,9 +65,9 @@ macro int compare_to(a, b) @builtin
 <*
 @require types::@comparable_value(a) && types::@comparable_value(b)
 *>
-macro greater_eq(a, b) @builtin
+macro bool greater_eq(a, b) @builtin
 {
-	$switch
+	$switch:
 	$case $defined(a.less):
 		return !a.less(b);
 	$case $defined(a.compare_to):
@@ -78,11 +78,11 @@ macro greater_eq(a, b) @builtin
 }

 <*
- @require types::@equatable_value(a) && types::@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
 {
-	$switch
+	$switch:
 	$case $defined(a.equals, a.equals(b)):
 		return a.equals(b);
 	$case $defined(a.compare_to, a.compare_to(b)):
@@ -100,7 +100,7 @@ macro min(x, ...) @builtin
 		return less(x, $vaarg[0]) ? x : $vaarg[0];
 	$else
 		var result = x;
-		$for (var $i = 0; $i < $vacount; $i++)
+		$for var $i = 0; $i < $vacount; $i++:
 			if (less($vaarg[$i], result))
 			{
 				 result = $vaarg[$i];
@@ -116,7 +116,7 @@ macro max(x, ...) @builtin
 		return greater(x, $vaarg[0]) ? x : $vaarg[0];
 	$else
 		var result = x;
-		$for (var $i = 0; $i < $vacount; $i++)
+		$for var $i = 0; $i < $vacount; $i++:
 			if (greater($vaarg[$i], result))
 			{
 				 result = $vaarg[$i];
@@ -126,3 +126,36 @@ macro max(x, ...) @builtin
 	$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
+}
+
--- a/lib/std/core/cinterop.c3
+++ b/lib/std/core/cinterop.c3
@@ -2,6 +2,8 @@
 // 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;
@@ -16,18 +18,18 @@ $assert C_SHORT_SIZE <= C_INT_SIZE;
 $assert C_INT_SIZE <= C_LONG_SIZE;
 $assert C_LONG_SIZE <= C_LONG_LONG_SIZE;

-def CShort = $typefrom(signed_int_from_bitsize($$C_SHORT_SIZE));
-def CUShort = $typefrom(unsigned_int_from_bitsize($$C_SHORT_SIZE));
-def CInt = $typefrom(signed_int_from_bitsize($$C_INT_SIZE));
-def CUInt = $typefrom(unsigned_int_from_bitsize($$C_INT_SIZE));
-def CLong = $typefrom(signed_int_from_bitsize($$C_LONG_SIZE));
-def CULong = $typefrom(unsigned_int_from_bitsize($$C_LONG_SIZE));
-def CLongLong = $typefrom(signed_int_from_bitsize($$C_LONG_LONG_SIZE));
-def CULongLong = $typefrom(unsigned_int_from_bitsize($$C_LONG_LONG_SIZE));
-def CSChar = ichar;
-def CUChar = char;
+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;

-def CChar = $typefrom($$C_CHAR_IS_SIGNED ? ichar.typeid : char.typeid);
+alias CChar = $typefrom($$C_CHAR_IS_SIGNED ? ichar.typeid : char.typeid);

 enum CBool : char
 {
@@ -38,7 +40,7 @@ enum CBool : char
 // Helper macros
 macro typeid signed_int_from_bitsize(usz $bitsize) @private
 {
-	$switch ($bitsize)
+	$switch $bitsize:
 		$case 128: return int128.typeid;
 		$case 64: return long.typeid;
 		$case 32: return int.typeid;
@@ -50,7 +52,7 @@ macro typeid signed_int_from_bitsize(usz $bitsize) @private

 macro typeid unsigned_int_from_bitsize(usz $bitsize) @private
 {
-	$switch ($bitsize)
+	$switch $bitsize:
 		$case 128: return uint128.typeid;
 		$case 64: return ulong.typeid;
 		$case 32: return uint.typeid;
@@ -59,3 +61,57 @@ macro typeid unsigned_int_from_bitsize(usz $bitsize) @private
 		$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);
+
+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;
+}
+
+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
+}
--- a/lib/std/core/conv.c3
+++ b/lib/std/core/conv.c3
@@ -10,30 +10,31 @@ 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 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)
+fn usz? char32_to_utf8(Char32 c, char[] output)
 {
-	if (!output.len) return UnicodeResult.CONVERSION_FAILED?;
+	if (!output.len) return string::CONVERSION_FAILED?;
 	switch (true)
 	{
 		case c <= 0x7f:
 			output[0] = (char)c;
 			return 1;
 		case c <= 0x7ff:
-			if (output.len < 2) return UnicodeResult.CONVERSION_FAILED?;
+			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 (output.len < 3) return UnicodeResult.CONVERSION_FAILED?;
+			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 UnicodeResult.CONVERSION_FAILED?;
+			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));
@@ -41,15 +42,15 @@ fn usz! char32_to_utf8(Char32 c, char[] output)
 			return 4;
 		default:
 			// 0x10FFFF and above is not defined.
-			return UnicodeResult.CONVERSION_FAILED?;
+			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.`
+ @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)
 {
@@ -69,11 +70,11 @@ fn void char32_to_utf16_unsafe(Char32 c, Char16** 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.`
+ @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)
+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)
@@ -83,15 +84,15 @@ fn void! char16_to_utf8_unsafe(Char16 *ptr, usz *available, char** output)
 		return;
 	}
 	// Low surrogate first is an error
-	if (high & UTF16_SURROGATE_MASK != UTF16_SURROGATE_HIGH_VALUE) return UnicodeResult.INVALID_UTF16?;
+	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
@@ -101,8 +102,8 @@ fn void! char16_to_utf8_unsafe(Char16 *ptr, usz *available, char** output)
 	*available = 2;
 }
 <*
- @param c `The utf32 codepoint to convert`
- @param [inout] output `the resulting buffer`
+ @param c : `The utf32 codepoint to convert`
+ @param [inout] output : `the resulting buffer`
 *>
 fn usz char32_to_utf8_unsafe(Char32 c, char** output)
 {
@@ -130,14 +131,14 @@ fn usz char32_to_utf8_unsafe(Char32 c, char** output)
 }

 <*
- @param [in] ptr `pointer to the first character to parse`
- @param [inout] size `Set to max characters to read, set to characters read`
+ @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)
+fn Char32? utf8_to_char32(char* ptr, usz* size)
 {
 	usz max_size = *size;
-	if (max_size < 1) return UnicodeResult.INVALID_UTF8?;
+	if (max_size < 1) return string::INVALID_UTF8?;
 	char c = (ptr++)[0];

 	if ((c & 0x80) == 0)
@@ -147,45 +148,45 @@ fn Char32! utf8_to_char32(char* ptr, usz* size)
 	}
 	if ((c & 0xE0) == 0xC0)
 	{
-		if (max_size < 2) return UnicodeResult.INVALID_UTF8?;
+		if (max_size < 2) return string::INVALID_UTF8?;
 		*size = 2;
 		Char32 uc = (c & 0x1F) << 6;
 		c = *ptr;
 		// Overlong sequence or invalid second.
-		if (!uc || c & 0xC0 != 0x80) return UnicodeResult.INVALID_UTF8?;
+		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?;
+		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];
 		// Overlong sequence or invalid last
-		if (!uc || c & 0xC0 != 0x80) return UnicodeResult.INVALID_UTF8?;
+		if (!uc || c & 0xC0 != 0x80) return string::INVALID_UTF8?;
 		return uc + c & 0x3F;
 	}
-	if (max_size < 4) return UnicodeResult.INVALID_UTF8?;
-	if ((c & 0xF8) != 0xF0) return UnicodeResult.INVALID_UTF8?;
+	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];
 	// Overlong sequence or invalid last
-	if (!uc || c & 0xC0 != 0x80) return UnicodeResult.INVALID_UTF8?;
+	if (!uc || c & 0xC0 != 0x80) return string::INVALID_UTF8?;
 	return uc + c & 0x3F;
 }

 <*
- @param utf8 `An UTF-8 encoded slice of bytes`
+ @param utf8 : `An UTF-8 encoded slice of bytes`
 @return `the number of encoded code points`
 *>
 fn usz utf8_codepoints(String utf8)
@@ -200,7 +201,7 @@ fn usz utf8_codepoints(String utf8)

 <*
 Calculate the UTF8 length required to encode an UTF32 array.
- @param [in] utf32 `the utf32 data to calculate from`
+ @param [in] utf32 : `the utf32 data to calculate from`
 @return `the length of the resulting UTF8 array`
 *>
 fn usz utf8len_for_utf32(Char32[] utf32)
@@ -225,7 +226,7 @@ fn usz utf8len_for_utf32(Char32[] utf32)

 <*
 Calculate the UTF8 length required to encode an UTF16 array.
- @param [in] utf16 `the utf16 data to calculate from`
+ @param [in] utf16 : `the utf16 data to calculate from`
 @return `the length of the resulting UTF8 array`
 *>
 fn usz utf8len_for_utf16(Char16[] utf16)
@@ -257,7 +258,7 @@ fn usz utf8len_for_utf16(Char16[] utf16)

 <*
 Calculate the UTF16 length required to encode a UTF8 array.
- @param utf8 `the utf8 data to calculate from`
+ @param utf8 : `the utf8 data to calculate from`
 @return `the length of the resulting UTF16 array`
 *>
 fn usz utf16len_for_utf8(String utf8)
@@ -280,7 +281,7 @@ fn usz utf16len_for_utf8(String utf8)
 }

 <*
- @param [in] utf32 `the UTF32 array to check the length for`
+ @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)
@@ -300,7 +301,7 @@ fn usz utf16len_for_utf32(Char32[] utf32)
 @param [out] utf8_buffer
 @return `the number of bytes written.`
 *>
-fn usz! utf32to8(Char32[] utf32, char[] utf8_buffer)
+fn usz? utf32to8(Char32[] utf32, char[] utf8_buffer)
 {
 	char[] buffer = utf8_buffer;
 	foreach (uc : utf32)
@@ -320,7 +321,7 @@ fn usz! utf32to8(Char32[] utf32, char[] utf8_buffer)
 @param [out] utf32_buffer
 @return `the number of Char32s written.`
 *>
-fn usz! utf8to32(String utf8, Char32[] utf32_buffer)
+fn usz? utf8to32(String utf8, Char32[] utf32_buffer)
 {
 	usz len = utf8.len;
 	Char32* ptr = utf32_buffer.ptr;
@@ -328,7 +329,7 @@ fn usz! utf8to32(String utf8, Char32[] utf32_buffer)
 	usz buf_len = utf32_buffer.len;
 	for (usz i = 0; i < len;)
 	{
-		if (len32 == buf_len) return UnicodeResult.CONVERSION_FAILED?;
+		if (len32 == buf_len) return string::CONVERSION_FAILED?;
 		usz width = len - i;
 		Char32 uc = utf8_to_char32(&utf8[i], &width) @inline!;
 		i += width;
@@ -344,10 +345,10 @@ fn usz! utf8to32(String utf8, Char32[] utf32_buffer)
 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.`
+ @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)
+fn void? utf16to8_unsafe(Char16[] utf16, char* utf8_buffer)
 {
 	usz len16 = utf16.len;
 	for (usz i = 0; i < len16;)
@@ -363,10 +364,10 @@ fn void! utf16to8_unsafe(Char16[] utf16, char* utf8_buffer)
 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.`
+ @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)
+fn void? utf8to32_unsafe(String utf8, Char32* utf32_buffer)
 {
 	usz len = utf8.len;
 	for (usz i = 0; i < len;)
@@ -383,10 +384,10 @@ fn void! utf8to32_unsafe(String utf8, Char32* utf32_buffer)
 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.`
+ @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)
+fn void? utf8to16_unsafe(String utf8, Char16* utf16_buffer)
 {
 	usz len = utf8.len;
 	for (usz i = 0; i < len;)
@@ -403,8 +404,8 @@ fn void! utf8to16_unsafe(String utf8, Char16* utf16_buffer)
 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.`
+ @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)
 {
--- a/lib/std/core/dstring.c3
+++ b/lib/std/core/dstring.c3
@@ -1,26 +1,21 @@
 module std::core::dstring;
 import std::io;

-distinct DString (OutStream) = DStringOpaque*;
-distinct DStringOpaque = void;
+<*
+ The DString offers a dynamic string builder.
+*>
+typedef DString (OutStream) = DStringOpaque*;
+typedef DStringOpaque = void;

 const usz MIN_CAPACITY @private = 16;

 <*
- @require !self.data() "String already initialized"
-*>
-fn DString DString.new_init(&self, usz capacity = MIN_CAPACITY, Allocator allocator = allocator::heap()) @deprecated("Use init(mem)")
-{
-	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 a particular allocator.

-<*
- @require !self.data() "String already initialized"
+ @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)
 {
@@ -33,34 +28,29 @@ fn DString DString.init(&self, Allocator allocator, usz capacity = MIN_CAPACITY)
 }

 <*
- @require !self.data() "String already initialized"
-*>
-fn DString DString.temp_init(&self, usz capacity = MIN_CAPACITY) @deprecated("Use tinit()")
-{
-	self.init(allocator::temp(), capacity) @inline;
-	return *self;
-}
+ Initialize the DString with the temp allocator. Note that if the dstring is never
+ initialized, this is the allocator it will default to.

-<*
- @require !self.data() "String already initialized"
+ @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)
 {
-	self.init(allocator::temp(), capacity) @inline;
-	return *self;
+	return self.init(tmem, capacity) @inline;
 }

-fn DString new_with_capacity(usz capacity, Allocator allocator = allocator::heap())
+fn DString new_with_capacity(Allocator allocator, usz capacity)
 {
 	return (DString){}.init(allocator, capacity);
 }

-fn DString temp_with_capacity(usz capacity) => new_with_capacity(capacity, allocator::temp()) @inline;
+fn DString temp_with_capacity(usz capacity) => new_with_capacity(tmem, capacity) @inline;

-fn DString new(String c = "", Allocator allocator = allocator::heap())
+fn DString new(Allocator allocator, String c = "")
 {
 	usz len = c.len;
-	StringData* data = (StringData*)new_with_capacity(len, allocator);
+	StringData* data = (StringData*)new_with_capacity(allocator, len);
 	if (len)
 	{
 		data.len = len;
@@ -69,7 +59,7 @@ fn DString new(String c = "", Allocator allocator = allocator::heap())
 	return (DString)data;
 }

-fn DString temp_new(String s = "") => new(s, allocator::temp()) @inline;
+fn DString temp(String s = "") => new(tmem, s) @inline;


 fn void DString.replace_char(self, char ch, char replacement)
@@ -92,7 +82,8 @@ fn void DString.replace(&self, String needle, String replacement)
 		self.replace_char(needle[0], replacement[0]);
 		return;
 	}
-	@pool(data.allocator) {
+	@pool()
+	{
 		String str = self.tcopy_str();
 		self.clear();
 		usz len = str.len;
@@ -121,7 +112,7 @@ fn void DString.replace(&self, String needle, String replacement)
 	};
 }

-fn DString DString.new_concat(self, DString b, Allocator allocator = allocator::heap()) @deprecated("Use concat(mem)")
+fn DString DString.concat(self, Allocator allocator, DString b) @nodiscard
 {
 	DString string;
 	string.init(allocator, self.len() + b.len());
@@ -130,16 +121,7 @@ fn DString DString.new_concat(self, DString b, Allocator allocator = allocator::
 	return string;
 }

-fn DString DString.concat(self, Allocator allocator, DString b)
-{
-	DString string;
-	string.init(allocator, self.len() + b.len());
-	string.append(self);
-	string.append(b);
-	return string;
-}
-
-fn DString DString.temp_concat(self, DString b) => self.concat(allocator::temp(), b);
+fn DString DString.tconcat(self, DString b) => self.concat(tmem, b);

 fn ZString DString.zstr_view(&self)
 {
@@ -188,7 +170,7 @@ fn String DString.str_view(self)

 <*
 @require index < self.len()
- @require self.data() != null "Empty string"
+ @require self.data() != null : "Empty string"
 *>
 fn char DString.char_at(self, usz index) @operator([])
 {
@@ -197,7 +179,7 @@ fn char DString.char_at(self, usz index) @operator([])

 <*
 @require index < self.len()
- @require self.data() != null  "Empty string"
+ @require self.data() != null  : "Empty string"
 *>
 fn char* DString.char_ref(&self, usz index) @operator(&[])
 {
@@ -249,23 +231,18 @@ fn usz DString.append_char32(&self, Char32 c)
 	return n;
 }

-fn DString DString.tcopy(&self) => self.copy(allocator::temp());
+fn DString DString.tcopy(&self) => self.copy(tmem);

-fn DString DString.copy(self, Allocator allocator = null)
+fn DString DString.copy(self, Allocator allocator) @nodiscard
 {
-	if (!self)
-	{
-		if (allocator) return new_with_capacity(0, allocator);
-		return (DString)null;
-	}
+	if (!self) return new(allocator);
 	StringData* data = self.data();
-	if (!allocator) allocator = allocator::heap();
-	DString new_string = new_with_capacity(data.capacity, allocator);
+	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 = allocator::heap())
+fn ZString DString.copy_zstr(self, Allocator allocator) @nodiscard
 {
 	usz str_len = self.len();
 	if (!str_len)
@@ -279,12 +256,12 @@ fn ZString DString.copy_zstr(self, Allocator allocator = allocator::heap())
 	return (ZString)zstr;
 }

-fn String DString.copy_str(self, Allocator allocator = allocator::heap())
+fn String DString.copy_str(self, Allocator allocator) @nodiscard
 {
 	return (String)self.copy_zstr(allocator)[:self.len()];
 }

-fn String DString.tcopy_str(self) => self.copy_str(allocator::temp()) @inline;
+fn String DString.tcopy_str(self) @nodiscard => self.copy_str(tmem) @inline;

 fn bool DString.equals(self, DString other_string)
 {
@@ -334,7 +311,7 @@ fn void DString.append_chars(&self, String str)
 	if (!other_len) return;
 	if (!*self)
 	{
-		*self = new(str);
+		*self = temp(str);
 		return;
 	}
 	self.reserve(other_len);
@@ -343,7 +320,7 @@ fn void DString.append_chars(&self, String str)
 	data.len += other_len;
 }

-fn Char32[] DString.copy_utf32(&self, Allocator allocator = allocator::heap())
+fn Char32[] DString.copy_utf32(&self, Allocator allocator)
 {
 	return self.str_view().to_utf32(allocator) @inline!!;
 }
@@ -361,13 +338,13 @@ fn void DString.clear(self)
 	self.data().len = 0;
 }

-fn usz! DString.write(&self, char[] buffer) @dynamic
+fn usz? DString.write(&self, char[] buffer) @dynamic
 {
 	self.append_chars((String)buffer);
 	return buffer.len;
 }

-fn void! DString.write_byte(&self, char c) @dynamic
+fn void? DString.write_byte(&self, char c) @dynamic
 {
 	self.append_char(c);
 }
@@ -376,7 +353,7 @@ fn void DString.append_char(&self, char c)
 {
 	if (!*self)
 	{
-		*self = new_with_capacity(MIN_CAPACITY);
+		*self = temp_with_capacity(MIN_CAPACITY);
 	}
 	self.reserve(1);
 	StringData* data = self.data();
@@ -386,7 +363,7 @@ fn void DString.append_char(&self, char c)
 <*
 @require start < self.len()
 @require end < self.len()
- @require end >= start "End must be same or equal to the start"
+ @require end >= start : "End must be same or equal to the start"
 *>
 fn void DString.delete_range(&self, usz start, usz end)
 {
@@ -418,7 +395,7 @@ fn void DString.delete(&self, usz start, usz len = 1)
 macro void DString.append(&self, value)
 {
 	var $Type = $typeof(value);
-	$switch ($Type)
+	$switch $Type:
 		$case char:
 		$case ichar:
 			self.append_char(value);
@@ -429,7 +406,7 @@ macro void DString.append(&self, value)
 		$case Char32:
 			self.append_char32(value);
 		$default:
-			$switch
+			$switch:
 				$case $defined((Char32)value):
 					self.append_char32((Char32)value);
 				$case $defined((String)value):
@@ -550,7 +527,7 @@ fn usz DString.insert_utf32_at(&self, usz index, Char32[] chars)
 macro void DString.insert_at(&self, usz index, value)
 {
 	var $Type = $typeof(value);
-	$switch ($Type)
+	$switch $Type:
 		$case char:
 		$case ichar:
 			self.insert_char_at(index, value);
@@ -561,7 +538,7 @@ macro void DString.insert_at(&self, usz index, value)
 		$case Char32:
 			self.insert_char32_at(index, value);
 		$default:
-			$switch
+			$switch:
 				$case $defined((Char32)value):
 					self.insert_char32_at(index, (Char32)value);
 				$case $defined((String)value):
@@ -572,21 +549,19 @@ macro void DString.insert_at(&self, usz index, value)
 	$endswitch
 }

-fn usz! DString.appendf(&self, String format, args...) @maydiscard
+import libc;
+fn usz? DString.appendf(&self, String format, args...) @maydiscard
 {
-	if (!self.data()) self.init(mem, format.len + 20);
-	@pool(self.data().allocator)
-	{
-		Formatter formatter;
-		formatter.init(&out_string_append_fn, self);
-		return formatter.vprintf(format, args);
-	};
+	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
+fn usz? DString.appendfn(&self, String format, args...) @maydiscard
 {
-	if (!self.data()) self.init(mem, format.len + 20);
-	@pool(self.data().allocator)
+	if (!self.data()) self.tinit(format.len + 20);
+	@pool()
 	{
 		Formatter formatter;
 		formatter.init(&out_string_append_fn, self);
@@ -596,25 +571,25 @@ fn usz! DString.appendfn(&self, String format, args...) @maydiscard
 	};
 }

-fn DString new_join(String[] s, String joiner, Allocator allocator = allocator::heap())
+fn DString join(Allocator allocator, String[] s, String joiner) @nodiscard
 {
-	if (!s.len) return (DString)null;
+	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(total_size, allocator);
+	DString res = new_with_capacity(allocator, total_size);
 	res.append(s[0]);
-	foreach (String* &str : s[1..])
+	foreach (String str : s[1..])
 	{
 		res.append(joiner);
-		res.append(*str);
+		res.append(str);
 	}
 	return res;
 }

-fn void! out_string_append_fn(void* data, char c) @private
+fn void? out_string_append_fn(void* data, char c) @private
 {
 	DString* s = data;
 	s.append_char(c);
@@ -644,7 +619,7 @@ fn void DString.reserve(&self, usz addition)
 	StringData* data = self.data();
 	if (!data)
 	{
-		*self = dstring::new_with_capacity(addition);
+		*self = dstring::temp_with_capacity(addition);
 		return;
 	}
 	usz len = data.len + addition;
@@ -656,7 +631,7 @@ fn void DString.reserve(&self, usz addition)
 	*self = (DString)allocator::realloc(data.allocator, data, StringData.sizeof + new_capacity);
 }

-fn usz! DString.read_from_stream(&self, InStream reader)
+fn usz? DString.read_from_stream(&self, InStream reader)
 {
 	if (&reader.available)
 	{
@@ -691,5 +666,5 @@ struct StringData @private
 	Allocator allocator;
 	usz len;
 	usz capacity;
-	char[?] chars;
+	char[*] chars;
 }
--- a/lib/std/core/env.c3
+++ b/lib/std/core/env.c3
@@ -57,6 +57,7 @@ enum OsType
 	HURD,
 	WASI,
 	EMSCRIPTEN,
+	ANDROID,
 }

 enum ArchType
@@ -119,6 +120,7 @@ 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;
@@ -135,12 +137,13 @@ 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 || WIN32;
+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;
@@ -150,15 +153,23 @@ 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_NOLIBC @builtin = !LIBC && 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 && (ARCH_TYPE == ArchType.WASM32 || ARCH_TYPE == ArchType.WASM64);
+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;

 macro bool os_is_darwin() @const
 {
-	$switch (OS_TYPE)
+	$switch OS_TYPE:
 	$case IOS:
 	$case MACOS:
 	$case TVOS:
@@ -171,7 +182,7 @@ macro bool os_is_darwin() @const

 macro bool os_is_posix() @const
 {
-	$switch (OS_TYPE)
+	$switch OS_TYPE:
 	$case IOS:
 	$case MACOS:
 	$case NETBSD:
@@ -182,6 +193,7 @@ macro bool os_is_posix() @const
 	$case SOLARIS:
 	$case TVOS:
 	$case WATCHOS:
+	$case ANDROID:
 		return true;
 	$case WIN32:
 	$case WASI:
@@ -192,6 +204,8 @@ macro bool os_is_posix() @const
 		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);
--- a/lib/std/core/logging.c3
+++ b/lib/std/core/logging.c3
@@ -0,0 +1,239 @@
+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  = 0;
+const LogCategory CATEGORY_SYSTEM       = 1;
+const LogCategory CATEGORY_KERNEL       = 2;
+const LogCategory CATEGORY_AUDIO        = 3;
+const LogCategory CATEGORY_VIDEO        = 4;
+const LogCategory CATEGORY_RENDER       = 5;
+const LogCategory CATEGORY_INPUT        = 6;
+const LogCategory CATEGORY_NETWORK      = 7;
+const LogCategory CATEGORY_SOCKET       = 8;
+const LogCategory CATEGORY_SECURITY     = 9;
+const LogCategory CATEGORY_TEST         = 10;
+const LogCategory CATEGORY_ERROR        = 11;
+const LogCategory CATEGORY_ASSERT       = 12;
+const LogCategory CATEGORY_CRASH        = 13;
+const LogCategory CATEGORY_STATS        = 14;
+const LogCategory CATEGORY_CUSTOM_START = 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() && @ok(logger_mutex.lock());
+	Logger logger = current_logger;
+	LogFn logfn = current_logfn;
+	defer if (locked) (void)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"
+};
--- a/lib/std/core/mem.c3
+++ b/lib/std/core/mem.c3
--- a/lib/std/core/mem_allocator.c3
+++ b/lib/std/core/mem_allocator.c3
@@ -1,4 +1,18 @@
 module std::core::mem::allocator;
+import std::math;
+
+// 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 DEFAULT_SIZE_PREFIX = usz.sizeof;
 const DEFAULT_SIZE_PREFIX_ALIGNMENT = usz.alignof;
@@ -18,36 +32,40 @@ enum AllocInitType

 interface Allocator
 {
-	fn void reset(usz mark) @optional;
-	fn usz mark() @optional;
 	<*
+	 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
+	 @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);
+	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 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);
+	fn void*? resize(void* ptr, usz new_size, usz alignment = 0);
+
 	<*
-	 @require ptr != null
+	 Release memory acquired using `acquire` or `resize`.
+
+	 @require ptr != null : "Empty pointers should never be released"
 	*>
 	fn void release(void* ptr, bool aligned);
 }

-def MemoryAllocFn = fn char[]!(usz);
+alias MemoryAllocFn = fn char[]?(usz);

-fault AllocationFailure
-{
-	OUT_OF_MEMORY,
-	CHUNK_TOO_LARGE,
-}

-fn usz alignment_for_allocation(usz alignment) @inline @private
+
+fn usz alignment_for_allocation(usz alignment) @inline
 {
 	return alignment < mem::DEFAULT_MEM_ALIGNMENT ? mem::DEFAULT_MEM_ALIGNMENT : alignment;
 }
@@ -57,7 +75,7 @@ macro void* malloc(Allocator allocator, usz size) @nodiscard
 	return malloc_try(allocator, size)!!;
 }

-macro void*! malloc_try(Allocator allocator, usz size) @nodiscard
+macro void*? malloc_try(Allocator allocator, usz size) @nodiscard
 {
 	if (!size) return null;
 	$if env::TESTING:
@@ -74,7 +92,7 @@ macro void* calloc(Allocator allocator, usz size) @nodiscard
 	return calloc_try(allocator, size)!!;
 }

-macro void*! calloc_try(Allocator allocator, usz size) @nodiscard
+macro void*? calloc_try(Allocator allocator, usz size) @nodiscard
 {
 	if (!size) return null;
 	return allocator.acquire(size, ZERO);
@@ -85,7 +103,7 @@ macro void* realloc(Allocator allocator, void* ptr, usz new_size) @nodiscard
 	return realloc_try(allocator, ptr, new_size)!!;
 }

-macro void*! realloc_try(Allocator allocator, void* ptr, usz new_size) @nodiscard
+macro void*? realloc_try(Allocator allocator, void* ptr, usz new_size) @nodiscard
 {
 	if (!new_size)
 	{
@@ -105,7 +123,7 @@ macro void free(Allocator allocator, void* ptr)
 	allocator.release(ptr, false);
 }

-macro void*! malloc_aligned(Allocator allocator, usz size, usz alignment) @nodiscard
+macro void*? malloc_aligned(Allocator allocator, usz size, usz alignment) @nodiscard
 {
 	if (!size) return null;
 	$if env::TESTING:
@@ -117,13 +135,13 @@ macro void*! malloc_aligned(Allocator allocator, usz size, usz alignment) @nodis
 	$endif
 }

-macro void*! calloc_aligned(Allocator allocator, usz size, usz alignment) @nodiscard
+macro void*? calloc_aligned(Allocator allocator, usz size, usz alignment) @nodiscard
 {
 	if (!size) return null;
 	return allocator.acquire(size, ZERO, alignment);
 }

-macro void*! realloc_aligned(Allocator allocator, void* ptr, usz new_size, usz alignment) @nodiscard
+macro void*? realloc_aligned(Allocator allocator, void* ptr, usz new_size, usz alignment) @nodiscard
 {
 	if (!new_size)
 	{
@@ -149,7 +167,7 @@ macro void free_aligned(Allocator allocator, void* ptr)
 <*
 @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 ||| $assignable($vaexpr[0], $Type) : "The second argument must be an initializer for the type"
+ @require $vacount == 0 ||| $defined($Type t = $vaexpr[0]) : "The second argument must be an initializer for the type"
 *>
 macro new(Allocator allocator, $Type, ...) @nodiscard
 {
@@ -165,7 +183,7 @@ macro new(Allocator allocator, $Type, ...) @nodiscard
 <*
 @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 ||| $assignable($vaexpr[0], $Type) : "The second argument must be an initializer for the type"
+ @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
 {
@@ -182,7 +200,7 @@ macro new_try(Allocator allocator, $Type, ...) @nodiscard
 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 ||| $assignable($vaexpr[0], $Type) : "The second argument must be an initializer for the type"
+ @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
 {
@@ -286,11 +304,48 @@ macro alloc_array_try(Allocator allocator, $Type, usz elements) @nodiscard
 	return (($Type*)malloc_try(allocator, $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
+{
+	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;
@@ -305,12 +360,12 @@ fn any clone_any(Allocator allocator, any value) @nodiscard
 @require alignment > 0
 @require bytes <= isz.max
 *>
-macro void*! @aligned_alloc(#alloc_fn, usz bytes, usz alignment)
+macro void*? @aligned_alloc(#alloc_fn, usz bytes, usz alignment)
 {
 	if (alignment < void*.alignof) alignment = void*.alignof;
 	usz header = AlignedBlock.sizeof + alignment;
 	usz alignsize = bytes + header;
-	$if @typekind(#alloc_fn(bytes)) == OPTIONAL:
+	$if $kindof(#alloc_fn(bytes)) == OPTIONAL:
 		void* data = #alloc_fn(alignsize)!;
 	$else
 		void* data = #alloc_fn(alignsize);
@@ -328,10 +383,10 @@ struct AlignedBlock
 	void* start;
 }

-macro void! @aligned_free(#free_fn, void* old_pointer)
+macro void? @aligned_free(#free_fn, void* old_pointer)
 {
 	AlignedBlock* desc = (AlignedBlock*)old_pointer - 1;
-	$if @typekind(#free_fn(desc.start)) == OPTIONAL:
+	$if $kindof(#free_fn(desc.start)) == OPTIONAL:
 	#free_fn(desc.start)!;
 	$else
 	#free_fn(desc.start);
@@ -342,13 +397,13 @@ macro void! @aligned_free(#free_fn, void* old_pointer)
 @require bytes > 0
 @require alignment > 0
 *>
-macro void*! @aligned_realloc(#calloc_fn, #free_fn, void* old_pointer, usz bytes, usz alignment)
+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 @typekind(#free_fn(data_start)) == OPTIONAL:
+	$if $kindof(#free_fn(data_start)) == OPTIONAL:
 	#free_fn(data_start)!;
 	$else
 	#free_fn(data_start);
@@ -358,14 +413,34 @@ macro void*! @aligned_realloc(#calloc_fn, #free_fn, void* old_pointer, usz bytes


 // All allocators
-
-
-def mem = thread_allocator @builtin;
+alias mem @builtin = thread_allocator ;
 tlocal Allocator thread_allocator @private = base_allocator();
 Allocator temp_base_allocator @private = base_allocator();

-tlocal TempAllocator* thread_temp_allocator @private = null;
-tlocal TempAllocator*[2] temp_allocator_pair @private;
+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
 {
@@ -376,36 +451,69 @@ macro Allocator base_allocator() @private
 	$endif
 }

-macro TempAllocator* create_default_sized_temp_allocator(Allocator allocator) @local
+macro usz temp_allocator_size() @local
 {
-	$switch (env::MEMORY_ENV)
-	$case NORMAL:
-		return new_temp_allocator(1024 * 256, allocator)!!;
-	$case SMALL:
-		return new_temp_allocator(1024 * 16, allocator)!!;
-	$case TINY:
-		return new_temp_allocator(1024 * 2, allocator)!!;
-	$case NONE:
-		unreachable("Temp allocator must explicitly created when memory-env is set to 'none'.");
+	$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 Allocator heap() => thread_allocator;
-
-macro TempAllocator* temp()
+macro usz temp_allocator_default_min_size() @local
 {
-	if (!thread_temp_allocator)
-	{
-		init_default_temp_allocators();
-	}
-	return thread_temp_allocator;
+	$switch env::MEMORY_ENV:
+		$case NORMAL: return 16 * 1024;
+		$case SMALL: return 1024 * 2;
+		$case TINY: return 256;
+		$case NONE: return 256;
+	$endswitch
 }

-fn void init_default_temp_allocators() @private
+macro usz temp_allocator_default_reserve_size() @local
 {
-	temp_allocator_pair[0] = create_default_sized_temp_allocator(temp_base_allocator);
-	temp_allocator_pair[1] = create_default_sized_temp_allocator(temp_base_allocator);
-	thread_temp_allocator = temp_allocator_pair[0];
+	$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)
@@ -418,35 +526,42 @@ fn void destroy_temp_allocators_after_exit() @finalizer(65535) @local @if(env::L
 *>
 fn void destroy_temp_allocators()
 {
-	if (!thread_temp_allocator) return;
-	temp_allocator_pair[0].destroy();
-	temp_allocator_pair[1].destroy();
-	temp_allocator_pair[..] = null;
-	thread_temp_allocator = null;
+	if (!top_temp) return;
+	top_temp.free();
+	top_temp = null;
+	current_temp = &LAZY_TEMP;
 }

-fn TempAllocator* temp_allocator_next() @private
+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
 {
-	if (!thread_temp_allocator)
-	{
-		init_default_temp_allocators();
-		return thread_temp_allocator;
-	}
-	usz index = thread_temp_allocator == temp_allocator_pair[0] ? 1 : 0;
-	return thread_temp_allocator = temp_allocator_pair[index];
 }

 const NullAllocator NULL_ALLOCATOR = {};
-distinct NullAllocator (Allocator) = uptr;
+typedef NullAllocator (Allocator) = uptr;

-fn void*! NullAllocator.acquire(&self, usz bytes, AllocInitType init_type, usz alignment) @dynamic
+fn void*? NullAllocator.acquire(&self, usz bytes, AllocInitType init_type, usz alignment) @dynamic
 {
-	return AllocationFailure.OUT_OF_MEMORY?;
+	return mem::OUT_OF_MEMORY?;
 }

-fn void*! NullAllocator.resize(&self, void* old_ptr, usz new_bytes, usz alignment) @dynamic
+fn void*? NullAllocator.resize(&self, void* old_ptr, usz new_bytes, usz alignment) @dynamic
 {
-	return AllocationFailure.OUT_OF_MEMORY?;
+	return mem::OUT_OF_MEMORY?;
 }

 fn void NullAllocator.release(&self, void* old_ptr, bool aligned) @dynamic
--- a/lib/std/core/mem_mempool.c3
+++ b/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"
+*>
+macro 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 = self.allocate_page();
+	$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
+	self.free_page(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
+		self.free_page(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) self.new_node();
+	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 self.check_ptr(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(&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(&self) @local
+{
+	FixedBlockPoolNode* node = allocator::new(self.allocator, FixedBlockPoolNode);
+	node.buffer = self.allocate_page();
+	$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(&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(&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;
+}
--- a/lib/std/core/os/mem_vm.c3
+++ b/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) @private
+{
+	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) @private
+{
+	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;
+	}
+}
+
--- a/lib/std/core/os/wasm/wasm_memory.c3
+++ b/lib/std/core/os/wasm/wasm_memory.c3
@@ -11,7 +11,7 @@ struct WasmMemory
 	uptr use;
 }

-fn char[]! WasmMemory.allocate_block(&self, usz bytes)
+fn char[]? WasmMemory.allocate_block(&self, usz bytes)
 {
 	if (!self.allocation)
 	{
@@ -25,7 +25,7 @@ fn char[]! WasmMemory.allocate_block(&self, usz bytes)
 	}

 	usz blocks_required = (bytes_required + WASM_BLOCK_SIZE + 1) / WASM_BLOCK_SIZE;
-	if ($$wasm_memory_grow(0, blocks_required) == -1) return AllocationFailure.OUT_OF_MEMORY?;
+	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];
--- a/lib/std/core/os/wasm_memory.c3
+++ b/lib/std/core/os/wasm_memory.c3
@@ -1,32 +0,0 @@
-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 AllocationFailure.OUT_OF_MEMORY?;
-	self.allocation = $$wasm_memory_size(0) * WASM_BLOCK_SIZE;
-	defer self.use += bytes;
-	return ((char*)self.use)[:bytes];
-}
--- a/lib/std/core/private/cpu_detect.c3
+++ b/lib/std/core/private/cpu_detect.c3
@@ -143,7 +143,7 @@ uint128 x86_features;

 fn void add_feature_if_bit(X86Feature feature, uint register, int bit)
 {
-	if (register & 1U << bit) x86_features |= 1u128 << feature.ordinal;
+	if (register & 1U << bit) x86_features |= 1ULL << feature.ordinal;
 }

 fn void x86_initialize_cpu_features()
--- a/lib/std/core/private/macho_runtime.c3
+++ b/lib/std/core/private/macho_runtime.c3
@@ -56,10 +56,7 @@ struct MachHeader64

 const LC_SEGMENT_64 = 0x19;

-fault MachoSearch
-{
-	NOT_FOUND
-}
+
 fn bool name_cmp(char* a, char[16]* b)
 {
 	for (usz i = 0; i < 16; i++)
@@ -70,7 +67,7 @@ fn bool name_cmp(char* a, char[16]* b)
 	return false;
 }

-fn SegmentCommand64*! find_segment(MachHeader* header, char* segname)
+fn SegmentCommand64*? find_segment(MachHeader* header, char* segname)
 {
 	LoadCommand* command = (void*)header + MachHeader64.sizeof;
 	for (uint i = 0; i < header.ncmds; i++)
@@ -82,9 +79,9 @@ fn SegmentCommand64*! find_segment(MachHeader* header, char* segname)
 		}
 		command = (void*)command + command.cmdsize;
 	}
-	return MachoSearch.NOT_FOUND?;
+	return NOT_FOUND?;
 }
-fn Section64*! find_section(SegmentCommand64* command, char* sectname)
+fn Section64*? find_section(SegmentCommand64* command, char* sectname)
 {
 	Section64* section = (void*)command + SegmentCommand64.sizeof;
 	for (uint i = 0; i < command.nsects; i++)
@@ -92,13 +89,13 @@ fn Section64*! find_section(SegmentCommand64* command, char* sectname)
 		if (name_cmp(sectname, &section.sectname)) return section;
 		section++;
 	}
-	return MachoSearch.NOT_FOUND?;
+	return NOT_FOUND?;
 }

 macro find_segment_section_body(MachHeader* header, char* segname, char* sectname, $Type)
 {

-	Section64*! section = find_section(find_segment(header, segname), sectname);
+	Section64*? section = find_section(find_segment(header, segname), sectname);
 	if (catch section)
 	{
 		return ($Type[]){};
@@ -107,7 +104,7 @@ macro find_segment_section_body(MachHeader* header, char* segname, char* sectnam
 	return ptr[:section.size / $Type.sizeof];
 }

-def DyldCallback = fn void (MachHeader* mh, isz vmaddr_slide);
+alias DyldCallback = fn void (MachHeader* mh, isz vmaddr_slide);

 extern fn void _dyld_register_func_for_add_image(DyldCallback);

@@ -126,7 +123,7 @@ extern fn void* realloc(void* ptr, usz size);
 extern fn void* malloc(usz size);
 extern fn void free(void* ptr);

-def CallbackFn = fn void();
+alias CallbackFn = fn void();
 struct Callback
 {
 	uint priority;
@@ -214,7 +211,7 @@ struct TypeId
 	usz sizeof;
 	TypeId* inner;
 	usz len;
-	typeid[?] additional;
+	typeid[*] additional;
 }

 fn void dl_reg_callback(MachHeader* mh, isz vmaddr_slide)
--- a/lib/std/core/private/main_stub.c3
+++ b/lib/std/core/private/main_stub.c3
@@ -64,7 +64,7 @@ macro int @main_to_void_main_args(#m, int argc, char** argv)

 module std::core::main_stub @if(env::WIN32);

-extern fn Char16** _win_command_line_to_argv_w(ushort* cmd_line, int* argc_ptr) @extern("CommandLineToArgvW");
+extern fn Char16** _win_command_line_to_argv_w(ushort* cmd_line, int* argc_ptr) @cname("CommandLineToArgvW");

 macro String[] win_command_line_to_strings(ushort* cmd_line) @private
 {
@@ -80,7 +80,7 @@ macro String[] wargs_strings(int argc, Char16** argv) @private
 	{
 		Char16* arg = argv[i];
 		Char16[] argstring = arg[:_strlen(arg)];
-		list[i] = string::new_from_utf16(argstring) ?? "?".copy();
+		list[i] = string::from_utf16(mem, argstring) ?? "?".copy(mem);
 	}
 	return list[:argc];
 }
--- a/lib/std/core/refcount.c3
+++ b/lib/std/core/refcount.c3
@@ -0,0 +1,132 @@
+<*
+ Ref provides a general *external* ref counted wrapper for a pointer. For convenience, a ref count of 0
+ means the reference is still valid.
+
+ When the rc drops to -1, it will first run the dealloc function on the underlying pointer (if it exists),
+ then free the pointer and the atomic variable assuming that they are allocated using the Allocator in the Ref.
+
+ @require !$defined(Type.dealloc) ||| $defined(Type.dealloc(&&(Type){})) : "'dealloc' must only take a pointer to the underlying type"
+ @require !$defined(Type.dealloc) ||| $typeof((Type){}.dealloc()) ==  void : "'dealloc' must return 'void'"
+*>
+module std::core::mem::ref { Type };
+import std::thread, std::atomic;
+
+const OVERALIGNED @private = Type.alignof > mem::DEFAULT_MEM_ALIGNMENT;
+
+alias DeallocFn = fn void(void*);
+
+fn Ref wrap(Type* ptr, Allocator allocator = mem)
+{
+	return { .refcount = allocator::new(allocator, Atomic{int}), .ptr = ptr, .allocator = allocator };
+}
+<*
+ @require $vacount < 2 : "Too many arguments."
+ @require $vacount == 0 ||| $defined(Type a = $vaexpr[0]) : "The first argument must be an initializer for the type"
+*>
+macro Ref new(..., Allocator allocator = mem)
+{
+
+	$switch:
+		$case OVERALIGNED && !$vacount:
+			Type* ptr = allocator::calloc_aligned(allocator, Type.sizeof, Type.alignof)!!;
+		$case OVERALIGNED:
+			Type* ptr = allocator::malloc_aligned(allocator, Type.sizeof, Type.alignof)!!;
+			*ptr = $vaexpr[0];
+		$case !$vacount:
+			Type* ptr = allocator::calloc(allocator, Type.sizeof);
+		$default:
+			Type* ptr = allocator::malloc(allocator, Type.sizeof);
+			*ptr = $vaexpr[0];
+	$endswitch
+	return { .refcount = allocator::new(allocator, Atomic{int}),
+	         .ptr = ptr,
+	         .allocator = allocator };
+}
+
+struct Ref
+{
+	Atomic{int}* refcount;
+	Type* ptr;
+	Allocator allocator;
+}
+
+fn Ref* Ref.retain(&self)
+{
+	assert(self.refcount != null, "Reference already released");
+	assert(self.refcount.load(RELAXED) >= 0, "Retaining zombie");
+	self.refcount.add(1, RELAXED);
+	return self;
+}
+
+fn void Ref.release(&self)
+{
+	assert(self.refcount != null, "Reference already released");
+    assert(self.refcount.load(RELAXED) >= 0, "Overrelease of refcount");
+	if (self.refcount.sub(1, RELAXED) == 0)
+	{
+		thread::fence(ACQUIRE);
+		$if $defined(Type.dealloc):
+			self.ptr.dealloc();
+		$endif
+		$if OVERALIGNED:
+			allocator::free_aligned(self.allocator, self.ptr);
+		$else
+			allocator::free(self.allocator, self.ptr);
+		$endif
+		allocator::free(self.allocator, self.refcount);
+		*self = {};
+	}
+}
+
+module std::core::mem::rc;
+import std::thread, std::atomic;
+
+<*
+ A RefCounted struct should be an inline base of a struct.
+ If a `dealloc` is defined, then it will be called rather than `free`
+
+ For convenience, a ref count of 0 is still valid, and the struct is
+ only freed when when ref count drops to -1.
+
+ The macros rc::retain and rc::release must be used on the full pointer,
+ not on the RefCounted substruct.
+
+ So `Foo* f = ...; RefCounted* rc = f; rc::release(rc);` will not do the right thing.
+*>
+struct RefCounted
+{
+	Atomic{int} refcount;
+}
+
+<*
+ @require $defined(RefCounted* c = refcounted) : "Expected a ref counted value"
+*>
+macro retain(refcounted)
+{
+	if (refcounted)
+	{
+		assert(refcounted.refcount.load(RELAXED) >= 0, "Retaining zombie");
+    	refcounted.refcount.add(1, RELAXED);
+	}
+	return refcounted;
+}
+
+<*
+ @require $defined(RefCounted* c = refcounted) : "Expected a ref counted value"
+ @require !$defined(refcounted.dealloc()) ||| $typeof(refcounted.dealloc()) == void
+   : "Expected refcounted type to have a valid dealloc"
+*>
+macro void release(refcounted)
+{
+	if (!refcounted) return;
+	assert(refcounted.refcount.load(RELAXED) >= 0, "Overrelease of refcount");
+	if (refcounted.refcount.sub(1, RELAXED) == 0)
+	{
+		thread::fence(ACQUIRE);
+		$if $defined(refcounted.dealloc):
+			refcounted.dealloc();
+		$else
+			free(refcounted);
+		$endif
+	}
+}
--- a/lib/std/core/runtime.c3
+++ b/lib/std/core/runtime.c3
@@ -22,11 +22,27 @@ struct SliceRaw
 	usz len;
 }

+macro @enum_lookup($Type, #value, value)
+{
+	$foreach $val : $Type.values:
+		if ($val.#value == value) return $val;
+	$endforeach
+	return NOT_FOUND?;
+}

-module std::core::runtime @if(WASM_NOLIBC);
+macro @enum_lookup_new($Type, $name, value)
+{
+	$foreach $val : $Type.values:
+		if ($val.$eval($name) == value) return $val;
+	$endforeach
+	return NOT_FOUND?;
+}
+
+
+module std::core::runtime @if(env::FREESTANDING_WASM);

 extern fn void __wasm_call_ctors();
-fn void wasm_initialize() @extern("_initialize") @wasm
+fn void wasm_initialize() @cname("_initialize") @wasm
 {
 	// The linker synthesizes this to call constructors.
 	__wasm_call_ctors();
--- a/lib/std/core/runtime_benchmark.c3
+++ b/lib/std/core/runtime_benchmark.c3
@@ -1,8 +1,9 @@
 module std::core::runtime;
-import libc, std::time, std::io, std::sort;
+import libc, std::time, std::io, std::sort, std::math, std::collections::map;

-def BenchmarkFn = fn void!() @if($$OLD_TEST);
-def BenchmarkFn = fn void() @if(!$$OLD_TEST);
+alias BenchmarkFn = fn void ();
+
+HashMap { String, uint } bench_fn_iters @local;

 struct BenchmarkUnit
 {
@@ -10,7 +11,7 @@ struct BenchmarkUnit
 	BenchmarkFn func;
 }

-fn BenchmarkUnit[] benchmark_collection_create(Allocator allocator = allocator::heap())
+fn BenchmarkUnit[] benchmark_collection_create(Allocator allocator)
 {
 	BenchmarkFn[] fns = $$BENCHMARK_FNS;
 	String[] names = $$BENCHMARK_NAMES;
@@ -18,6 +19,7 @@ fn BenchmarkUnit[] benchmark_collection_create(Allocator allocator = allocator::
 	foreach (i, benchmark : fns)
 	{
 		benchmarks[i] = { names[i], fns[i] };
+		if (!bench_fn_iters.has_key(names[i])) bench_fn_iters[names[i]] = benchmark_max_iterations;
 	}
 	return benchmarks;
 }
@@ -37,82 +39,52 @@ fn void set_benchmark_max_iterations(uint value) @builtin
 {
    assert(value > 0);
    benchmark_max_iterations = value;
+	foreach (k : bench_fn_iters.key_iter()) bench_fn_iters[k] = value;
 }

-fn bool run_benchmarks(BenchmarkUnit[] benchmarks) @if($$OLD_TEST)
+fn void set_benchmark_func_iterations(String func, uint value) @builtin
 {
-	int benchmarks_passed = 0;
-	int benchmark_count = benchmarks.len;
-	usz max_name;
-
-	foreach (&unit : benchmarks)
-	{
-		if (max_name < unit.name.len) max_name = unit.name.len;
-	}
-
-	usz len = max_name + 9;
-
-	DString name = dstring::temp_with_capacity(64);
-	name.append_repeat('-', len / 2);
-	name.append(" BENCHMARKS ");
-	name.append_repeat('-', len - len / 2);
-
-	io::printn(name);
-
-	name.clear();
-
-	long sys_clock_started;
-	long sys_clock_finished;
-	long sys_clocks;
-	Clock clock;
-	anyfault err;
-
-	foreach(unit : benchmarks)
-	{
-		defer name.clear();
-		name.appendf("Benchmarking %s ", unit.name);
-		name.append_repeat('.', max_name - unit.name.len + 2);
-		io::printf("%s ", name.str_view());
-
-		for (uint i = 0; i < benchmark_warmup_iterations; i++)
-		{
-			err = @catch(unit.func()) @inline;
-			@volatile_load(err);
-		}
-
-		clock = std::time::clock::now();
-		sys_clock_started = $$sysclock();
-
-		for (uint i = 0; i < benchmark_max_iterations; i++)
-		{
-			err = @catch(unit.func()) @inline;
-			@volatile_load(err);
-		}
-
-		sys_clock_finished = $$sysclock();
-		NanoDuration nano_seconds = clock.mark();
-		sys_clocks = sys_clock_finished - sys_clock_started;
-
-		if (err)
-		{
-			io::printfn("[failed] Failed due to: %s", err);
-			continue;
-		}
-
-		io::printfn("[ok] %.2f ns, %.2f CPU's clocks", (float)nano_seconds / benchmark_max_iterations, (float)sys_clocks / benchmark_max_iterations);
-		benchmarks_passed++;
-	}
-
-	io::printfn("\n%d benchmark%s run.\n", benchmark_count, benchmark_count > 1 ? "s" : "");
-	io::printfn("Benchmarks Result: %s. %d passed, %d failed.",
-		benchmarks_passed < benchmark_count ? "FAILED" : "ok",
-		benchmarks_passed,
-		benchmark_count - benchmarks_passed);
-
-	return benchmark_count == benchmarks_passed;
+	assert(value > 0);
+	bench_fn_iters[func] = value;
 }

-fn bool run_benchmarks(BenchmarkUnit[] benchmarks) @if(!$$OLD_TEST)
+
+Clock benchmark_clock @local;
+NanoDuration benchmark_nano_seconds @local;
+long cycle_start @local;
+long cycle_stop @local;
+DString benchmark_log @local;
+bool benchmark_warming @local;
+uint this_iteration @local;
+bool benchmark_stop @local;
+
+macro void @start_benchmark()
+{
+	benchmark_clock = clock::now();
+	cycle_start = $$sysclock();
+}
+
+macro void @end_benchmark()
+{
+	benchmark_nano_seconds = benchmark_clock.mark();
+	cycle_stop = $$sysclock();
+}
+
+macro void @kill_benchmark(String format, ...)
+{
+	@log_benchmark(format, $vasplat);
+	benchmark_stop = true;
+}
+
+macro void @log_benchmark(msg, args...) => @pool()
+{
+	if (benchmark_warming) return;
+
+	benchmark_log.appendf("%s [%d]:  ", $$FUNC, this_iteration);
+	benchmark_log.appendfn(msg, ...args);
+}
+
+fn bool run_benchmarks(BenchmarkUnit[] benchmarks)
 {
 	usz max_name;

@@ -132,36 +104,69 @@ fn bool run_benchmarks(BenchmarkUnit[] benchmarks) @if(!$$OLD_TEST)

 	name.clear();

-	long sys_clock_started;
-	long sys_clock_finished;
-	long sys_clocks;
-	Clock clock;
-
-	foreach(unit : benchmarks)
+	foreach (unit : benchmarks)
 	{
 		defer name.clear();
 		name.appendf("Benchmarking %s ", unit.name);
 		name.append_repeat('.', max_name - unit.name.len + 2);
 		io::printf("%s ", name.str_view());

+		benchmark_warming = true;
 		for (uint i = 0; i < benchmark_warmup_iterations; i++)
 		{
 			unit.func() @inline;
 		}
+		benchmark_warming = false;

-		clock = std::time::clock::now();
-		sys_clock_started = $$sysclock();
+		NanoDuration running_timer;
+		long total_clocks;

-		for (uint i = 0; i < benchmark_max_iterations; i++)
+		uint current_benchmark_iterations = bench_fn_iters[unit.name] ?? benchmark_max_iterations;
+		char[] perc_str = { [0..19] = ' ', [20] = 0 };
+		int perc = 0;
+		uint print_step = current_benchmark_iterations / 100;
+
+		for (this_iteration = 0; this_iteration < current_benchmark_iterations; ++this_iteration, benchmark_nano_seconds = {})
 		{
+			if (0 == this_iteration % print_step)   // only print right about when the % will update
+			{
+				perc_str[0..(uint)math::floor((this_iteration / (float)current_benchmark_iterations) * 20)] = '#';
+				perc = (uint)math::ceil(100 * (this_iteration / (float)current_benchmark_iterations));
+
+				io::printf("\r%s [%s] %d / %d (%d%%)", name.str_view(), (ZString)perc_str, this_iteration, current_benchmark_iterations, perc);
+				io::stdout().flush()!!;
+			}
+
+			@start_benchmark();   // can be overridden by calls inside the unit's func
+
 			unit.func() @inline;
+			if (benchmark_stop) return false;
+
+			if (benchmark_nano_seconds == (NanoDuration){}) @end_benchmark();   // only mark when it wasn't already by the unit.func
+
+			total_clocks += cycle_stop - cycle_start;
+			running_timer += benchmark_nano_seconds;
 		}

-		sys_clock_finished = $$sysclock();
-		NanoDuration nano_seconds = clock.mark();
-		sys_clocks = sys_clock_finished - sys_clock_started;
+		float clock_cycles = (float)total_clocks / current_benchmark_iterations;
+		float measurement = (float)running_timer / current_benchmark_iterations;
+		String[] units = { "nanoseconds", "microseconds", "milliseconds", "seconds" };

-		io::printfn("[COMPLETE] %.2f ns, %.2f CPU's clocks", (float)nano_seconds / benchmark_max_iterations, (float)sys_clocks / benchmark_max_iterations);
+		float adjusted_measurement = measurement;
+		while (adjusted_measurement > 1_000) adjusted_measurement /= 1_000;
+		float adjusted_runtime_total = (float)running_timer;
+		while (adjusted_runtime_total > 1_000) adjusted_runtime_total /= 1_000;
+
+		io::printf("\r%s ", name.str_view());
+		io::printfn(
+			"[COMPLETE] %.2f %s, %.2f CPU clocks, %d iterations (runtime %.2f %s)",
+			adjusted_measurement,
+			units[math::min(3, (int)math::floor(math::log(measurement, 1_000)))],
+			clock_cycles,
+			current_benchmark_iterations,
+			adjusted_runtime_total,
+			units[math::min(3, (int)math::floor(math::log((float)running_timer, 1_000)))],
+		);
 	}

 	io::printfn("\n%d benchmark%s run.\n", benchmarks.len, benchmarks.len > 1 ? "s" : "");
@@ -170,5 +175,12 @@ fn bool run_benchmarks(BenchmarkUnit[] benchmarks) @if(!$$OLD_TEST)

 fn bool default_benchmark_runner(String[] args) => @pool()
 {
-	return run_benchmarks(benchmark_collection_create(allocator::temp()));
+	benchmark_log.init(mem);
+	defer
+	{
+		if (benchmark_log.len()) io::printfn("\n---------- BENCHMARK LOG ----------\n%s\n", benchmark_log.str_view());
+		benchmark_log.free();
+	}
+
+	return run_benchmarks(benchmark_collection_create(tmem));
 }
--- a/lib/std/core/runtime_test.c3
+++ b/lib/std/core/runtime_test.c3
@@ -4,21 +4,22 @@
 module std::core::runtime;
 import std::core::test @public;
 import std::core::mem::allocator @public;
-import libc, std::time, std::io, std::sort;
-import std::os::env;
+import libc, std::time, std::io, std::sort, std::os;

-def TestFn = fn void!() @if($$OLD_TEST);
-def TestFn = fn void() @if(!$$OLD_TEST);
+
+alias TestFn = fn void();

 TestContext* test_context @private;

 struct TestContext
 {
 	JmpBuf buf;
-	// Allows filtering test cased or modules by substring, e.g. 'foo::', 'foo::test_add'
+	<* Allows filtering test cased or modules by substring, e.g. 'foo::', 'foo::test_add' *>
 	String test_filter;
-	// Triggers debugger breakpoint when assert or test:: checks failed
+	<* Triggers debugger breakpoint when assert or test:: checks failed *>
 	bool breakpoint_on_assert;
+	<* Controls level of printed logs *>
+	LogPriority log_level;

 	// internal state
 	bool assert_print_backtrace;
@@ -47,7 +48,7 @@ struct TestUnit
 	TestFn func;
 }

-fn TestUnit[] test_collection_create(Allocator allocator = allocator::heap())
+fn TestUnit[] test_collection_create(Allocator allocator)
 {
 	TestFn[] fns = $$TEST_FNS;
 	String[] names = $$TEST_NAMES;
@@ -75,7 +76,8 @@ fn int cmp_test_unit(TestUnit a, TestUnit b)

 fn bool terminal_has_ansi_codes() @local => @pool()
 {
-	if (try v = env::get_var_temp("TERM"))
+
+	if (try v = env::tget_var("TERM"))
 	{
 		if (v.contains("xterm") || v.contains("vt100") || v.contains("screen")) return true;
 	}
@@ -86,7 +88,21 @@ fn bool terminal_has_ansi_codes() @local => @pool()
 	$endif
 }

+fn void sig_bus_error(CInt i, void*, void* context) @local @if(env::POSIX)
+{
+	panic_test("Bus error", "Unknown", "Unknown", 1, posix::stack_instruction(context));
+}
+
+fn void sig_segmentation_fault(CInt i, void*, void* context) @local @if(env::POSIX)
+{
+	panic_test("Segmentation fault", "Unknown", "Unknown", 1, posix::stack_instruction(context));
+}
+
 fn void test_panic(String message, String file, String function, uint line) @local
+{
+	panic_test(message, file, function, line);
+}
+fn void panic_test(String message, String file, String function, uint line, void* extra_trace = null) @local
 {
 	if (test_context.is_in_panic) return;
 	test_context.is_in_panic = true;
@@ -96,7 +112,7 @@ fn void test_panic(String message, String file, String function, uint line) @loc
 	if (test_context.assert_print_backtrace)
 	{
 		$if env::NATIVE_STACKTRACE:
-    		builtin::print_backtrace(message, 0);
+    		builtin::print_backtrace(message, extra_trace ? 3 : 0, extra_trace);
 		$endif
 	}
 	io::printf("\nTest failed ^^^ ( %s:%s ) %s\n",  file, line, message);
@@ -140,7 +156,6 @@ fn void unmute_output(bool has_error) @local
 	usz log_size = test_context.fake_stdout.seek(0, Seek.CURSOR)!!;
 	if (has_error)
 	{
-		io::printf("\nTesting %s ", test_context.current_test_name);
 		io::printn(test_context.has_ansi_codes ? "[\e[0;31mFAIL\e[0m]" : "[FAIL]");
 	}

@@ -166,11 +181,21 @@ fn void unmute_output(bool has_error) @local
 	(void)stdout.flush();
 }

+
 fn bool run_tests(String[] args, TestUnit[] tests) @private
 {
 	usz max_name;
 	bool sort_tests = true;
 	bool check_leaks = true;
+	if (!tests.len)
+	{
+		io::printn("There are no test units to run.");
+		return true;   // no tests == technically a pass
+	}
+$if !env::NO_LIBC && env::POSIX:
+	posix::install_signal_handler(libc::SIGBUS, &sig_bus_error);
+	posix::install_signal_handler(libc::SIGSEGV, &sig_segmentation_fault);
+$endif
 	foreach (&unit : tests)
 	{
 		if (max_name < unit.name.len) max_name = unit.name.len;
@@ -179,9 +204,10 @@ fn bool run_tests(String[] args, TestUnit[] tests) @private
 	{
 		.assert_print_backtrace = true,
 		.breakpoint_on_assert = false,
+		.log_level = LogPriority.ERROR,
 		.test_filter = "",
 		.has_ansi_codes = terminal_has_ansi_codes(),
-		.stored.allocator = allocator::heap(),
+		.stored.allocator = mem,
 		.stored.stderr = *io::stderr(),
 		.stored.stdout = *io::stdout(),
 	};
@@ -196,6 +222,7 @@ fn bool run_tests(String[] args, TestUnit[] tests) @private
 			case "--test-noleak":
 				check_leaks = false;
 			case "--test-nocapture":
+			case "--test-show-output":
 				context.is_no_capture = true;
 			case "--noansi":
 				context.has_ansi_codes = false;
@@ -211,11 +238,28 @@ fn bool run_tests(String[] args, TestUnit[] tests) @private
 				}
 				context.test_filter = args[i + 1];
 				i++;
+			case "--test-log-level":
+				if (i == args.len - 1)
+				{
+					io::printn("Missing log level for argument `--test-log-level`.");
+					return false;
+				}
+				@pool()
+				{
+					String upper = args[i + 1].to_upper_copy(tmem);
+					if (catch @try(context.log_level, enum_by_name(LogPriority, upper)))
+					{
+						io::printn("Log level given to `--test-log-level` is not one of verbose, debug, info, warn, error or critical.");
+						return false;
+					}
+				};
+				i++;
 			default:
 				io::printfn("Unknown argument: %s", args[i]);
 		}
 	}
 	test_context = &context;
+	log::set_priority_all(test_context.log_level);

 	if (sort_tests)
 	{
@@ -244,7 +288,7 @@ fn bool run_tests(String[] args, TestUnit[] tests) @private
 	name.append_repeat('-', len - len / 2);
 	if (!context.is_quiet_mode) io::printn(name);
 	name.clear();
-	TempState temp_state = mem::temp_push();
+	PoolState temp_state = mem::temp_push();
 	defer mem::temp_pop(temp_state);
 	foreach(unit : tests)
 	{
@@ -278,15 +322,7 @@ fn bool run_tests(String[] args, TestUnit[] tests) @private
 			mute_output();
 			mem.clear();
 			if (check_leaks) allocator::thread_allocator = &mem;
-			$if(!$$OLD_TEST):
-				unit.func();
-			$else
-				if (catch err = unit.func())
-				{
-					io::printf("[FAIL] Failed due to: %s", err);
-					continue;
-				}
-			$endif
+			unit.func();
 			// track cleanup that may take place in teardown_fn
 			if (context.teardown_fn)
 			{
@@ -297,7 +333,7 @@ fn bool run_tests(String[] args, TestUnit[] tests) @private
 			unmute_output(false); // all good, discard output
 			if (mem.has_leaks())
 			{
-				if(context.is_quiet_mode) io::printf("\n%s ", context.current_test_name);
+				if (context.is_quiet_mode) io::printf("\n%s ", context.current_test_name);
 				io::print(context.has_ansi_codes ? "[\e[0;31mFAIL\e[0m]" : "[FAIL]");
 				io::printn(" LEAKS DETECTED!");
 				mem.print_report();
@@ -313,7 +349,7 @@ fn bool run_tests(String[] args, TestUnit[] tests) @private
 		}
 		mem.free();
 	}
-	io::printfn("\n%d test%s run.\n", test_count-tests_skipped, test_count > 1 ? "s" : "");
+	io::printfn("\n%d test%s run.\n", test_count-tests_skipped, test_count != 1 ? "s" : "");

 	int n_failed = test_count - tests_passed - tests_skipped;
 	io::printf("Test Result: %s%s%s: ",
@@ -337,6 +373,6 @@ fn bool run_tests(String[] args, TestUnit[] tests) @private
 fn bool default_test_runner(String[] args) => @pool()
 {
 	assert(test_context == null, "test suite is already running");
-	return run_tests(args, test_collection_create(allocator::temp()));
+	return run_tests(args, test_collection_create(tmem));
 }

--- a/lib/std/core/sanitizer/asan.c3
+++ b/lib/std/core/sanitizer/asan.c3
@@ -12,7 +12,7 @@

 module std::core::sanitizer::asan;

-def ErrorCallback = fn void (ZString);
+alias ErrorCallback = fn void (ZString);

 <*
 Marks a memory region ([addr, addr+size)) as unaddressable.
@@ -26,14 +26,14 @@ def ErrorCallback = fn void (ZString);
 NOTE This function is not thread-safe because no two threads can poison or
 unpoison memory in the same memory region simultaneously.

- @param addr "Start of memory region."
- @param size "Size of memory region."
+ @param addr : "Start of memory region."
+ @param size : "Size of memory region."
 *>
-macro poison_memory_region(void* addr, usz size)
+macro void poison_memory_region(void* addr, usz size)
 {
-	$if env::ADDRESS_SANITIZER: 
+	$if env::ADDRESS_SANITIZER:
 		__asan_poison_memory_region(addr, size);
-	$endif 
+	$endif
 }

 <*
@@ -47,20 +47,20 @@ macro poison_memory_region(void* addr, usz size)
 NOTE This function is not thread-safe because no two threads can
 poison or unpoison memory in the same memory region simultaneously.

- @param addr "Start of memory region."
- @param size "Size of memory region."
+ @param addr : "Start of memory region."
+ @param size : "Size of memory region."
 *>
-macro unpoison_memory_region(void* addr, usz size)
+macro void unpoison_memory_region(void* addr, usz size)
 {
-	$if env::ADDRESS_SANITIZER: 
+	$if env::ADDRESS_SANITIZER:
 		__asan_unpoison_memory_region(addr, size);
-	$endif 
+	$endif
 }

 <*
 Checks if an address is poisoned.
 @return "True if 'addr' is poisoned (that is, 1-byte read/write access to this address would result in an error report from ASan). Otherwise returns false."
- @param addr "Address to check."
+ @param addr : "Address to check."
 *>
 macro bool address_is_poisoned(void* addr)
 {
@@ -77,8 +77,8 @@ macro bool address_is_poisoned(void* addr)
 If at least one byte in [beg, beg+size) is poisoned, returns the
 address of the first such byte. Otherwise returns 0.

- @param beg "Start of memory region."
- @param size "Start of memory region."
+ @param beg : "Start of memory region."
+ @param size : "Start of memory region."
 @return "Address of first poisoned byte."
 *>
 macro void* region_is_poisoned(void* beg, usz size)
--- a/lib/std/core/sanitizer/tsan.c3
+++ b/lib/std/core/sanitizer/tsan.c3
@@ -1,6 +1,6 @@
 module std::core::sanitizer::tsan;

-distinct MutexFlags = inline CUInt;
+typedef MutexFlags = inline CUInt;

 const MutexFlags MUTEX_LINKER_INIT      = 1 << 0;
 const MutexFlags MUTEX_WRITE_REENTRANT  = 1 << 1;
--- a/lib/std/core/slice2d.c3
+++ b/lib/std/core/slice2d.c3
@@ -0,0 +1,169 @@
+module std::core::array::slice {Type};
+
+<*
+ A slice2d allows slicing an array like int[10][10] into an arbitrary "int[][]"-like counterpart
+ Typically you'd use array::slice2d(...) to create one.
+*>
+struct Slice2d
+{
+	Type* ptr;
+	usz inner_len;
+	usz ystart;
+	usz ylen;
+	usz xstart;
+	usz xlen;
+}
+
+<*
+ @return `The length of the "outer" slice`
+*>
+fn usz Slice2d.len(&self) @operator(len)
+{
+	return self.ylen;
+}
+
+<*
+ @return `The total number of elements.`
+*>
+fn usz Slice2d.count(&self)
+{
+	return self.ylen * self.xlen;
+}
+
+<*
+ Step through each element of the slice.
+*>
+macro void Slice2d.@each(&self; @body(usz[<2>], Type))
+{
+	foreach (y, line : *self)
+	{
+		foreach (x, val : line)
+		{
+			@body({ x, y }, val);
+		}
+	}
+}
+
+<*
+ Step through each element of the slice *by reference*
+*>
+macro void Slice2d.@each_ref(&self; @body(usz[<2>], Type*))
+{
+	foreach (y, line : *self)
+	{
+		foreach (x, &val : line)
+		{
+			@body({ x, y }, val);
+		}
+	}
+}
+
+<*
+ Return a row as a slice.
+
+ @param idy : "The row to return"
+ @return "The slice for the particular row"
+ @require idy >= 0 && idy < self.ylen
+*>
+macro Type[] Slice2d.get_row(self, usz idy) @operator([])
+{
+	return (self.ptr + self.inner_len * (idy + self.ystart))[self.xstart:self.xlen];
+}
+
+<*
+ Get the value at a particular x/y position in the slice.
+
+ @param coord : "The xy coordinate"
+ @return "The value at that coordinate"
+ @require coord.y >= 0 && coord.y < self.ylen : "y value out of range"
+ @require coord.x >= 0 && coord.x < self.xlen : "x value out of range"
+*>
+macro Type Slice2d.get_coord(self, usz[<2>] coord)
+{
+	return *self.get_coord_ref(coord);
+}
+
+<*
+ Get a pointer to the value at a particular x/y position in the slice.
+
+ @param coord : "The xy coordinate"
+ @return "A pointer to the value at that coordinate"
+ @require coord.y >= 0 && coord.y < self.ylen : "y value out of range"
+ @require coord.x >= 0 && coord.x < self.xlen : "x value out of range"
+*>
+macro Type* Slice2d.get_coord_ref(self, usz[<2>] coord)
+{
+	return self.get_xy_ref(coord.x, coord.y);
+}
+
+<*
+ Get the value at a particular x/y position in the slice.
+
+ @param x : "The x coordinate"
+ @param y : "The x coordinate"
+ @return "The value at that coordinate"
+ @require y >= 0 && y < self.ylen : "y value out of range"
+ @require x >= 0 && x < self.xlen : "x value out of range"
+*>
+macro Type Slice2d.get_xy(self, x, y)
+{
+	return *self.get_xy_ref(x, y);
+}
+
+<*
+ Get the value at a particular x/y position in the slice by reference.
+
+ @param x : "The x coordinate"
+ @param y : "The y coordinate"
+ @return "A pointer to the value at that coordinate"
+ @require y >= 0 && y < self.ylen : "y value out of range"
+ @require x >= 0 && x < self.xlen : "x value out of range"
+*>
+macro Type* Slice2d.get_xy_ref(self, x, y)
+{
+	return self.ptr + self.inner_len * (y + self.ystart) + self.xstart + x;
+}
+
+<*
+ Set the ´value at a particular x/y position in the slice.
+
+ @param coord : "The xy coordinate"
+ @param value : "The new value"
+ @require coord.y >= 0 && coord.y < self.ylen : "y value out of range"
+ @require coord.x >= 0 && coord.x < self.xlen : "x value out of range"
+*>
+macro void Slice2d.set_coord(self, usz[<2>] coord, Type value)
+{
+	*self.get_coord_ref(coord) = value;
+}
+
+<*
+ Set the value at a particular x/y position in the slice.
+
+ @param x : "The x coordinate"
+ @param y : "The y coordinate"
+ @param value : "The new value"
+ @require y >= 0 && y < self.ylen : "y value out of range"
+ @require x >= 0 && x < self.xlen : "x value out of range"
+*>
+macro void Slice2d.set_xy(self, x, y, Type value)
+{
+	*self.get_xy_ref(x, y) = value;
+}
+
+<*
+ Reslice a slice2d returning a new slice.
+
+ @param x : "The starting x"
+ @param xlen : "The length along x"
+ @param y : "The starting y"
+ @param ylen : "The length along y"
+ @require y >= 0 && y < self.ylen
+ @require x >= 0 && x < self.xlen
+*>
+fn Slice2d Slice2d.slice(&self, isz x = 0, isz xlen = 0, isz y = 0, isz ylen = 0)
+{
+	if (xlen < 1) xlen = self.xlen + xlen;
+	if (ylen < 1) ylen = self.ylen + ylen;
+	return { self.ptr, self.inner_len, y + self.ystart, ylen, x + self.xstart, xlen };
+}
--- a/lib/std/core/string.c3
+++ b/lib/std/core/string.c3
--- a/lib/std/core/string_escape.c3
+++ b/lib/std/core/string_escape.c3
@@ -0,0 +1,233 @@
+// Copyright (c) 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.
+
+<*
+ This module provides functionality for escaping and unescaping strings
+ with standard C-style escape sequences, similar to what's used in JSON
+ and other string literals.
+*>
+module std::core::string;
+import std::io;
+
+faultdef INVALID_ESCAPE_SEQUENCE, UNTERMINATED_STRING, INVALID_HEX_ESCAPE, INVALID_UNICODE_ESCAPE;
+
+<*
+ Escape a string by adding quotes and converting special characters to escape sequences.
+
+ @param allocator : "The allocator to use for the result"
+ @param s : "The string to escape"
+ @param strip_quotes : "Do not include beginning and end quotes, defaults to false"
+ @return "The escaped string with surrounding quotes, can safely be cast to ZString"
+*>
+fn String String.escape(String s, Allocator allocator, bool strip_quotes = true)
+{
+    // Conservative allocation: most strings need minimal escaping
+    usz initial_capacity = s.len + s.len / 5 + 2; // ~1.2x + quotes
+    DString result = dstring::new_with_capacity(allocator, initial_capacity);
+
+    if (!strip_quotes) result.append_char('"');
+
+    foreach (char c : s)
+    {
+        switch (c)
+        {
+            case '"':  result.append(`\"`);
+            case '\\': result.append(`\\`);
+            case '\b': result.append(`\b`);
+            case '\f': result.append(`\f`);
+            case '\n': result.append(`\n`);
+            case '\r': result.append(`\r`);
+            case '\t': result.append(`\t`);
+            case '\v': result.append(`\v`);
+            case '\0': result.append(`\0`);
+            default:
+                if (c >= 32 && c <= 126)
+                {
+                    // Printable ASCII
+                    result.append_char(c);
+                }
+                else
+                {
+                    // Non-printable, use hex escape
+                    result.appendf("\\x%02x", (uint)c);
+                }
+        }
+    }
+
+    if (!strip_quotes) result.append_char('"');
+    return result.copy_str(allocator);
+}
+
+<*
+ Escape a string using the temp allocator.
+
+ @param s : "The string to escape"
+ @param strip_quotes : "Do not include beginning and end quotes, defaults to false"
+ @return "The escaped string with surrounding quotes"
+*>
+fn String String.tescape(String s, bool strip_quotes = false) => s.escape(tmem, strip_quotes);
+
+<*
+ Calculate the length needed for an escaped string (including quotes).
+
+ @param s : "The string to check"
+ @return "The length needed for the escaped version"
+*>
+fn usz escape_len(String s)
+{
+    usz len = 2; // For quotes
+    foreach (char c : s)
+    {
+        switch (c)
+        {
+            case '"':
+            case '\\':
+            case '\b':
+            case '\f':
+            case '\n':
+            case '\r':
+            case '\t':
+            case '\v':
+            case '\0':
+                len += 2; // \X
+            default:
+                if (c >= 32 && c <= 126)
+                {
+                    len += 1;
+                }
+                else
+                {
+                    len += 4; // \xHH
+                }
+        }
+    }
+    return len;
+}
+
+<*
+ Unescape a quoted string by parsing escape sequences.
+
+ @param allocator : "The allocator to use for the result"
+ @param s : "The quoted string to unescape"
+ @param allow_unquoted : "Set to true to unescape strings not surrounded by quotes, defaults to false"
+ @return "The unescaped string without quotes, safe to convert to ZString"
+ @return? UNTERMINATED_STRING, INVALID_ESCAPE_SEQUENCE, INVALID_HEX_ESCAPE, INVALID_UNICODE_ESCAPE
+*>
+fn String? String.unescape(String s, Allocator allocator, bool allow_unquoted = false)
+{
+	if (s.len >= 2 && s[0] == '"' && s[^1] == '"')
+	{
+		// Remove quotes.
+		s = s[1:^2];
+	}
+	else if (!allow_unquoted) return UNTERMINATED_STRING?;
+
+    // Handle empty string case
+    if (!s.len)
+    {
+        return "".copy(allocator);
+    }
+
+    DString result = dstring::new_with_capacity(allocator, s.len);
+
+	usz len = s.len;
+	for (usz i = 0; i < len; i++)
+	{
+		char c = s[i];
+        if (c != '\\')
+        {
+            result.append_char(c);
+            continue;
+        }
+
+        // Handle escape sequence
+        if (i + 1 >= len) return INVALID_ESCAPE_SEQUENCE?;
+
+        char escape_char = s[++i];
+        switch (escape_char)
+        {
+            case '"':  result.append_char('"');
+            case '\\': result.append_char('\\');
+            case '/':  result.append_char('/');
+            case 'b':  result.append_char('\b');
+            case 'f':  result.append_char('\f');
+            case 'n':  result.append_char('\n');
+            case 'r':  result.append_char('\r');
+            case 't':  result.append_char('\t');
+            case 'v':  result.append_char('\v');
+            case '0':  result.append_char('\0');
+            case 'x':
+                // Hex escape \xHH
+                if (i + 2 >= len) return INVALID_HEX_ESCAPE?;
+                char h1 = s[++i];
+                char h2 = s[++i];
+                if (!h1.is_xdigit() || !h2.is_xdigit()) return INVALID_HEX_ESCAPE?;
+                uint val = h1 > '9' ? (h1 | 32) - 'a' + 10 : h1 - '0';
+                val = val << 4;
+                val += h2 > '9' ? (h2 | 32) - 'a' + 10 : h2 - '0';
+                result.append_char((char)val);
+            case 'u':
+                // Unicode escape \uHHHH
+                if (i + 4 >= len) return INVALID_UNICODE_ESCAPE?;
+                uint val;
+                for (int j = 0; j < 4; j++)
+                {
+                    char hex_char = s[++i];
+                    if (!hex_char.is_xdigit()) return INVALID_UNICODE_ESCAPE?;
+                    val = val << 4 + (hex_char > '9' ? (hex_char | 32) - 'a' + 10 : hex_char - '0');
+                }
+                result.append_char32(val);
+            case 'U':
+                // Unicode escape \UHHHHHHHH
+                if (i + 8 >= len) return INVALID_UNICODE_ESCAPE?;
+                uint val;
+                for (int j = 0; j < 8; j++)
+                {
+                    char hex_char = s[++i];
+                    if (!hex_char.is_xdigit()) return INVALID_UNICODE_ESCAPE?;
+                    val = val << 4 + (hex_char > '9' ? (hex_char | 32) - 'a' + 10 : hex_char - '0');
+                }
+                result.append_char32(val);
+            default:
+                return INVALID_ESCAPE_SEQUENCE?;
+        }
+    }
+
+    return result.copy_str(allocator);
+}
+
+<*
+ Unescape a quoted string using the temp allocator.
+
+ @param s : "The quoted string to unescape"
+ @param allow_unquoted : "Set to true to unescape strings not surrounded by quotes, defaults to false"
+ @return "The unescaped string without quotes"
+ @return? UNTERMINATED_STRING, INVALID_ESCAPE_SEQUENCE, INVALID_HEX_ESCAPE, INVALID_UNICODE_ESCAPE
+*>
+fn String? String.tunescape(String s, bool allow_unquoted = false) => s.unescape(tmem, allow_unquoted);
+
+<*
+ Check if a character needs to be escaped in a string literal.
+
+ @param c : "The character to check"
+ @return "True if the character needs escaping"
+*>
+fn bool needs_escape(char c)
+{
+    switch (c)
+    {
+        case '"':
+        case '\\':
+        case '\b':
+        case '\f':
+        case '\n':
+        case '\r':
+        case '\t':
+        case '\v':
+        case '\0':
+            return true;
+        default:
+            return c < 32 || c > 126;
+    }
+}
--- a/lib/std/core/string_iterator.c3
+++ b/lib/std/core/string_iterator.c3
@@ -11,22 +11,22 @@ fn void StringIterator.reset(&self)
 	self.current = 0;
 }

-fn Char32! StringIterator.next(&self)
+fn Char32? StringIterator.next(&self)
 {
    usz len = self.utf8.len;
    usz current = self.current;
-    if (current >= len) return IteratorResult.NO_MORE_ELEMENT?;
+    if (current >= len) return NO_MORE_ELEMENT?;
    usz read = (len - current < 4 ? len - current : 4);
    Char32 res = conv::utf8_to_char32(&self.utf8[current], &read)!;
    self.current += read;
    return res;
 }

-fn Char32! StringIterator.peek(&self)
+fn Char32? StringIterator.peek(&self)
 {
    usz len = self.utf8.len;
    usz current = self.current;
-    if (current >= len) return IteratorResult.NO_MORE_ELEMENT?;
+    if (current >= len) return NO_MORE_ELEMENT?;
    usz read = (len - current < 4 ? len - current : 4);
    Char32 res = conv::utf8_to_char32(&self.utf8[current], &read)!;
    return res;
@@ -37,13 +37,13 @@ fn bool StringIterator.has_next(&self)
    return self.current < self.utf8.len;
 }

-fn Char32! StringIterator.get(&self)
+fn Char32? StringIterator.get(&self)
 {
    usz len = self.utf8.len;
    usz current = self.current;
    usz read = (len - current < 4 ? len - current : 4);
    usz index = current > read ? current - read : 0;
-    if (index >= len) return IteratorResult.NO_MORE_ELEMENT?;
+    if (index >= len) return NO_MORE_ELEMENT?;
    Char32 res = conv::utf8_to_char32(&self.utf8[index], &read)!;
    return res;
 }
--- a/lib/std/core/string_to_real.c3
+++ b/lib/std/core/string_to_real.c3
@@ -34,13 +34,13 @@ const uint[2] B1B_MAX = { 9007199, 254740991 };
 <*
 @require chars.len > 0
 *>
-macro double! decfloat(char[] chars, int $bits, int $emin, int sign)
+macro double? decfloat(char[] chars, int $bits, int $emin, int sign)
 {
 	uint[KMAX] x;
 	const uint[2] TH = B1B_MAX;
 	int emax = - $emin - $bits + 3;

-	const int[?] P10S = { 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000 };
+	const int[*] P10S = { 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000 };
 	usz index;
 	bool got_digit = chars[0] == '0';
 	bool got_rad;
@@ -64,7 +64,7 @@ macro double! decfloat(char[] chars, int $bits, int $emin, int sign)
 		got_rad = true;
 		if (index == last_char)
 		{
-			if (!got_digit) return NumberConversion.MALFORMED_FLOAT?;
+			if (!got_digit) return MALFORMED_FLOAT?;
 			return sign * 0.0;
 		}
 		if (index != last_char && (c = chars[++index]) == '0')
@@ -83,7 +83,7 @@ macro double! decfloat(char[] chars, int $bits, int $emin, int sign)
 		switch
 		{
 			case c == '.':
-				if (got_rad) return NumberConversion.MALFORMED_FLOAT?;
+				if (got_rad) return MALFORMED_FLOAT?;
 				got_rad = true;
 				lrp = dc;
 			case k < KMAX - 3:
@@ -113,24 +113,24 @@ macro double! decfloat(char[] chars, int $bits, int $emin, int sign)
 		c = chars[++index];
 	}
 	if (!got_rad) lrp = dc;
-	if (!got_digit) return NumberConversion.MALFORMED_FLOAT?;
+	if (!got_digit) return MALFORMED_FLOAT?;
 	if ((c | 32) == 'e')
 	{
-		if (last_char == index) return NumberConversion.MALFORMED_FLOAT?;
-		long e10 = String.to_long((String)chars[index + 1..]) ?? NumberConversion.MALFORMED_FLOAT?!;
+		if (last_char == index) return MALFORMED_FLOAT?;
+		long e10 = String.to_long((String)chars[index + 1..]) ?? MALFORMED_FLOAT?!;
 		lrp += e10;
 	}
 	else if (index != last_char)
 	{
-		return NumberConversion.MALFORMED_FLOAT?;
+		return MALFORMED_FLOAT?;
 	}
 	// Handle zero specially to avoid nasty special cases later
 	if (!x[0]) return sign * 0.0;

 	// Optimize small integers (w/no exponent) and over/under-flow
 	if (lrp == dc && dc < 10 && ($bits > 30 || (ulong)x[0] >> $bits == 0)) return sign * (double)x[0];
-	if (lrp > - $emin / 2) return NumberConversion.FLOAT_OUT_OF_RANGE?;
-	if (lrp < $emin - 2 * math::DOUBLE_MANT_DIG) return NumberConversion.FLOAT_OUT_OF_RANGE?;
+	if (lrp > - $emin / 2) return FLOAT_OUT_OF_RANGE?;
+	if (lrp < $emin - 2 * math::DOUBLE_MANT_DIG) return FLOAT_OUT_OF_RANGE?;

 	// Align incomplete final B1B digit
 	if (j)
@@ -320,12 +320,12 @@ macro double! decfloat(char[] chars, int $bits, int $emin, int sign)
 			y *= 0.5;
 			e2++;
 		}
-		if (e2 + math::DOUBLE_MANT_DIG > emax || (denormal && frac)) return NumberConversion.MALFORMED_FLOAT?;
+		if (e2 + math::DOUBLE_MANT_DIG > emax || (denormal && frac)) return MALFORMED_FLOAT?;
 	}
 	return math::scalbn(y, e2);
 }

-macro double! hexfloat(char[] chars, int $bits, int $emin, int sign)
+macro double? hexfloat(char[] chars, int $bits, int $emin, int sign)
 {
 	double scale = 1;
 	uint x;
@@ -351,7 +351,7 @@ macro double! hexfloat(char[] chars, int $bits, int $emin, int sign)
 		got_rad = true;
 		if (index == last_char)
 		{
-			if (!got_digit) return NumberConversion.MALFORMED_FLOAT?;
+			if (!got_digit) return MALFORMED_FLOAT?;
 			return sign * 0.0;
 		}
 		if (index != last_char && (c = chars[++index]) == '0')
@@ -369,7 +369,7 @@ macro double! hexfloat(char[] chars, int $bits, int $emin, int sign)
 	{
 		if (c == '.')
 		{
-			if (got_rad) return NumberConversion.MALFORMED_FLOAT?;
+			if (got_rad) return MALFORMED_FLOAT?;
 			got_rad = true;
 			rp = dc;
 		}
@@ -393,20 +393,20 @@ macro double! hexfloat(char[] chars, int $bits, int $emin, int sign)
 		if (index == last_char) break;
 		c = chars[++index];
 	}
-	if (!got_digit) return NumberConversion.MALFORMED_FLOAT?;
+	if (!got_digit) return MALFORMED_FLOAT?;
 	if (!got_rad) rp = dc;
 	for (; dc < 8; dc++) x *= 16;

 	long e2;
 	if ((c | 32) == 'p')
 	{
-		long e2val = String.to_long((String)chars[index + 1..]) ?? (NumberConversion.MALFORMED_FLOAT?)!;
+		long e2val = String.to_long((String)chars[index + 1..]) ?? (MALFORMED_FLOAT?)!;
 		e2 = e2val;
 	}
 	e2 += 4 * rp - 32;
 	if (!x) return sign * 0.0;
-	if (e2 > -$emin) return NumberConversion.FLOAT_OUT_OF_RANGE?;
-	if (e2 < $emin - 2 * math::DOUBLE_MANT_DIG) return NumberConversion.FLOAT_OUT_OF_RANGE?;
+	if (e2 > -$emin) return FLOAT_OUT_OF_RANGE?;
+	if (e2 < $emin - 2 * math::DOUBLE_MANT_DIG) return FLOAT_OUT_OF_RANGE?;

 	while (x < 0x80000000)
 	{
@@ -441,7 +441,7 @@ macro double! hexfloat(char[] chars, int $bits, int $emin, int sign)
 	}
 	y = bias + sign * (double)x + sign * y;
 	y -= bias;
-	if (!y) return NumberConversion.FLOAT_OUT_OF_RANGE?;
+	if (!y) return FLOAT_OUT_OF_RANGE?;

 	return math::scalbn(y, (int)e2);
 }
@@ -449,7 +449,7 @@ macro double! hexfloat(char[] chars, int $bits, int $emin, int sign)
 macro String.to_real(chars, $Type) @private
 {
 	int sign = 1;
-	$switch ($Type)
+	$switch $Type:
 	$case float:
 		const int BITS = math::FLOAT_MANT_DIG;
 		const int EMIN = math::FLOAT_MIN_EXP - BITS;
@@ -462,16 +462,23 @@ macro String.to_real(chars, $Type) @private
 		$error "Unexpected type";
 	$endswitch

-	while (chars.len && chars[0] == ' ') chars = chars[1..];
-	if (!chars.len) return NumberConversion.MALFORMED_FLOAT?;
-	switch (chars[0])
+	chars = chars.trim();
+	if (!chars.len) return MALFORMED_FLOAT?;
+
+	if (chars.len != 1)
 	{
-		case '-':
-			sign = -1;
-			nextcase;
-		case '+':
-			chars = chars[1..];
+		switch (chars[0])
+		{
+			case '-':
+				sign = -1;
+				nextcase;
+			case '+':
+				chars = chars[1..];
+		}
 	}
+	chars = chars.trim();
+	if (!chars.len) return MALFORMED_FLOAT?;
+
 	if (chars == "infinity" || chars == "INFINITY") return sign * $Type.inf;
 	if (chars == "NAN" || chars == "nan") return $Type.nan;

--- a/lib/std/core/test.c3
+++ b/lib/std/core/test.c3
@@ -8,18 +8,15 @@ Example:
 module sample::m;
 import std::io;

-fault MathError
-{
-	DIVISION_BY_ZERO
-}
+faultdef DIVISION_BY_ZERO;

-fn double! divide(int a, int b)
+fn double? divide(int a, int b)
 {
 	if (b == 0) return MathError.DIVISION_BY_ZERO?;
 	return (double)(a) / (double)(b);
 }

-fn void! test_div() @test
+fn void? test_div() @test
 {
 	test::eq(2, divide(6, 3)!);
 	test::ne(1, 2);
@@ -29,6 +26,7 @@ fn void! test_div() @test
 	test::le(2, 3);
 	test::eq_approx(m::divide(1, 3)!, 0.333, places: 3);
 	test::@check(2 == 2, "divide: %d", divide(6, 3)!);
+	test::@error(m::divide(3, 0));
 	test::@error(m::divide(3, 0), MathError.DIVISION_BY_ZERO);
 }

@@ -44,11 +42,11 @@ import std::math, std::io, libc;
 <*
 Initializes test case context.

- @param setup_fn `initializer function for test case`
- @param teardown_fn `cleanup function for test context (may be null)`
+ @param setup_fn : `initializer function for test case`
+ @param teardown_fn : `cleanup function for test context (may be null)`

- @require runtime::test_context != null "Only allowed in @test functions"
- @require setup_fn != null "setup_fn must always be set"
+ @require runtime::test_context != null : "Only allowed in @test functions"
+ @require setup_fn != null : "setup_fn must always be set"
 *>
 macro @setup(TestFn setup_fn, TestFn teardown_fn = null)
 {
@@ -60,10 +58,10 @@ macro @setup(TestFn setup_fn, TestFn teardown_fn = null)
 <*
 Checks condition and fails assertion if not true

- @param #condition `any boolean condition, will be expanded by text`
- @param format `printf compatible format`
- @param args `vargs for format`
- @require runtime::test_context != null "Only allowed in @test functions"
+ @param #condition : `any boolean condition, will be expanded by text`
+ @param format : `printf compatible format`
+ @param args : `vargs for format`
+ @require runtime::test_context != null : "Only allowed in @test functions"
 *>
 macro @check(#condition, String format = "", args...)
 {
@@ -81,14 +79,15 @@ macro @check(#condition, String format = "", args...)
 }

 <*
- Check if function returns specific error
+ Check if function returns (specific) error

- @param #funcresult `result of function execution`
- @param error_expected `expected error of function execution`
- @require runtime::test_context != null "Only allowed in @test functions"
+ @param #funcresult : `result of function execution`
+ @param error_expected : `expected error of function execution`
+ @require runtime::test_context != null : "Only allowed in @test functions"
 *>
-macro @error(#funcresult, anyfault error_expected)
+macro @error(#funcresult, fault error_expected = ...)
 {
+	$if $defined(error_expected):
 	if (catch err = #funcresult)
 	{
 		if (err != error_expected)
@@ -99,14 +98,18 @@ macro @error(#funcresult, anyfault error_expected)
 		return;
 	}
 	print_panicf("`%s` error [%s] was not returned.", $stringify(#funcresult), error_expected);
+	$else
+	if (catch err = #funcresult) return;
+	print_panicf("`%s` unexpectedly did not return error.", $stringify(#funcresult));
+	$endif
 }

 <*
 Check if left == right

- @param left `left argument of any comparable type`
- @param right `right argument of any comparable type`
- @require runtime::test_context != null "Only allowed in @test functions"
+ @param left : `left argument of any comparable type`
+ @param right : `right argument of any comparable type`
+ @require runtime::test_context != null : "Only allowed in @test functions"
 *>
 macro eq(left, right)
 {
@@ -119,13 +122,13 @@ macro eq(left, right)
 <*
 Check left floating point value is approximately equals to right value

- @param places `number of decimal places to compare (default: 7)`
- @param delta `minimal allowed difference (overrides places parameter)`
- @param equal_nan `allows comparing nan values, if left and right both nans result is ok`
+ @param places : `number of decimal places to compare (default: 7)`
+ @param delta : `minimal allowed difference (overrides places parameter)`
+ @param equal_nan : `allows comparing nan values, if left and right both nans result is ok`

- @require places > 0, places <= 20 "too many decimal places"
- @require delta >= 0, delta <= 1 "delta must be a small number"
- @require runtime::test_context != null "Only allowed in @test functions"
+ @require places > 0, places <= 20 : "too many decimal places"
+ @require delta >= 0, delta <= 1 : "delta must be a small number"
+ @require runtime::test_context != null : "Only allowed in @test functions"
 *>
 macro void eq_approx(double left, double right, uint places = 7, double delta = 0, bool equal_nan = true)
 {
@@ -143,9 +146,9 @@ macro void eq_approx(double left, double right, uint places = 7, double delta =
 <*
 Check if left != right

- @param left `left argument of any comparable type`
- @param right `right argument of any comparable type`
- @require runtime::test_context != null "Only allowed in @test functions"
+ @param left : `left argument of any comparable type`
+ @param right : `right argument of any comparable type`
+ @require runtime::test_context != null : "Only allowed in @test functions"
 *>
 macro void ne(left, right)
 {
@@ -158,9 +161,9 @@ macro void ne(left, right)
 <*
 Check if left > right

- @param left `left argument of any comparable type`
- @param right `right argument of any comparable type`
- @require runtime::test_context != null "Only allowed in @test functions"
+ @param left : `left argument of any comparable type`
+ @param right : `right argument of any comparable type`
+ @require runtime::test_context != null : "Only allowed in @test functions"
 *>
 macro gt(left, right)
 {
@@ -173,9 +176,9 @@ macro gt(left, right)
 <*
 Check if left >= right

- @param left `left argument of any comparable type`
- @param right `right argument of any comparable type`
- @require runtime::test_context != null "Only allowed in @test functions"
+ @param left : `left argument of any comparable type`
+ @param right : `right argument of any comparable type`
+ @require runtime::test_context != null : "Only allowed in @test functions"
 *>
 macro ge(left, right)
 {
@@ -188,9 +191,9 @@ macro ge(left, right)
 <*
 Check if left < right

- @param left `left argument of any comparable type`
- @param right `right argument of any comparable type`
- @require runtime::test_context != null "Only allowed in @test functions"
+ @param left : `left argument of any comparable type`
+ @param right : `right argument of any comparable type`
+ @require runtime::test_context != null : "Only allowed in @test functions"
 *>
 macro lt(left, right)
 {
@@ -203,9 +206,9 @@ macro lt(left, right)
 <*
 Check if left <= right

- @param left `left argument of any comparable type`
- @param right `right argument of any comparable type`
- @require runtime::test_context != null "Only allowed in @test functions"
+ @param left : `left argument of any comparable type`
+ @param right : `right argument of any comparable type`
+ @require runtime::test_context != null : "Only allowed in @test functions"
 *>
 macro le(left, right)
 {
--- a/lib/std/core/types.c3
+++ b/lib/std/core/types.c3
@@ -3,15 +3,11 @@ module std::core::types;
 import libc;


-fault ConversionResult
-{
-	VALUE_OUT_OF_RANGE,
-	VALUE_OUT_OF_UNSIGNED_RANGE,
-}
+faultdef VALUE_OUT_OF_RANGE, VALUE_OUT_OF_UNSIGNED_RANGE;

 <*
- @require $Type.kindof.is_int() "Type was not an integer"
- @require v.type.kindof == ENUM "Value was not an enum"
+ @require $Type.kindof.is_int() : "Type was not an integer"
+ @require v.type.kindof == ENUM : "Value was not an enum"
 *>
 macro any_to_enum_ordinal(any v, $Type)
 {
@@ -19,8 +15,8 @@ macro any_to_enum_ordinal(any v, $Type)
 }

 <*
- @require $Type.kindof.is_int() "Type was not an integer"
- @require v.type.kindof.is_int() "Value was not an integer"
+ @require $Type.kindof.is_int() : "Type was not an integer"
+ @require v.type.kindof.is_int() : "Value was not an integer"
 *>
 macro any_to_int(any v, $Type)
 {
@@ -33,47 +29,47 @@ macro any_to_int(any v, $Type)
 	{
 		case ichar:
 			ichar c = *(char*)v.ptr;
-			if (is_mixed_signed && c < 0) return ConversionResult.VALUE_OUT_OF_UNSIGNED_RANGE?;
+			if (is_mixed_signed && c < 0) return VALUE_OUT_OF_UNSIGNED_RANGE?;
 			return ($Type)c;
 		case short:
 			short s = *(short*)v.ptr;
-			if (is_mixed_signed && s < 0) return ConversionResult.VALUE_OUT_OF_UNSIGNED_RANGE?;
-			if (s > max || s < min) return ConversionResult.VALUE_OUT_OF_RANGE?;
+			if (is_mixed_signed && s < 0) return VALUE_OUT_OF_UNSIGNED_RANGE?;
+			if (s > max || s < min) return VALUE_OUT_OF_RANGE?;
 			return ($Type)s;
 		case int:
 			int i = *(int*)v.ptr;
-			if (is_mixed_signed && i < 0) return ConversionResult.VALUE_OUT_OF_UNSIGNED_RANGE?;
-			if (i > max || i < min) return ConversionResult.VALUE_OUT_OF_RANGE?;
+			if (is_mixed_signed && i < 0) return VALUE_OUT_OF_UNSIGNED_RANGE?;
+			if (i > max || i < min) return VALUE_OUT_OF_RANGE?;
 			return ($Type)i;
 		case long:
 			long l = *(long*)v.ptr;
-			if (is_mixed_signed && l < 0) return ConversionResult.VALUE_OUT_OF_UNSIGNED_RANGE?;
-			if (l > max || l < min) return ConversionResult.VALUE_OUT_OF_RANGE?;
+			if (is_mixed_signed && l < 0) return VALUE_OUT_OF_UNSIGNED_RANGE?;
+			if (l > max || l < min) return VALUE_OUT_OF_RANGE?;
 			return ($Type)l;
 		case int128:
 			int128 i = *(int128*)v.ptr;
-			if (is_mixed_signed && i < 0) return ConversionResult.VALUE_OUT_OF_UNSIGNED_RANGE?;
-			if (i > max || i < min) return ConversionResult.VALUE_OUT_OF_RANGE?;
+			if (is_mixed_signed && i < 0) return VALUE_OUT_OF_UNSIGNED_RANGE?;
+			if (i > max || i < min) return VALUE_OUT_OF_RANGE?;
 			return ($Type)i;
 		case char:
 			char c = *(char*)v.ptr;
-			if (c > max) return ConversionResult.VALUE_OUT_OF_RANGE?;
+			if (c > max) return VALUE_OUT_OF_RANGE?;
 			return ($Type)c;
 		case ushort:
 			ushort s = *(ushort*)v.ptr;
-			if (s > max || s < min) return ConversionResult.VALUE_OUT_OF_RANGE?;
+			if (s > max || s < min) return VALUE_OUT_OF_RANGE?;
 			return ($Type)s;
 		case uint:
 			uint i = *(uint*)v.ptr;
-			if (i > max || i < min) return ConversionResult.VALUE_OUT_OF_RANGE?;
+			if (i > max || i < min) return VALUE_OUT_OF_RANGE?;
 			return ($Type)i;
 		case ulong:
 			ulong l = *(ulong*)v.ptr;
-			if (l > max || l < min) return ConversionResult.VALUE_OUT_OF_RANGE?;
+			if (l > max || l < min) return VALUE_OUT_OF_RANGE?;
 			return ($Type)l;
 		case uint128:
 			uint128 i = *(uint128*)v.ptr;
-			if (i > max || i < min) return ConversionResult.VALUE_OUT_OF_RANGE?;
+			if (i > max || i < min) return VALUE_OUT_OF_RANGE?;
 			return ($Type)i;
 		default:
 			unreachable();
@@ -93,20 +89,25 @@ fn bool typeid.is_subtype_of(self, typeid other)
 macro bool is_subtype_of($Type, $OtherType)
 {
 	var $typeid = $Type.typeid;
-	$switch ($Type)
+	$switch $Type:
 		$case $OtherType: return true;
 		$default: return false;
 	$endswitch
 }
 macro bool is_numerical($Type)
 {
-	var $kind = $Type.kindof;
-	$if $kind == TypeKind.DISTINCT:
-		return is_numerical($typefrom($Type.inner));
-	$else
-		return $kind == TypeKind.SIGNED_INT || $kind == TypeKind.UNSIGNED_INT || $kind == TypeKind.FLOAT
-			|| $kind == TypeKind.VECTOR;
-	$endif
+	$switch $Type.kindof:
+		$case DISTINCT:
+		$case CONST_ENUM:
+			return is_numerical($Type.inner);
+		$case SIGNED_INT:
+		$case UNSIGNED_INT:
+		$case FLOAT:
+		$case VECTOR:
+			return true;
+		$default:
+			return false;
+	$endswitch
 }

 fn bool TypeKind.is_int(kind) @inline
@@ -114,9 +115,11 @@ fn bool TypeKind.is_int(kind) @inline
 	return kind == TypeKind.SIGNED_INT || kind == TypeKind.UNSIGNED_INT;
 }

-macro bool is_slice_convertable($Type)
+macro bool is_slice_convertable($Type) @deprecated("Use is_slice_convertible") => is_slice_convertible($Type);
+
+macro bool is_slice_convertible($Type)
 {
-	$switch ($Type.kindof)
+	$switch $Type.kindof:
 		$case SLICE:
 			return true;
 		$case POINTER:
@@ -130,36 +133,54 @@ macro bool is_bool($Type) @const => $Type.kindof == TypeKind.BOOL;
 macro bool is_int($Type) @const  => $Type.kindof == TypeKind.SIGNED_INT || $Type.kindof == TypeKind.UNSIGNED_INT;

 <*
- @require is_numerical($Type) "Expected a numerical type"
+ @require is_numerical($Type) : "Expected a numerical type"
 *>
 macro bool is_signed($Type) @const
 {
-	$switch (inner_kind($Type))
+	$switch inner_kind($Type):
 		$case SIGNED_INT:
 		$case FLOAT:
 			return true;
 		$case VECTOR:
-			return is_signed($typefrom($Type.inner));
+			return is_signed($Type.inner);
 		$default:
 			return false;
 	$endswitch
 }

 <*
- @require is_numerical($Type) "Expected a numerical type"
+ @require is_numerical($Type) : "Expected a numerical type"
 *>
 macro bool is_unsigned($Type) @const
 {
-	$switch (inner_kind($Type))
+	$switch inner_kind($Type):
 		$case UNSIGNED_INT:
 			return true;
 		$case VECTOR:
-			return is_unsigned($typefrom($Type.inner));
+			return is_unsigned($Type.inner);
 		$default:
 			return false;
 	$endswitch
 }

+macro typeid flat_type($Type) @const
+{
+	$if $Type.kindof == DISTINCT || $Type.kindof == CONST_ENUM:
+		return flat_type($Type.inner);
+	$else
+		return $Type.typeid;
+	$endif
+}
+
+macro TypeKind flat_kind($Type) @const
+{
+	$if $Type.kindof == DISTINCT || $Type.kindof == CONST_ENUM:
+		return flat_type($Type.inner);
+	$else
+		return $Type.kindof;
+	$endif
+}
+
 macro bool is_indexable($Type) @const
 {
 	return $defined(($Type){}[0]);
@@ -170,9 +191,24 @@ macro bool is_ref_indexable($Type) @const
 	return $defined(&($Type){}[0]);
 }

+macro bool is_flat_intlike($Type) @const
+{
+	$switch $Type.kindof:
+		$case SIGNED_INT:
+		$case UNSIGNED_INT:
+			return true;
+		$case VECTOR:
+		$case DISTINCT:
+		$case CONST_ENUM:
+			return is_flat_intlike($Type.inner);
+		$default:
+			return false;
+	$endswitch
+}
+
 macro bool is_intlike($Type) @const
 {
-	$switch ($Type.kindof)
+	$switch $Type.kindof:
 		$case SIGNED_INT:
 		$case UNSIGNED_INT:
 			return true;
@@ -185,12 +221,12 @@ macro bool is_intlike($Type) @const

 macro bool is_underlying_int($Type) @const
 {
-	$switch ($Type.kindof)
+	$switch $Type.kindof:
 		$case SIGNED_INT:
 		$case UNSIGNED_INT:
 			return true;
 		$case DISTINCT:
-			return is_underlying_int($typefrom($Type.inner));
+			return is_underlying_int($Type.inner);
 		$default:
 			return false;
 	$endswitch
@@ -200,7 +236,7 @@ macro bool is_float($Type) @const  => $Type.kindof == TypeKind.FLOAT;

 macro bool is_floatlike($Type) @const
 {
-	$switch ($Type.kindof)
+	$switch $Type.kindof:
 		$case FLOAT:
 			return true;
 		$case VECTOR:
@@ -217,8 +253,8 @@ macro bool is_vector($Type) @const

 macro typeid inner_type($Type) @const
 {
-	$if $Type.kindof == TypeKind.DISTINCT:
-		return inner_type($typefrom($Type.inner));
+	$if $Type.kindof == DISTINCT || $Type.kindof == CONST_ENUM:
+		return inner_type($Type.inner);
 	$else
 		return $Type.typeid;
 	$endif
@@ -240,7 +276,7 @@ macro bool @has_same(#a, #b, ...) @const
 	$if $type_a != @typeid(#b):
 		return false;
 	$endif
-	$for (var $i = 0; $i < $vacount; $i++)
+	$for var $i = 0; $i < $vacount; $i++:
 		$if @typeid($vaexpr[$i]) != $type_a:
 			return false;
 		$endif
@@ -250,7 +286,7 @@ macro bool @has_same(#a, #b, ...) @const

 macro bool may_load_atomic($Type) @const
 {
-	$switch ($Type.kindof)
+	$switch $Type.kindof:
 	$case BOOL:
 	$case SIGNED_INT:
 	$case UNSIGNED_INT:
@@ -258,6 +294,7 @@ macro bool may_load_atomic($Type) @const
 	$case FLOAT:
 		return true;
 	$case DISTINCT:
+	$case ENUM:
 		return may_load_atomic($Type.inner);
 	$default:
 		return false;
@@ -266,15 +303,17 @@ macro bool may_load_atomic($Type) @const

 macro lower_to_atomic_compatible_type($Type) @const
 {
-	$switch ($Type.kindof)
-	$case SIGNED_INT:
-	  $case UNSIGNED_INT:
-	  return $Type.typeid;
+	$switch $Type.kindof:
+		$case BOOL:
+		$case SIGNED_INT:
+		$case UNSIGNED_INT:
+	        return $Type.typeid;
 		$case DISTINCT:
+		$case CONST_ENUM:
 			return lower_to_atomic_compatible_type($Type.inner);
 		$case FLOAT:
-			$switch ($Type)
-				$case float16: 
+			$switch $Type:
+				$case float16:
 					return ushort.typeid;
 				$case float: 
 					return uint.typeid;
@@ -302,6 +341,8 @@ macro bool is_same_vector_type($Type1, $Type2) @const
 	$endif
 }

+macro bool has_equals($Type) @const => $defined(($Type){} == ($Type){});
+
 macro bool is_equatable_type($Type) @const
 {
 	$if $defined($Type.less) || $defined($Type.compare_to) || $defined($Type.equals):
@@ -319,11 +360,6 @@ macro bool implements_copy($Type) @const
 	return $defined($Type.copy) && $defined($Type.free);
 }

-macro bool is_equatable_value(value) @deprecated
-{
-	return is_equatable_type($typeof(value));
-}
-
 macro bool @equatable_value(#value) @const
 {
 	return is_equatable_type($typeof(#value));
@@ -338,15 +374,6 @@ macro bool @comparable_value(#value) @const
 	$endif
 }

-macro bool is_comparable_value(value) @deprecated
-{
-	$if $defined(value.less) || $defined(value.compare_to):
-		return true;
-	$else
-		return $typeof(value).is_ordered;
-	$endif
-}
-
 enum TypeKind : char
 {
 	VOID,
@@ -355,10 +382,10 @@ enum TypeKind : char
 	UNSIGNED_INT,
 	FLOAT,
 	TYPEID,
-	ANYFAULT,
+	FAULT,
 	ANY,
 	ENUM,
-	FAULT,
+	CONST_ENUM,
 	STRUCT,
 	UNION,
 	BITSTRUCT,
--- a/lib/std/core/values.c3
+++ b/lib/std/core/values.c3
@@ -1,22 +1,27 @@
 module std::core::values;
+import std::core::types;

-macro typeid @typeid(#value) @const @builtin => $typeof(#value).typeid;
-macro TypeKind @typekind(#value) @const @builtin => $typeof(#value).kindof;
-macro bool @typeis(#value, $Type) @const @builtin => $typeof(#value).typeid == $Type.typeid;
+
+macro bool @typematch(#value1, #value2) @builtin @const => $typeof(#value1) == $typeof(#value2);
 <*
 Return true if two values have the same type before any conversions.
 *>
-macro bool @is_same_type(#value1, #value2) @const => $typeof(#value1).typeid == $typeof(#value2).typeid;
+macro bool @is_same_type(#value1, #value2) @const @deprecated("Use @typematch") => $typeof(#value1).typeid == $typeof(#value2).typeid;
 macro bool @is_bool(#value) @const => types::is_bool($typeof(#value));
 macro bool @is_int(#value) @const => types::is_int($typeof(#value));
+macro bool @is_flat_intlike(#value) @const => types::is_flat_intlike($typeof(#value));
 macro bool @is_floatlike(#value) @const => types::is_floatlike($typeof(#value));
 macro bool @is_float(#value) @const => types::is_float($typeof(#value));
 macro bool @is_promotable_to_floatlike(#value) @const => types::is_promotable_to_floatlike($typeof(#value));
 macro bool @is_promotable_to_float(#value) @const => types::is_promotable_to_float($typeof(#value));
 macro bool @is_vector(#value) @const => types::is_vector($typeof(#value));
 macro bool @is_same_vector_type(#value1, #value2) @const => types::is_same_vector_type($typeof(#value1), $typeof(#value2));
-macro bool @assign_to(#value1, #value2) @const => $assignable(#value1, $typeof(#value2));
-macro bool @is_lvalue(#value) => $defined(#value = #value);
+macro bool @assign_to(#value1, #value2) @const @deprecated("use '$defined(#value1 = #value2)'") => @assignable_to(#value1, $typeof(#value2));
+macro bool @is_lvalue(#value) @deprecated("use '$defined(#value = #value)'")=> $defined(#value = #value);
+macro bool @is_const(#foo) @const @builtin @deprecated("use '$defined(var $v = expr)'")
+{
+	return $defined(var $v = #foo);
+}

 macro promote_int(x)
 {
@@ -33,12 +38,12 @@ macro promote_int(x)

 This acts like `$bool ? #value_1 : #value_2` but at compile time.

- @param $bool `true for picking the first value, false for the other`
+ @param $bool : `true for picking the first value, false for the other`
 @param #value_1
 @param #value_2
 @returns `The selected value.`
 *>
-macro @select(bool $bool, #value_1, #value_2) @builtin
+macro @select(bool $bool, #value_1, #value_2) @builtin @deprecated("Use '$bool ? #value_1 : #value_2' instead.")
 {
 	$if $bool:
 		return #value_1;
@@ -46,10 +51,11 @@ macro @select(bool $bool, #value_1, #value_2) @builtin
 		return #value_2;
 	$endif
 }
+
 macro promote_int_same(x, y)
 {
 	$if @is_int(x):
-		$switch
+		$switch:
 		$case @is_vector(y) &&& $typeof(y).inner == float.typeid:
 			return (float)x;
 		$case $typeof(y).typeid == float.typeid:
--- a/lib/std/crypto/aes.c3
+++ b/lib/std/crypto/aes.c3
@@ -0,0 +1,650 @@
+<*
+This is an implementation of the AES algorithm with the ECB, CTR and CBC
+modes. The key size can be chosen among AES128, AES192, AES256.
+
+Ported from github.com/kokke/tiny-aes-c by Koni Marti.
+
+The implementation is verified against the test vectors from the National
+Institute of Standards and Technology Special Publication 800-38A 2001 ED.
+
+Data length must be evenly divisible by 16 bytes (len % 16 == 0) unless CTR is
+used. You should pad the end of the string with zeros or use PKCS7 if this is not the case.
+For AES192/256 the key size is proportionally larger.
+
+The following example demonstrates the AES encryption of a plaintext string
+with an AES 128-bit key:
+
+```
+module app;
+import std::crypto::aes, std::io;
+fn void main()
+{
+	char[] key 	= x"2b7e151628aed2a6abf7158809cf4f3c";
+	char[] text	= x"6bc1bee22e409f96e93d7e117393172a";
+	char[16] iv = x"f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff";
+	Aes aes;
+	aes.init(AES128, key, iv);
+	defer aes.destroy();
+	char[] cipher = aes.encrypt(mem, text);
+	defer free(cipher);
+	assert(cipher == x"874d6191b620e3261bef6864990db6ce");
+}
+```
+
+*>
+module std::crypto::aes;
+
+<* Block length in bytes. AES is 128-bit blocks only. *>
+const BLOCKLEN = 16;
+
+<* Number of columns of a AES state. *>
+const COLNUM = 4;
+
+<*
+ Block modes:
+ ECB - Electronic Code Book  (Not recommended, indata be 16 byte multiple)
+ CBC - Cipher Block Chaining (Indata be 16 byte multiple)
+ CTR - Counter Mode          (Recommended, data may be any size)
+*>
+enum BlockMode
+{
+	ECB,
+	CBC,
+	CTR,
+}
+
+<* AES type: 128, 192 or 256 bits *>
+enum AesType : (AesKey key)
+{
+	AES128 = { 128, 16, 176, 4, 10 },
+	AES192 = { 192, 24, 208, 6, 12 },
+	AES256 = { 256, 32, 240, 8, 14 }
+}
+
+struct AesKey
+{
+	<* Size of key in bits *>
+	usz key_size;
+	<* Size of key in bytes *>
+	int key_len;
+	<* Size of the expanded round_key *>
+	int key_exp_size; // expected size of round_key
+	<* Number of 32 bit words in key *>
+	usz nk;
+	<* Number of rounds in the cipher *>
+	usz nr;
+}
+
+struct Aes
+{
+	<* The type, AES128, AES192 or AES256 *>
+	AesKey type;
+	<* Block mode: ECB, CBC or CTR *>
+	BlockMode mode;
+	<* Initialization Vector *>
+	char[BLOCKLEN] iv;
+	<* Internal key state *>
+	char[256] round_key;
+	<* Internal state *>
+	AesState state;
+}
+alias AesState = char[COLNUM][COLNUM];
+
+<*
+ Initializes the AES crypto. The initialization vector should be securely random for each encryption
+ to mitigate things like replay attacks.
+
+ @param type : "The type or AES: 128, 192 or 256 bits"
+ @param [in] key : "The key to use, should be the same bit size as the type, so 16, 24 or 32 bytes"
+ @param iv : "The initialization vector"
+ @param mode : "The block mode: EBC, CBC, CTR. Defaults to CTR"
+
+ @require key.len == type.key.key_len : "Key does not match expected length."
+*>
+fn Aes* Aes.init(&self, AesType type, char[] key, char[BLOCKLEN] iv, BlockMode mode = CTR)
+{
+	*self = { .type = type.key, .mode = mode, .iv = iv };
+	key_expansion(type, key, &self.round_key);
+	return self;
+}
+
+<*
+ Completely erases data stored in the context.
+*>
+fn void Aes.destroy(&self)
+{
+	*self = {};
+}
+
+<*
+ Check if the length is valid using the given block mode. It has to be a multiple of 16 bytes unless CTR is used.
+*>
+macro bool is_valid_encryption_len(BlockMode mode, usz len)
+{
+	switch (mode)
+	{
+		case CTR:
+			return true;
+		case ECB:
+		case CBC:
+			return len % BLOCKLEN == 0;
+	}
+}
+
+<*
+ @param [in] in : "Plaintext input."
+ @param [out] out : "Cipher output."
+ @require is_valid_encryption_len(self.mode, in.len) : "The input must be a multiple of 16 unless CTR is used"
+ @require out.len >= in.len : "Out buffer must be sufficiently large to hold the data"
+*>
+fn void Aes.encrypt_buffer(&self, char[] in, char[] out)
+{
+	switch (self.mode)
+	{
+		case CTR: ctr_xcrypt_buffer(self, in, out);
+		case ECB: ecb_encrypt_buffer(self, in, out);
+		case CBC: cbc_encrypt_buffer(self, in, out);
+	}
+}
+
+<*
+ @param [in] in : "Cipher input."
+ @param [out] out : "Plaintext output."
+ @require is_valid_encryption_len(self.mode, in.len) : "The encrypted data must be a multiple of 16 unless CTR is used"
+ @require out.len >= in.len : "Out buffer must be sufficiently large to hold the data"
+*>
+fn void Aes.decrypt_buffer(&self, char[] in, char[] out)
+{
+	switch (self.mode)
+	{
+		case ECB: ecb_decrypt_buffer(self, in, out);
+		case CBC: cbc_decrypt_buffer(self, in, out);
+		case CTR: ctr_xcrypt_buffer(self, in, out);
+	}
+}
+
+<*
+ Encrypt the data, allocating memory for the encrypted data.
+
+ @param [in] in : "Plaintext input."
+ @param [&inout] allocator : "The allocator to use for the output"
+ @require is_valid_encryption_len(self.mode, in.len) : "The in-data needs to be a multiple of 16 unless CTR is used"
+*>
+fn char[] Aes.encrypt(&self, Allocator allocator, char[] in)
+{
+	char[] out = allocator::alloc_array(allocator, char, in.len);
+	self.encrypt_buffer(in, out) @inline;
+	return out;
+}
+
+<*
+ Encrypt the data, allocating temp memory for the encrypted data.
+
+ @param [in] in : "Plaintext input."
+ @require is_valid_encryption_len(self.mode, in.len) : "The in-data needs to be a multiple of 16 unless CTR is used"
+*>
+fn char[] Aes.tencrypt(&self, char[] in)
+{
+	return self.encrypt(tmem, in);
+}
+
+<*
+ Decrypt the data, allocating memory for the decrypted data.
+
+ @param [in] in : "Encrypted input."
+ @param [&inout] allocator : "The allocator to use for the output"
+ @require is_valid_encryption_len(self.mode, in.len) : "The in-data needs to be a multiple of 16 unless CTR is used"
+*>
+fn char[] Aes.decrypt(&self, Allocator allocator, char[] in)
+{
+	char[] out = allocator::alloc_array(allocator, char, in.len);
+	self.decrypt_buffer(in, out) @inline;
+	return out;
+}
+
+<*
+ Decrypt the data, allocating temp memory for the decrypted data.
+
+ @param [in] in : "Encrypted input."
+ @require is_valid_encryption_len(self.mode, in.len) : "The in-data needs to be a multiple of 16 unless CTR is used"
+
+*>
+fn char[] Aes.tdecrypt(&self, char[] in)
+{
+	return self.decrypt(tmem, in);
+}
+
+module std::crypto::aes @private;
+
+<*
+ @param [&inout] aes : "AES context."
+ @param [in] in : "Plaintext input."
+ @param [out] out : "Cipher output."
+*>
+fn void ecb_encrypt_block(Aes *aes, char[BLOCKLEN]* in, char[BLOCKLEN]* out)
+{
+	for (usz i = 0; i < 4; i++)
+	{
+		for (usz j = 0; j < 4; j++)
+		{
+			aes.state[i][j] = (*in)[i * 4 + j];
+		}
+	}
+	aes_cipher(aes, &aes.round_key);
+	for (usz i = 0; i < 4; i++)
+	{
+		for (usz j = 0; j < 4; j++)
+		{
+			(*out)[i * 4 + j] = aes.state[i][j];
+		}
+	}
+}
+
+<*
+ @param [&inout] aes : "AES context."
+ @param [in] in : "Cipher input."
+ @param [out] out : "Plaintext output."
+*>
+fn void ecb_decrypt_block(Aes *aes, char[BLOCKLEN]* in, char[BLOCKLEN]* out)
+{
+	for (usz i = 0; i < 4; i++)
+	{
+		for (usz j = 0; j < 4; j++)
+		{
+			aes.state[i][j] = (*in)[i * 4 + j];
+		}
+	}
+	inv_cipher(aes, &aes.round_key);
+	for (usz i = 0; i < 4; i++)
+	{
+		for (usz j = 0; j < 4; j++)
+		{
+			(*out)[i * 4 + j] = aes.state[i][j];
+		}
+	}
+}
+
+<*
+ @param [&inout] aes : "AES context."
+ @param [in] in : "Cipher input."
+ @param [out] out : "Plaintext output."
+ @require out.len >= in.len : "out must be at least as large as buf"
+*>
+fn void ecb_decrypt_buffer(Aes *aes, char[] in, char[] out)
+{
+	usz len = in.len;
+	for (usz i = 0; i < len; i += 4)
+	{
+		ecb_decrypt_block(aes, in[:BLOCKLEN], out[:BLOCKLEN]) @inline;
+	}
+}
+
+<*
+ @param [&inout] aes : "AES context."
+ @param [in] in : "Plaintext input."
+ @param [out] out : "Cipher output."
+*>
+fn void ecb_encrypt_buffer(Aes *aes, char[] in, char[] out)
+{
+	usz len = in.len;
+	for (usz i = 0; i < len; i += BLOCKLEN)
+	{
+		ecb_encrypt_block(aes, in[i:BLOCKLEN], out[i:BLOCKLEN]) @inline;
+	}
+}
+
+fn void xor_with_iv(char[] buf, char[BLOCKLEN]* iv) @local
+{
+	foreach (i, b : *iv)
+	{
+		buf[i] ^= b;
+	}
+}
+
+<*
+ @param [&inout] aes : "AES context."
+ @param [in] in : "Plaintext input."
+ @param [out] out : "Cipher output."
+*>
+fn void cbc_encrypt_buffer(Aes *aes, char[] in, char[] out)
+{
+	char[] iv = aes.iv[..];
+	usz len = in.len;
+	char[BLOCKLEN] tmp;
+	char[BLOCKLEN] tmp2;
+	for (usz i = 0; i < len; i += BLOCKLEN)
+	{
+		tmp[:BLOCKLEN] = in[i:BLOCKLEN];
+		xor_with_iv(&tmp, iv);
+		ecb_encrypt_block(aes, &tmp, &tmp2);
+		out[i:BLOCKLEN] = tmp2[..];
+		iv = tmp2[..];
+	}
+}
+
+<*
+ @param [&inout] aes : "AES context."
+ @param [in] in : "Cipher input."
+ @param [out] out : "Plaintext output."
+*>
+fn void cbc_decrypt_buffer(Aes *aes, char[] in, char[] out)
+{
+	char[BLOCKLEN] tmp;
+	usz len = in.len;
+	for (usz i = 0; i < len; i += BLOCKLEN)
+	{
+		ecb_decrypt_block(aes, in[i:BLOCKLEN], &tmp);
+		xor_with_iv(&tmp, aes.iv[..]);
+		aes.iv[:BLOCKLEN] = in[i:BLOCKLEN];
+		out[i:BLOCKLEN] = tmp[..];
+	}
+}
+
+<*
+ @param [&inout] aes : "AES context."
+ @param [in] in : "Plaintext/cipher input."
+ @param [out] out : "Cipher/plaintext output."
+*>
+fn void ctr_xcrypt_buffer(Aes *aes, char[] in, char[] out)
+{
+	 char[BLOCKLEN] buffer @noinit;
+	 usz len = in.len;
+	 for (int bi = BLOCKLEN, usz i = 0; i < len; i++)
+	 {
+		 if (bi == BLOCKLEN)
+		 {
+			 buffer = aes.iv;
+			 ecb_encrypt_block(aes, &buffer, &buffer);
+
+			 for LOOP: (bi = (BLOCKLEN - 1); bi >= 0; bi--)
+			 {
+				 if (aes.iv[bi] == 255)
+				 {
+					 aes.iv[bi] = 0;
+					 continue;
+				 }
+				 aes.iv[bi]++;
+				 break LOOP;
+			 }
+			 bi = 0;
+		 }
+		 out[i] = in[i] ^ buffer[bi];
+		 bi++;
+	 }
+}
+
+macro char get_sbox_value(num) => SBOX[num];
+macro char get_sbox_invert(num) => RSBOX[num];
+
+const char[256] SBOX =
+	x`637c777bf26b6fc53001672bfed7ab76
+	  ca82c97dfa5947f0add4a2af9ca472c0
+	  b7fd9326363ff7cc34a5e5f171d83115
+	  04c723c31896059a071280e2eb27b275
+	  09832c1a1b6e5aa0523bd6b329e32f84
+	  53d100ed20fcb15b6acbbe394a4c58cf
+	  d0efaafb434d338545f9027f503c9fa8
+	  51a3408f929d38f5bcb6da2110fff3d2
+	  cd0c13ec5f974417c4a77e3d645d1973
+	  60814fdc222a908846eeb814de5e0bdb
+	  e0323a0a4906245cc2d3ac629195e479
+	  e7c8376d8dd54ea96c56f4ea657aae08
+	  ba78252e1ca6b4c6e8dd741f4bbd8b8a
+	  703eb5664803f60e613557b986c11d9e
+	  e1f8981169d98e949b1e87e9ce5528df
+	  8ca1890dbfe6426841992d0fb054bb16`;
+
+const char[256] RSBOX =
+	x`52096ad53036a538bf40a39e81f3d7fb
+	  7ce339829b2fff87348e4344c4dee9cb
+	  547b9432a6c2233dee4c950b42fac34e
+	  082ea16628d924b2765ba2496d8bd125
+	  72f8f66486689816d4a45ccc5d65b692
+	  6c704850fdedb9da5e154657a78d9d84
+	  90d8ab008cbcd30af7e45805b8b34506
+	  d02c1e8fca3f0f02c1afbd0301138a6b
+	  3a9111414f67dcea97f2cfcef0b4e673
+	  96ac7422e7ad3585e2f937e81c75df6e
+	  47f11a711d29c5896fb7620eaa18be1b
+	  fc563e4bc6d279209adbc0fe78cd5af4
+	  1fdda8338807c731b11210592780ec5f
+	  60517fa919b54a0d2de57a9f93c99cef
+	  a0e03b4dae2af5b0c8ebbb3c83539961
+	  172b047eba77d626e169146355210c7d`;
+
+const char[11] RCON = x`8d01020408102040801b36`;
+
+fn void add_round_key(Aes* aes, usz round, char[] round_key)
+{
+	usz i, j;
+	for (i = 0; i < 4; i++)
+	{
+		for (j = 0; j < 4; j++)
+		{
+			aes.state[i][j] ^= round_key[(round * COLNUM * 4) + (i * COLNUM) + j];
+		}
+	}
+}
+
+fn void sub_bytes(Aes* aes)
+{
+	for (usz i = 0; i < 4; i++)
+	{
+		for (usz j = 0; j < 4; j++)
+		{
+			aes.state[j][i] = get_sbox_value(aes.state[j][i]);
+		}
+	}
+}
+
+fn void shift_rows(Aes* aes)
+{
+	char temp;
+
+	temp             = aes.state[0][1];
+	aes.state[0][1]  = aes.state[1][1];
+	aes.state[1][1]  = aes.state[2][1];
+	aes.state[2][1]  = aes.state[3][1];
+	aes.state[3][1]  = temp;
+
+	temp	         = aes.state[0][2];
+	aes.state[0][2]  = aes.state[2][2];
+	aes.state[2][2]  = temp;
+
+	temp	         = aes.state[1][2];
+	aes.state[1][2]  = aes.state[3][2];
+	aes.state[3][2]  = temp;
+
+	temp	         = aes.state[0][3];
+	aes.state[0][3]  = aes.state[3][3];
+	aes.state[3][3]  = aes.state[2][3];
+	aes.state[2][3]  = aes.state[1][3];
+	aes.state[1][3]  = temp;
+}
+
+fn char xtime(char x) @local
+{
+	return ((x << 1) ^ (((x >> 7) & 1) * 0x1b));
+}
+
+fn void mix_columns(Aes* aes)
+{
+	for (usz i = 0; i < 4; i++)
+	{
+		char t = aes.state[i][0];
+		char tmp = aes.state[i][0] ^ aes.state[i][1] ^ aes.state[i][2] ^ aes.state[i][3];
+
+		char tm = aes.state[i][0] ^ aes.state[i][1];
+		tm = xtime(tm);
+		aes.state[i][0] ^= tm ^ tmp;
+
+		tm = aes.state[i][1] ^ aes.state[i][2];
+		tm = xtime(tm);
+		aes.state[i][1] ^= tm ^ tmp;
+
+		tm = aes.state[i][2] ^ aes.state[i][3];
+		tm = xtime(tm);
+		aes.state[i][2] ^= tm ^ tmp;
+
+		tm = aes.state[i][3] ^ t;
+		tm = xtime(tm);
+		aes.state[i][3] ^= tm ^ tmp;
+	}
+}
+
+fn char multiply(char x, char y) @local
+{
+	return (((y & 1) * x) ^
+	       (((y>>1) & 1) * xtime(x)) ^
+		   (((y>>2) & 1) * xtime(xtime(x))) ^
+	       (((y>>3) & 1) * xtime(xtime(xtime(x)))) ^
+	       (((y>>4) & 1) * xtime(xtime(xtime(xtime(x))))));
+}
+
+fn void inv_mix_columns(Aes* aes)
+{
+	for (int i = 0; i < 4; i++)
+	{
+		char a = aes.state[i][0];
+		char b = aes.state[i][1];
+		char c = aes.state[i][2];
+		char d = aes.state[i][3];
+
+		aes.state[i][0] = multiply(a, 0x0e) ^ multiply(b, 0x0b) ^ multiply(c, 0x0d) ^ multiply(d, 0x09);
+		aes.state[i][1] = multiply(a, 0x09) ^ multiply(b, 0x0e) ^ multiply(c, 0x0b) ^ multiply(d, 0x0d);
+		aes.state[i][2] = multiply(a, 0x0d) ^ multiply(b, 0x09) ^ multiply(c, 0x0e) ^ multiply(d, 0x0b);
+		aes.state[i][3] = multiply(a, 0x0b) ^ multiply(b, 0x0d) ^ multiply(c, 0x09) ^ multiply(d, 0x0e);
+	}
+}
+
+fn void inv_sub_bytes(Aes* aes)
+{
+	for (usz i = 0; i < 4; i++)
+	{
+		for (usz j = 0; j < 4; j++)
+		{
+			aes.state[j][i] = get_sbox_invert(aes.state[j][i]);
+		}
+	}
+}
+
+fn void inv_shift_rows(Aes* aes)
+{
+	char temp;
+
+	temp            = aes.state[3][1];
+	aes.state[3][1] = aes.state[2][1];
+	aes.state[2][1] = aes.state[1][1];
+	aes.state[1][1] = aes.state[0][1];
+	aes.state[0][1] = temp;
+
+	temp	        = aes.state[0][2];
+	aes.state[0][2] = aes.state[2][2];
+	aes.state[2][2] = temp;
+
+	temp	        = aes.state[1][2];
+	aes.state[1][2] = aes.state[3][2];
+	aes.state[3][2] = temp;
+
+	temp	        = aes.state[0][3];
+	aes.state[0][3] = aes.state[1][3];
+	aes.state[1][3] = aes.state[2][3];
+	aes.state[2][3] = aes.state[3][3];
+	aes.state[3][3] = temp;
+}
+
+fn void aes_cipher(Aes* aes, char[] round_key)
+{
+	usz round = 0;
+	add_round_key(aes, 0, round_key);
+
+	for LOOP: (round = 1;; round++)
+	{
+		sub_bytes(aes);
+		shift_rows(aes);
+		if (round == aes.type.nr) break LOOP;
+		mix_columns(aes);
+		add_round_key(aes, round, round_key);
+	}
+	add_round_key(aes, aes.type.nr, round_key);
+}
+
+fn void inv_cipher(Aes* aes, char[] round_key)
+{
+	add_round_key(aes, aes.type.nr, round_key);
+	for (usz round = aes.type.nr - 1; ; round--)
+	{
+		inv_shift_rows(aes);
+		inv_sub_bytes(aes);
+		add_round_key(aes, round, round_key);
+		if (!round) return;
+		inv_mix_columns(aes);
+	}
+}
+
+<*¨
+ @param type : "The AES variant to expant the key for"
+ @param [inout] round_key : "Key to expand into"
+ @param [in] key : "The key to expand"
+ @require key.len == type.key.key_len : "Key does not match expected length."
+*>
+fn void key_expansion(AesType type, char[] key, char[] round_key) @private
+{
+	usz nk = type.key.nk;
+	for (usz i = 0; i < nk; i++)
+	{
+		round_key[(i * 4) + 0] = key[(i * 4) + 0];
+		round_key[(i * 4) + 1] = key[(i * 4) + 1];
+		round_key[(i * 4) + 2] = key[(i * 4) + 2];
+		round_key[(i * 4) + 3] = key[(i * 4) + 3];
+	}
+
+	for (usz i = nk; i < COLNUM * (type.key.nr + 1); i++)
+	{
+		usz k = (i - 1) * 4;
+
+		char[4] tempa @noinit;
+
+		tempa[0] = round_key[k + 0];
+		tempa[1] = round_key[k + 1];
+		tempa[2] = round_key[k + 2];
+		tempa[3] = round_key[k + 3];
+
+		if (i % nk == 0)
+		{
+			// rotword
+			char tmp = tempa[0];
+			tempa[0] = tempa[1];
+			tempa[1] = tempa[2];
+			tempa[2] = tempa[3];
+			tempa[3] = tmp;
+
+			// subword
+			tempa[0] = get_sbox_value(tempa[0]);
+			tempa[1] = get_sbox_value(tempa[1]);
+			tempa[2] = get_sbox_value(tempa[2]);
+			tempa[3] = get_sbox_value(tempa[3]);
+
+			tempa[0] = tempa[0] ^ RCON[i / nk];
+		}
+
+		if (type.key.key_size == 256)
+		{
+			if (i % nk == 4)
+			{
+				// subword
+				tempa[0] = get_sbox_value(tempa[0]);
+				tempa[1] = get_sbox_value(tempa[1]);
+				tempa[2] = get_sbox_value(tempa[2]);
+				tempa[3] = get_sbox_value(tempa[3]);
+			}
+		}
+		usz j = i * 4;
+		k = (i - nk) * 4;
+		round_key[j + 0] = round_key[k + 0] ^ tempa[0];
+		round_key[j + 1] = round_key[k + 1] ^ tempa[1];
+		round_key[j + 2] = round_key[k + 2] ^ tempa[2];
+		round_key[j + 3] = round_key[k + 3] ^ tempa[3];
+	}
+}
+
--- a/lib/std/crypto/aes_128_192_256.c3
+++ b/lib/std/crypto/aes_128_192_256.c3
@@ -0,0 +1,87 @@
+// Experimental implementation
+module std::crypto::aes128;
+import std::crypto::aes;
+
+fn char[] encrypt(Allocator allocator, char[16]* key, char[aes::BLOCKLEN] iv, char[] data)
+{
+	Aes aes @noinit;
+	aes.init(AES128, key, iv, CTR);
+	defer aes.destroy();
+	return aes.encrypt(allocator, data);
+}
+
+fn char[] tencrypt(char[16]* key, char[aes::BLOCKLEN] iv, char[] data)
+{
+	return encrypt(tmem, key, iv, data);
+}
+
+fn char[] decrypt(Allocator allocator, char[16]* key, char[aes::BLOCKLEN] iv, char[] data)
+{
+	Aes aes @noinit;
+	aes.init(AES128, key, iv, CTR);
+	defer aes.destroy();
+	return aes.decrypt(allocator, data);
+}
+
+fn char[] tdecrypt(char[16]* key, char[aes::BLOCKLEN] iv, char[] data)
+{
+	return decrypt(tmem, key, iv, data);
+}
+
+module std::crypto::aes192;
+import std::crypto::aes;
+
+fn char[] encrypt(Allocator allocator, char[24]* key, char[aes::BLOCKLEN] iv, char[] data)
+{
+	Aes aes @noinit;
+	aes.init(AES192, key, iv, CTR);
+	defer aes.destroy();
+	return aes.encrypt(allocator, data);
+}
+
+fn char[] tencrypt(char[24]* key, char[aes::BLOCKLEN] iv, char[] data)
+{
+	return encrypt(tmem, key, iv, data);
+}
+
+fn char[] decrypt(Allocator allocator, char[24]* key, char[aes::BLOCKLEN] iv, char[] data)
+{
+	Aes aes @noinit;
+	aes.init(AES192, key, iv, CTR);
+	defer aes.destroy();
+	return aes.decrypt(allocator, data);
+}
+
+fn char[] tdecrypt(char[24]* key, char[aes::BLOCKLEN] iv, char[] data)
+{
+	return decrypt(tmem, key, iv, data);
+}
+
+module std::crypto::aes256;
+import std::crypto::aes;
+
+fn char[] encrypt(Allocator allocator, char[32]* key, char[aes::BLOCKLEN] iv, char[] data)
+{
+	Aes aes @noinit;
+	aes.init(AES256, key, iv, CTR);
+	defer aes.destroy();
+	return aes.encrypt(allocator, data);
+}
+
+fn char[] tencrypt(char[32]* key, char[aes::BLOCKLEN] iv, char[] data)
+{
+	return encrypt(tmem, key, iv, data);
+}
+
+fn char[] decrypt(Allocator allocator, char[32]* key, char[aes::BLOCKLEN] iv, char[] data)
+{
+	Aes aes @noinit;
+	aes.init(AES256, key, iv, CTR);
+	defer aes.destroy();
+	return aes.decrypt(allocator, data);
+}
+
+fn char[] tdecrypt(char[32]* key, char[aes::BLOCKLEN] iv, char[] data)
+{
+	return decrypt(tmem, key, iv, data);
+}
--- a/lib/std/crypto/crypto.c3
+++ b/lib/std/crypto/crypto.c3
@@ -9,4 +9,3 @@ fn bool safe_compare(void* data1, void* data2, usz len)
 	}
 	return match == 0;
 }
-
--- a/lib/std/crypto/ed25519.c3
+++ b/lib/std/crypto/ed25519.c3
@@ -0,0 +1,737 @@
+/*
+ Ed25519 Digital Signature Algorithm
+*/
+
+module std::crypto::ed25519;
+import std::hash::sha512;
+
+alias Ed25519PrivateKey = char[32];
+alias Ed25519PublicKey = char[Ed25519PrivateKey.len];
+alias Ed25519Signature = char[2 * Ed25519PublicKey.len];
+
+<*
+ Generate a public key from a private key.
+
+ @param [in] private_key : "32 bytes of cryptographically secure random data"
+ @require private_key.len == Ed25519PrivateKey.len
+*>
+fn Ed25519PublicKey public_keygen(char[] private_key)
+{
+	return pack(&&unproject(&&(BASE * expand_private_key(private_key)[:FBaseInt.len])));
+}
+
+<*
+ Sign a message.
+
+ @param [in] message
+ @param [in] private_key
+ @param [in] public_key
+ @require private_key.len == Ed25519PrivateKey.len
+ @require public_key.len == Ed25519PublicKey.len
+*>
+fn Ed25519Signature sign(char[] message, char[] private_key, char[] public_key)
+{
+	Ed25519Signature r @noinit;
+
+	char[*] exp = expand_private_key(private_key);
+
+	Sha512 sha @noinit;
+	sha.init();
+
+	sha.update(exp[FBaseInt.len..]);
+	sha.update(message);
+
+	FBaseInt k = from_bytes(&&sha.final());
+
+	r[:F25519Int.len] = pack(&&unproject(&&(BASE * k[..])))[..];
+
+	sha.init();
+
+	sha.update(r[:F25519Int.len]);
+	sha.update(public_key);
+	sha.update(message);
+
+	FBaseInt z = from_bytes(&&sha.final());
+	FBaseInt e = from_bytes(exp[:FBaseInt.len]);
+
+	r[F25519Int.len..] = (z * e + k)[..];
+
+	return r;
+}
+
+<*
+ Verify the signature of a message.
+
+ @param [in] message
+ @param [in] signature
+ @param [in] public_key
+ @require signature.len == Ed25519Signature.len
+ @require public_key.len == Ed25519PublicKey.len
+*>
+fn bool verify(char[] message, char[] signature, char[] public_key)
+{
+	char ok = 1;
+
+	F25519Int lhs = pack(&&unproject(&&(BASE * signature[F25519Int.len..])));
+
+	Unpacking unp_p = unpack_on_curve((F25519Int*)public_key);
+	Projection p = project(&unp_p.point);
+	ok &= unp_p.on_curve;
+
+	Sha512 sha @noinit;
+	sha.init();
+
+	sha.update(signature[:F25519Int.len]);
+	sha.update(public_key);
+	sha.update(message);
+
+	FBaseInt z = from_bytes(&&sha.final());
+
+	p = p * z[..];
+
+	Unpacking unp_q = unpack_on_curve((F25519Int*)signature[:F25519Int.len]);
+	Projection q = project(&unp_q.point);
+	ok &= unp_q.on_curve;
+
+	p = p + q;
+
+	F25519Int rhs = pack(&&unproject(&p));
+
+	return (bool)(ok & eq(&lhs, &rhs));
+}
+
+// Base point for Ed25519. Generate a subgroup of order 2^252+0x14def9dea2f79cd65812631a5cf5d3ed
+const Projection BASE @private =
+{
+	x"1ad5258f602d56c9 b2a7259560c72c69 5cdcd6fd31e2a4c0 fe536ecdd3366921",
+	x"5866666666666666 6666666666666666 6666666666666666 6666666666666666",
+	x"a3ddb7a5b38ade6d f5525177809ff020 7de3ab648e4eea66 65768bd70f5f8767",
+	ONE
+};
+
+<*
+ Compute the pruned SHA-512 hash of a private key.
+
+ @param [in] private_key
+ @require private_key.len == Ed25519PrivateKey.len
+*>
+fn char[sha512::HASH_SIZE] expand_private_key(char[] private_key) @local
+{
+	char[*] r = sha512::hash(private_key);
+
+	r[0] &= 0b11111000;
+	r[FBaseInt.len - 1] &= 0b01111111;
+	r[FBaseInt.len - 1] |= 0b01000000;
+
+	return r;
+}
+
+
+
+/*
+ Operations on the twisted Edwards curve -x^2+y^2=1-121665/121666*x^2*y^2 over the prime field F_(2^255-19) (edwards25519)
+ The set of F_(2^255-19)-rational curve points is a group of order 2^3*(2^252+0x14def9dea2f79cd65812631a5cf5d3ed)
+*/
+
+module std::crypto::ed25519 @private;
+
+// Affine coordinates.
+struct Point
+{
+	F25519Int x;
+	F25519Int y;
+}
+
+// Projective coordinates.
+struct Projection
+{
+	F25519Int x;
+	F25519Int y;
+	F25519Int t;
+	F25519Int z;
+}
+
+// Neutral.
+const Projection NEUTRAL =
+{
+	ZERO,
+	ONE,
+	ZERO,
+	ONE
+};
+
+<*
+ Convert affine to projective coordinates.
+
+ @param [&in] p
+*>
+fn Projection project(Point* p) => { p.x, p.y, p.x * p.y, ONE };
+
+<*
+ Convert projective to affine coordinates.
+
+ @param [&in] p
+*>
+fn Point unproject(Projection* p)
+{
+	Point r @noinit;
+
+	F25519Int inv = p.z.inv();
+	r.x = p.x * inv;
+	r.y = p.y * inv;
+
+	r.x.normalize();
+	r.y.normalize();
+
+	return r;
+}
+
+// d parameter for edwards25519 : -121665/121666
+const F25519Int D = x"a3785913ca4deb75 abd841414d0a7000 98e879777940c78c 73fe6f2bee6c0352";
+
+// 2*d
+const F25519Int DD = x"59f1b226949bd6eb 56b183829a14e000 30d1f3eef2808e19 e7fcdf56dcd90624";
+
+<*
+ Compress a point.
+
+ @param [&in] p
+*>
+fn F25519Int pack(Point* p)
+{
+	Point r = *p;
+
+	r.x.normalize();
+	r.y.normalize();
+
+	r.y[^1] |= (r.x[0] & 1) << 7;
+
+	return r.y;
+}
+
+struct Unpacking
+{
+	Point point;
+	<* Non-zero if true. *>
+	char on_curve;
+}
+
+<*
+ Uncompress a point. Check if it is on the curve.
+
+ @param [&in] encoding
+*>
+fn Unpacking unpack_on_curve(F25519Int* encoding)
+{
+	Point p @noinit;
+
+	char parity = (*encoding)[^1] >> 7;
+
+	p.y = *encoding;
+	p.y[^1] &= 0b01111111;
+
+	F25519Int y2 = p.y * p.y;
+	F25519Int x2 = (D * y2 + ONE).inv() * (y2 - ONE);
+
+	F25519Int x = x2.sqrt();
+
+	p.x = f25519_select(&x, &&-x, (x[0] ^ parity) & 1);
+
+	F25519Int _x2 = p.x * p.x;
+
+	x2.normalize();
+	_x2.normalize();
+
+	return {p, eq(&x2, &_x2)};
+}
+
+macro Projection Projection.@add(&s, Projection #p) @operator(+) => s.add(@addr(#p));
+<*
+ Addition.
+
+ @param [&in] s
+*>
+fn Projection Projection.add(&s, Projection* p) @operator(+)
+{
+	Projection r @noinit;
+
+	F25519Int a = (s.y - s.x) * (p.y - p.x);
+	F25519Int b = (s.y + s.x) * (p.y + p.x);
+	F25519Int c = s.t * DD * p.t;
+	F25519Int d = (s.z * p.z).mul_s(2);
+	F25519Int e = b - a;
+	F25519Int f = d - c;
+	F25519Int g = d + c;
+	F25519Int h = b + a;
+
+	r.x = e * f;
+	r.y = g * h;
+	r.t = e * h;
+	r.z = f * g;
+
+	return r;
+}
+
+<*
+ Double a point.
+
+ @param [&in] s
+*>
+fn Projection Projection.twice(&s)
+{
+	Projection r @noinit;
+
+	F25519Int a = s.x * s.x;
+	F25519Int b = s.y * s.y;
+	F25519Int c = (s.z * s.z).mul_s(2);
+	F25519Int d = s.x + s.y;
+	F25519Int e = d * d - a - b;
+	F25519Int g = b - a;
+	F25519Int f = g - c;
+	F25519Int h = -b - a;
+
+	r.x = e * f;
+	r.y = g * h;
+	r.t = e * h;
+	r.z = f * g;
+
+	return r;
+}
+
+<*
+ Variable base scalar multiplication.
+
+ @param [&in] s
+ @param [in] n
+*>
+fn Projection Projection.mul(&s, char[] n) @operator(*)
+{
+	Projection r = NEUTRAL;
+
+	for (isz i = n.len << 3 - 1; i >= 0; i--)
+	{
+		r = r.twice();
+
+		Projection t = r + s;
+
+		char bit = n[i >> 3] >> (i & 7) & 1;
+		r.x = f25519_select(&r.x, &t.x, bit);
+		r.y = f25519_select(&r.y, &t.y, bit);
+		r.z = f25519_select(&r.z, &t.z, bit);
+		r.t = f25519_select(&r.t, &t.t, bit);
+	}
+
+	return r;
+}
+
+
+
+/*
+ Modular arithmetic over the prime field F_(2^255-19)
+*/
+
+module std::crypto::ed25519 @private;
+
+typedef F25519Int = inline char[32];
+
+const F25519Int ZERO = {};
+const F25519Int ONE = {[0] = 1};
+
+<*
+ Reduce an element with carry to at most 2^255+18 (32 bytes)
+
+ @param [&inout] s
+*>
+fn void F25519Int.reduce_carry(&s, uint carry)
+{
+	// Reduce using 2^255 = 19 mod p
+	(*s)[^1] &= 0b01111111;
+
+	carry *= 19;
+
+	foreach (i, &v : s)
+	{
+		carry += *v;
+		*v = (char)carry;
+		carry >>= 8;
+	}
+}
+
+<*
+ Reduce an element to at most 2^255-19
+
+ @param [&inout] s
+*>
+fn void F25519Int.normalize(&s)
+{
+	s.reduce_carry((*s)[^1] >> 7);
+
+	// Subtract p
+	F25519Int sub @noinit;
+	ushort c = 19;
+	foreach (i, v : (*s)[:^1])
+	{
+		c += v;
+		sub[i] = (char)c;
+		c >>= 8;
+	}
+	c += (*s)[^1] - 0b10000000;
+	sub[^1] = (char)c;
+
+	*s = f25519_select(&sub, s, (char)(c >> 15));
+}
+
+<*
+ Constant-time equality comparison. Return is non-zero if true.
+
+ @param [&in] a
+ @param [&in] b
+*>
+fn char eq(F25519Int* a, F25519Int* b)
+{
+	char e;
+	foreach (i, v : a) e |= v ^ (*b)[i];
+
+	e |= (e >> 4);
+	e |= (e >> 2);
+	e |= (e >> 1);
+
+	return e ^ 1;
+}
+
+<*
+ Constant-time conditional selection. Result is undefined if condition is neither 0 nor 1.
+
+ @param [&in] zero : "selected if condition is 0"
+ @param [&in] one : "selected if condition is 1"
+*>
+fn F25519Int f25519_select(F25519Int* zero, F25519Int* one, char condition)
+{
+	F25519Int r @noinit;
+
+	foreach (i, z : zero) r[i] = z ^ (-condition & ((*one)[i] ^ z));
+
+	return r;
+}
+
+macro F25519Int F25519Int.@add(&s, F25519Int #n) @operator(+) => s.add(@addr(#n));
+
+<*
+ Addition.
+
+ @param [&in] s
+ @param [&in] n
+*>
+fn F25519Int F25519Int.add(&s, F25519Int* n) @operator(+)
+{
+	F25519Int r @noinit;
+
+	ushort c;
+	foreach (i, v : s)
+	{
+		c >>= 8;
+		c += v + (*n)[i];
+		r[i] = (char)c;
+	}
+
+	r.reduce_carry(c >> 7);
+
+	return r;
+}
+
+macro F25519Int F25519Int.@sub(&s, F25519Int #n) @operator(-) => s.sub(@addr(#n));
+
+<*
+ Subtraction.
+
+ @param [&in] s
+ @param [&in] n
+*>
+fn F25519Int F25519Int.sub(&s, F25519Int* n) @operator(-)
+{
+	// Compute s+2*p-n instead of s-n to avoid underflow.
+	F25519Int r @noinit;
+
+	uint c = (char)~(2 * 19 - 1);
+	foreach (i, v : (*s)[:^1])
+	{
+		c += 0b11111111_00000000 + v - (*n)[i];
+		r[i] = (char)c;
+		c >>= 8;
+	}
+	c += (*s)[^1] - (*n)[^1];
+	r[^1] = (char)c;
+
+	r.reduce_carry(c >> 7);
+
+	return r;
+}
+
+<*
+ Negation.
+
+ @param [&in] s
+*>
+fn F25519Int F25519Int.neg(&s) @operator(-)
+{
+	// Compute 2*p-s instead of -s to avoid underflow.
+	F25519Int r @noinit;
+
+	uint c = (char)~(2 * 19 - 1);
+	foreach (i, v : (*s)[:^1])
+	{
+		c += 0b11111111_00000000 - v;
+		r[i] = (char)c;
+		c >>= 8;
+	}
+	c -= (*s)[^1];
+	r[^1] = (char)c;
+
+	r.reduce_carry(c >> 7);
+
+	return r;
+}
+
+macro F25519Int F25519Int.@mul(&s, F25519Int #n) @operator(*) => s.mul(@addr(#n));
+
+<*
+ Multiplication.
+
+ @param [&in] s
+ @param [&in] n
+*>
+fn F25519Int F25519Int.mul(&s, F25519Int* n) @operator(*)
+{
+	F25519Int r @noinit;
+
+	uint c;
+	for (usz i = 0; i < F25519Int.len; i++)
+	{
+		c >>= 8;
+		for (usz j; j <= i; j++) c += (*s)[j] * (*n)[i - j];
+		// Reduce using 2^256 = 2*19 mod p
+		for (usz j = i + 1; j < F25519Int.len; j++) c += (*s)[j] * (*n)[^j - i] * 2 * 19;
+		r[i] = (char)c;
+	}
+
+	r.reduce_carry(c >> 7);
+
+	return r;
+}
+
+<*
+ Multiplication by a small element.
+
+ @param [&in] s
+*>
+fn F25519Int F25519Int.mul_s(&s, uint n)
+{
+	F25519Int r @noinit;
+
+	uint c;
+	foreach (i, v : s)
+	{
+		c >>= 8;
+		c += v * n;
+		r[i] = (char)c;
+	}
+
+	r.reduce_carry(c >> 7);
+
+	return r;
+}
+
+<*
+ Inverse an element.
+
+ @param [&in] s
+*>
+fn F25519Int F25519Int.inv(&s)
+{
+	//Compute s^(p-2)
+	F25519Int r = *s;
+
+	for (usz i; i < 255 - 1 - 5; i++) r = r * r * s;
+
+	r *= r;
+	r = r * r * s;
+	r *= r;
+	r = r * r * s;
+	r = r * r * s;
+
+	return r;
+}
+
+<*
+ Raise an element to the power of 2^252-3
+
+ @param [&in] s
+*>
+fn F25519Int F25519Int.pow_2523(&s) @local
+{
+	F25519Int r = *s;
+
+	for (usz i; i < 252 - 1 - 2; i++) r = r * r * s;
+
+	r *= r;
+	r = r * r * s;
+
+	return r;
+}
+
+<*
+ Compute the square root of an element.
+
+ @param [&in] s
+*>
+fn F25519Int F25519Int.sqrt(&s)
+{
+	F25519Int twice = s.mul_s(2);
+	F25519Int pow = twice.pow_2523();
+
+	return (twice * pow * pow - ONE) * s * pow;
+}
+
+
+
+/*
+ Modular arithmetic over the prime field F_(2^252+0x14def9dea2f79cd65812631a5cf5d3ed)
+*/
+
+module std::crypto::ed25519 @private;
+import std::math;
+
+typedef FBaseInt = inline char[32];
+
+// Order of the field : 2^252+0x14def9dea2f79cd65812631a5cf5d3ed
+const FBaseInt ORDER = x"edd3f55c1a631258 d69cf7a2def9de14 0000000000000000 0000000000000010";
+
+<*
+ Interpret bytes as a normalized element.
+
+ @param [in] bytes
+*>
+fn FBaseInt from_bytes(char[] bytes)
+{
+	FBaseInt r;
+
+	usz bitc = min(252 - 1, bytes.len << 3);
+	usz bytec = bitc >> 3;
+	usz mod = bitc & 7;
+	usz rem = bytes.len << 3 - bitc;
+
+	r[:bytec] = bytes[^bytec..];
+
+	if (mod)
+	{
+		r <<= mod;
+		r[0] |= bytes[^bytec + 1] >> (8 - mod);
+	}
+
+	for (isz i = rem - 1; i >= 0; i--)
+	{
+		r <<= 1;
+		r[0] |= bytes[i >> 3] >> (i & 7) & 1;
+		r = r.sub_l(&ORDER);
+	}
+
+	return r;
+}
+
+<*
+ Constant-time conditional selection. Result is undefined if condition is neither 0 nor 1.
+
+ @param [&in] zero : "selected if condition is 0"
+ @param [&in] one : "selected if condition is 1"
+*>
+fn FBaseInt fbase_select(FBaseInt* zero, FBaseInt* one, char condition)
+{
+	FBaseInt r @noinit;
+
+	foreach (i, z : zero) r[i] = z ^ (-condition & ((*one)[i] ^ z));
+
+	return r;
+}
+
+macro FBaseInt FBaseInt.@add(&s, FBaseInt #n) @operator(+) => s.add(@addr(#n));
+
+<*
+ Addition.
+
+ @param [&in] s
+ @param [&in] n
+*>
+fn FBaseInt FBaseInt.add(&s, FBaseInt* n) @operator(+)
+{
+	FBaseInt r @noinit;
+
+	ushort c;
+	foreach (i, v : s)
+	{
+		c += v + (*n)[i];
+		r[i] = (char)c;
+		c >>= 8;
+	}
+
+	return r.sub_l(&ORDER);
+}
+
+<*
+ Subtraction if RHS is less than LHS else identity.
+
+ @param [&in] s
+ @param [&in] n
+*>
+fn FBaseInt FBaseInt.sub_l(&s, FBaseInt* n)
+{
+	FBaseInt sub @noinit;
+	ushort c;
+	foreach (i, v : s)
+	{
+		c = v - (*n)[i] - c;
+		sub[i] = (char)c;
+		c = (c >> 8) & 1;
+	}
+
+	return fbase_select(&sub, s, (char)c);
+}
+
+<*
+ Left shift.
+
+ @param [&in] s
+*>
+fn FBaseInt FBaseInt.shl(&s, usz n) @operator(<<)
+{
+	FBaseInt r @noinit;
+
+	ushort c;
+	foreach (i, v : s)
+	{
+		c |= v << n;
+		r[i] = (char)c;
+		c >>= 8;
+	}
+
+	return r;
+}
+
+macro FBaseInt FBaseInt.@mul(&s, FBaseInt #n) @operator(*) => s.mul(@addr(#n));
+<*
+ Multiplication.
+
+ @param [&in] s
+ @param [&in] n
+*>
+fn FBaseInt FBaseInt.mul(&s, FBaseInt* n) @operator(*)
+{
+	FBaseInt r;
+
+	for (isz i = 252; i >= 0; i--)
+	{
+		r = (r << 1).sub_l(&ORDER);
+		r = fbase_select(&r, &&(r + s), (*n)[i >> 3] >> (i & 7) & 1);
+	}
+
+	return r;
+}
--- a/lib/std/crypto/rc4.c3
+++ b/lib/std/crypto/rc4.c3
@@ -12,8 +12,8 @@ struct Rc4
 <*
 Initialize the RC4 state.

- @param [in] key "The key to use"
- @require key.len > 0 "The key must be at least 1 byte long"
+ @param [in] key : "The key to use"
+ @require key.len > 0 : "The key must be at least 1 byte long"
 *>
 fn void Rc4.init(&self, char[] key)
 {
@@ -43,9 +43,9 @@ fn void crypt(char[] key, char[] data)
 <*
 Encrypt or decrypt a sequence of bytes.

- @param [in] in "The input"
- @param [out] out "The output"
- @require in.len <= out.len "Output would overflow"
+ @param [in] in : "The input"
+ @param [out] out : "The output"
+ @require in.len <= out.len : "Output would overflow"
 *>
 fn void Rc4.crypt(&self, char[] in, char[] out)
 {
@@ -67,7 +67,7 @@ fn void Rc4.crypt(&self, char[] in, char[] out)
 <*
 Clear the rc4 state.

- @param [&out] self "The RC4 State"
+ @param [&out] self : "The RC4 State"
 *>
 fn void Rc4.destroy(&self)
 {
--- a/lib/std/encoding/base32.c3
+++ b/lib/std/encoding/base32.c3
@@ -14,13 +14,13 @@ const char DEFAULT_PAD = '=';

 <*
 Encode the content of src into a newly allocated string
- @param [in] src "The input to be encoded."
- @param padding "The padding character or 0 if none"
- @param alphabet "The alphabet to use"
- @require padding < 0xFF "Invalid padding character"
+ @param [in] src : "The input to be encoded."
+ @param padding : "The padding character or 0 if none"
+ @param alphabet : "The alphabet to use"
+ @require padding < 0xFF : "Invalid padding character"
 @return "The encoded string."
 *>
-fn String! encode(char[] src, Allocator allocator, char padding = DEFAULT_PAD, Base32Alphabet* alphabet = &STANDARD)
+fn String? encode(Allocator allocator, char[] src, char padding = DEFAULT_PAD, Base32Alphabet* alphabet = &STANDARD)
 {
 	char[] dst = allocator::alloc_array(allocator, char, encode_len(src.len, padding));
 	return encode_buffer(src, dst, padding, alphabet);
@@ -28,28 +28,26 @@ fn String! encode(char[] src, Allocator allocator, char padding = DEFAULT_PAD, B

 <*
 Decode the content of src into a newly allocated char array.
- @param [in] src "The input to be encoded."
- @param padding "The padding character or 0 if none"
- @param alphabet "The alphabet to use"
- @require padding < 0xFF "Invalid padding character"
+ @param [in] src : "The input to be encoded."
+ @param padding : "The padding character or 0 if none"
+ @param alphabet : "The alphabet to use"
+ @require padding < 0xFF : "Invalid padding character"
 @return "The decoded data."
 *>
-fn char[]! decode(char[] src, Allocator allocator, char padding = DEFAULT_PAD, Base32Alphabet* alphabet = &STANDARD)
+fn char[]? decode(Allocator allocator, char[] src, char padding = DEFAULT_PAD, Base32Alphabet* alphabet = &STANDARD)
 {
 	char[] dst = allocator::alloc_array(allocator, char, decode_len(src.len, padding));
 	return decode_buffer(src, dst, padding, alphabet);
 }

-fn String! encode_new(char[] code, char padding = DEFAULT_PAD, Base32Alphabet* alphabet = &STANDARD) @inline => encode(code, allocator::heap(), padding, alphabet);
-fn String! encode_temp(char[] code, char padding = DEFAULT_PAD, Base32Alphabet* alphabet = &STANDARD) @inline => encode(code, allocator::temp(), padding, alphabet);
-fn char[]! decode_new(char[] code, char padding = DEFAULT_PAD, Base32Alphabet* alphabet = &STANDARD) @inline => decode(code, allocator::heap(), padding, alphabet);
-fn char[]! decode_temp(char[] code, char padding = DEFAULT_PAD, Base32Alphabet* alphabet = &STANDARD) @inline => decode(code, allocator::temp(), padding, alphabet);
+fn String? tencode(char[] code, char padding = DEFAULT_PAD, Base32Alphabet* alphabet = &STANDARD) @inline => encode(tmem, code, padding, alphabet);
+fn char[]? tdecode(char[] code, char padding = DEFAULT_PAD, Base32Alphabet* alphabet = &STANDARD) @inline => decode(tmem, code, padding, alphabet);

 <*
 Calculate the length in bytes of the decoded data.
- @param n "Length in bytes of input."
- @param padding "The padding character or 0 if none"
- @require padding < 0xFF "Invalid padding character"
+ @param n : "Length in bytes of input."
+ @param padding : "The padding character or 0 if none"
+ @require padding < 0xFF : "Invalid padding character"
 @return "Length in bytes of the decoded data."
 *>
 fn usz decode_len(usz n, char padding)
@@ -62,9 +60,9 @@ fn usz decode_len(usz n, char padding)

 <*
 Calculate the length in bytes of the encoded data.
- @param n "Length in bytes on input."
- @param padding "The padding character or 0 if none"
- @require padding < 0xFF "Invalid padding character"
+ @param n : "Length in bytes on input."
+ @param padding : "The padding character or 0 if none"
+ @require padding < 0xFF : "Invalid padding character"
 @return "Length in bytes of the encoded data."
 *>
 fn usz encode_len(usz n, char padding)
@@ -79,16 +77,16 @@ fn usz encode_len(usz n, char padding)

 <*
 Decode the content of src into dst, which must be properly sized.
- @param src "The input to be decoded."
- @param dst "The decoded input."
- @param padding "The padding character or 0 if none"
- @param alphabet "The alphabet to use"
- @require padding < 0xFF "Invalid padding character"
- @require dst.len >= decode_len(src.len, padding) "Destination buffer too small"
+ @param src : "The input to be decoded."
+ @param dst : "The decoded input."
+ @param padding : "The padding character or 0 if none"
+ @param alphabet : "The alphabet to use"
+ @require padding < 0xFF : "Invalid padding character"
+ @require dst.len >= decode_len(src.len, padding) : "Destination buffer too small"
 @return "The resulting dst buffer"
- @return! DecodingFailure
+ @return? encoding::INVALID_PADDING, encoding::INVALID_CHARACTER
 *>
-fn char[]! decode_buffer(char[] src, char[] dst, char padding = DEFAULT_PAD, Base32Alphabet* alphabet = &STANDARD)
+fn char[]? decode_buffer(char[] src, char[] dst, char padding = DEFAULT_PAD, Base32Alphabet* alphabet = &STANDARD)
 {
 	if (src.len == 0) return dst[:0];
 	char* dst_ptr = dst;
@@ -103,12 +101,12 @@ fn char[]! decode_buffer(char[] src, char[] dst, char padding = DEFAULT_PAD, Bas
 		{
 			if (src.len == 0)
 			{
-				if (padding > 0) return DecodingFailure.INVALID_PADDING?;
+				if (padding > 0) return encoding::INVALID_PADDING?;
 				break;
 			}
 			if (src[0] == padding) break;
 			buf[i] = alphabet.reverse[src[0]];
-			if (buf[i] == INVALID) return DecodingFailure.INVALID_CHARACTER?;
+			if (buf[i] == INVALID) return encoding::INVALID_CHARACTER?;
 			src = src[1..];
 		}

@@ -152,7 +150,7 @@ fn char[]! decode_buffer(char[] src, char[] dst, char padding = DEFAULT_PAD, Bas
 				dst[0] = buf[1] >> 2 | buf[0] << 3;
 				n++;
 			default:
-				return DecodingFailure.INVALID_CHARACTER?;
+				return encoding::INVALID_CHARACTER?;
 		}
 		if (dst.len < 5) break;
 		dst = dst[5..];
@@ -162,12 +160,12 @@ fn char[]! decode_buffer(char[] src, char[] dst, char padding = DEFAULT_PAD, Bas

 <*
 Encode the content of src into dst, which must be properly sized.
- @param [in] src "The input to be encoded."
- @param [inout] dst "The encoded input."
- @param padding "The padding character or 0 if none"
- @param alphabet "The alphabet to use"
- @require padding < 0xFF "Invalid padding character"
- @require dst.len >= encode_len(src.len, padding) "Destination buffer too small"
+ @param [in] src : "The input to be encoded."
+ @param [inout] dst : "The encoded input."
+ @param padding : "The padding character or 0 if none"
+ @param alphabet : "The alphabet to use"
+ @require padding < 0xFF : "Invalid padding character"
+ @require dst.len >= encode_len(src.len, padding) : "Destination buffer too small"
 @return "The encoded size."
 *>
 fn String encode_buffer(char[] src, char[] dst, char padding = DEFAULT_PAD, Base32Alphabet* alphabet = &STANDARD)
@@ -244,138 +242,7 @@ const char INVALID @private = 0xff;
 const int STD_PADDING = '=';
 const int NO_PADDING = -1;

-fault Base32Error
-{
-	DUPLICATE_IN_ALPHABET,
-	PADDING_IN_ALPHABET,
-	INVALID_CHARACTER_IN_ALPHABET,
-	DESTINATION_TOO_SMALL,
-	INVALID_PADDING,
-	CORRUPT_INPUT
-}
-
-struct Base32Encoder @deprecated
-{
-	Base32Alphabet alphabet;
-	char padding;
-}
-
-<*
- @param encoder "The 32-character alphabet for encoding."
- @param padding "Set to a negative value to disable padding."
- @require padding < 256
-*>
-fn void! Base32Encoder.init(&self, Alphabet encoder = STD_ALPHABET, int padding = STD_PADDING)
-{
-	encoder.validate(padding)!;
-	*self = { .alphabet = { .encoding = (char[32])encoder }, .padding = padding < 0 ? (char)0 : (char)padding};
-}
-
-<*
- Calculate the length in bytes of the encoded data.
- @param n "Length in bytes on input."
- @return "Length in bytes of the encoded data."
-*>
-fn usz Base32Encoder.encode_len(&self, usz n)
-{
-	return encode_len(n, self.padding);
-}
-
-<*
- Encode the content of src into dst, which must be properly sized.
- @param [in] src "The input to be encoded."
- @param [inout] dst "The encoded input."
- @return "The encoded size."
- @return! Base32Error.DESTINATION_TOO_SMALL
-*>
-fn usz! Base32Encoder.encode(&self, char[] src, char[] dst)
-{
-	usz dn = self.encode_len(src.len);
-	if (dst.len < dn) return Base32Error.DESTINATION_TOO_SMALL?;
-	return encode_buffer(src, dst, self.padding, &self.alphabet).len;
-}
-
-struct Base32Decoder @deprecated
-{
-	Base32Alphabet alphabet;
-	char padding;
-}
-
-<*
- @param decoder "The alphabet used for decoding."
- @param padding "Set to a negative value to disable padding."
- @require padding < 256
-*>
-fn void! Base32Decoder.init(&self, Alphabet decoder = STD_ALPHABET, int padding = STD_PADDING)
-{
-	decoder.validate(padding)!;
-	*self = { .alphabet = { .encoding = (char[32])decoder }, .padding = padding < 0 ? (char)0 : (char)padding };
-
-	self.alphabet.reverse[..] = INVALID;
-	foreach (char i, c : decoder)
-	{
-		self.alphabet.reverse[c] = i;
-	}
-}
-
-<*
- Calculate the length in bytes of the decoded data.
- @param n "Length in bytes of input."
- @return "Length in bytes of the decoded data."
-*>
-fn usz Base32Decoder.decode_len(&self, usz n)
-{
-	return decode_len(n, self.padding);
-}
-
-<*
- Decode the content of src into dst, which must be properly sized.
- @param src "The input to be decoded."
- @param dst "The decoded input."
- @return "The decoded size."
- @return! Base32Error.DESTINATION_TOO_SMALL, Base32Error.CORRUPT_INPUT
-*>
-fn usz! Base32Decoder.decode(&self, char[] src, char[] dst)
-{
-	if (src.len == 0) return 0;
-	usz dn = self.decode_len(src.len);
-	if (dst.len < dn) return Base32Error.DESTINATION_TOO_SMALL?;
-	return decode_buffer(src, dst, self.padding, &self.alphabet).len;
-}
-
-
-// Validate the 32-character alphabet to make sure that no character occurs
-// twice and that the padding is not present in the alphabet.
-fn void! Alphabet.validate(&self, int padding)
-{
-	bool[256] checked;
-	foreach (c : self)
-	{
-		if (checked[c])
-		{
-			return Base32Error.DUPLICATE_IN_ALPHABET?;
-		}
-		checked[c] = true;
-		if (c == '\r' || c == '\n')
-		{
-			return Base32Error.INVALID_CHARACTER_IN_ALPHABET?;
-		}
-	}
-	if (padding >= 0)
-	{
-		char pad = (char)padding;
-		if (pad == '\r' || pad == '\n')
-		{
-			return Base32Error.INVALID_PADDING?;
-		}
-		if (checked[pad])
-		{
-			return Base32Error.PADDING_IN_ALPHABET?;
-		}
-	}
-}
-
-distinct Alphabet = char[32];
+typedef Alphabet = char[32];
 // Standard base32 Alphabet
 const Alphabet STD_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
 // Extended Hex Alphabet
--- a/lib/std/encoding/base64.c3
+++ b/lib/std/encoding/base64.c3
@@ -43,29 +43,27 @@ const Base64Alphabet URL = {
 const STD_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 const URL_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";

-fn String encode(char[] src, Allocator allocator, char padding = DEFAULT_PAD, Base64Alphabet* alphabet = &STANDARD)
+fn String encode(Allocator allocator, char[] src, char padding = DEFAULT_PAD, Base64Alphabet* alphabet = &STANDARD)
 {
 	char[] dst = allocator::alloc_array(allocator, char, encode_len(src.len, padding));
 	return encode_buffer(src, dst, padding, alphabet);
 }

-fn char[]! decode(char[] src, Allocator allocator, char padding = DEFAULT_PAD, Base64Alphabet* alphabet = &STANDARD)
+fn char[]? decode(Allocator allocator, char[] src, char padding = DEFAULT_PAD, Base64Alphabet* alphabet = &STANDARD)
 {
 	char[] dst = allocator::alloc_array(allocator, char, decode_len(src.len, padding))!;
 	return decode_buffer(src, dst, padding, alphabet);
 }

-fn String encode_new(char[] code, char padding = DEFAULT_PAD, Base64Alphabet* alphabet = &STANDARD) @inline => encode(code, allocator::heap(), padding, alphabet);
-fn String encode_temp(char[] code, char padding = DEFAULT_PAD, Base64Alphabet* alphabet = &STANDARD) @inline => encode(code, allocator::temp(), padding, alphabet);
-fn char[]! decode_new(char[] code, char padding = DEFAULT_PAD, Base64Alphabet* alphabet = &STANDARD) @inline => decode(code, allocator::heap(), padding, alphabet);
-fn char[]! decode_temp(char[] code, char padding = DEFAULT_PAD, Base64Alphabet* alphabet = &STANDARD) @inline => decode(code, allocator::temp(), padding, alphabet);
+fn String tencode(char[] code, char padding = DEFAULT_PAD, Base64Alphabet* alphabet = &STANDARD) @inline => encode(tmem, code, padding, alphabet);
+fn char[]? tdecode(char[] code, char padding = DEFAULT_PAD, Base64Alphabet* alphabet = &STANDARD) @inline => decode(tmem, code, padding, alphabet);


 <*
 Calculate the size of the encoded data.
- @param n "Size of the input to be encoded."
- @param padding "The padding character or 0 if none"
- @require padding < 0xFF "Invalid padding character"
+ @param n : "Size of the input to be encoded."
+ @param padding : "The padding character or 0 if none"
+ @require padding < 0xFF : "Invalid padding character"
 @return "The size of the input once encoded."
 *>
 fn usz encode_len(usz n, char padding)
@@ -77,35 +75,34 @@ fn usz encode_len(usz n, char padding)

 <*
 Calculate the size of the decoded data.
- @param n "Size of the input to be decoded."
- @param padding "The padding character or 0 if none"
- @require padding < 0xFF "Invalid padding character"
+ @param n : "Size of the input to be decoded."
+ @param padding : "The padding character or 0 if none"
+ @require padding < 0xFF : "Invalid padding character"
 @return "The size of the input once decoded."
- @return! DecodingFailure.INVALID_PADDING
+ @return? encoding::INVALID_PADDING
 *>
-fn usz! decode_len(usz n, char padding)
+fn usz? decode_len(usz n, char padding)
 {
 	usz dn = n / 4 * 3;
 	usz trailing = n % 4;
 	if (padding)
 	{
-		if (trailing != 0) return DecodingFailure.INVALID_PADDING?;
+		if (trailing != 0) return encoding::INVALID_PADDING?;
 		// source size is multiple of 4
 		return dn;
 	}
-	if (trailing == 1) return DecodingFailure.INVALID_PADDING?;
+	if (trailing == 1) return encoding::INVALID_PADDING?;
 	return dn + trailing * 3 / 4;
 }

 <*
 Encode the content of src into dst, which must be properly sized.
- @param src "The input to be encoded."
- @param dst "The encoded input."
- @param padding "The padding character or 0 if none"
- @param alphabet "The alphabet to use"
- @require padding < 0xFF "Invalid padding character"
+ @param src : "The input to be encoded."
+ @param dst : "The encoded input."
+ @param padding : "The padding character or 0 if none"
+ @param alphabet : "The alphabet to use"
+ @require padding < 0xFF : "Invalid padding character"
 @return "The encoded size."
- @return! Base64Error.DESTINATION_TOO_SMALL
 *>
 fn String encode_buffer(char[] src, char[] dst, char padding = DEFAULT_PAD, Base64Alphabet* alphabet = &STANDARD)
 {
@@ -159,16 +156,16 @@ fn String encode_buffer(char[] src, char[] dst, char padding = DEFAULT_PAD, Base

 <*
 Decode the content of src into dst, which must be properly sized.
- @param src "The input to be decoded."
- @param dst "The decoded input."
- @param padding "The padding character or 0 if none"
- @param alphabet "The alphabet to use"
- @require (decode_len(src.len, padding) ?? 0) <= dst.len "Destination buffer too small"
- @require padding < 0xFF "Invalid padding character"
+ @param src : "The input to be decoded."
+ @param dst : "The decoded input."
+ @param padding : "The padding character or 0 if none"
+ @param alphabet : "The alphabet to use"
+ @require (decode_len(src.len, padding) ?? 0) <= dst.len : "Destination buffer too small"
+ @require padding < 0xFF : "Invalid padding character"
 @return "The decoded data."
- @return! DecodingFailure
+ @return? encoding::INVALID_CHARACTER, encoding::INVALID_PADDING
 *>
-fn char[]! decode_buffer(char[] src, char[] dst, char padding = DEFAULT_PAD, Base64Alphabet* alphabet = &STANDARD)
+fn char[]? decode_buffer(char[] src, char[] dst, char padding = DEFAULT_PAD, Base64Alphabet* alphabet = &STANDARD)
 {
 	if (src.len == 0) return dst[:0];
 	usz dn = decode_len(src.len, padding)!;
@@ -199,7 +196,7 @@ fn char[]! decode_buffer(char[] src, char[] dst, char padding = DEFAULT_PAD, Bas
 			case c1:
 			case c2:
 			case c3:
-				return DecodingFailure.INVALID_CHARACTER?;
+				return encoding::INVALID_CHARACTER?;
 		}
 		uint group = (uint)c0 << 18 | (uint)c1 << 12 | (uint)c2 << 6 | (uint)c3;
 		dst[0] = (char)(group >> 16);
@@ -214,7 +211,7 @@ fn char[]! decode_buffer(char[] src, char[] dst, char padding = DEFAULT_PAD, Bas
 	src = src[^trailing..];
 	char c0 = alphabet.reverse[src[0]];
 	char c1 = alphabet.reverse[src[1]];
-	if (c0 == 0xFF || c1 == 0xFF) return DecodingFailure.INVALID_PADDING?;
+	if (c0 == 0xFF || c1 == 0xFF) return encoding::INVALID_PADDING?;
 	if (!padding)
 	{
 		switch (src.len)
@@ -224,7 +221,7 @@ fn char[]! decode_buffer(char[] src, char[] dst, char padding = DEFAULT_PAD, Bas
 				dst[0] = (char)(group >> 16);
 			case 3:
 				char c2 = alphabet.reverse[src[2]];
-				if (c2 == 0xFF) return DecodingFailure.INVALID_CHARACTER?;
+				if (c2 == 0xFF) return encoding::INVALID_CHARACTER?;
 				uint group = (uint)c0 << 18 | (uint)c1 << 12 | (uint)c2 << 6;
 				dst[0] = (char)(group >> 16);
 				dst[1] = (char)(group >> 8);
@@ -238,13 +235,13 @@ fn char[]! decode_buffer(char[] src, char[] dst, char padding = DEFAULT_PAD, Bas
 		switch (padding)
 		{
 			case src[2]:
-				if (src[3] != padding) return DecodingFailure.INVALID_PADDING?;
+				if (src[3] != padding) return encoding::INVALID_PADDING?;
 				uint group = (uint)c0 << 18 | (uint)c1 << 12;
 				dst[0] = (char)(group >> 16);
 				dn -= 2;
 			case src[3]:
 				char c2 = alphabet.reverse[src[2]];
-				if (c2 == 0xFF) return DecodingFailure.INVALID_CHARACTER?;
+				if (c2 == 0xFF) return encoding::INVALID_CHARACTER?;
 				uint group = (uint)c0 << 18 | (uint)c1 << 12 | (uint)c2 << 6;
 				dst[0] = (char)(group >> 16);
 				dst[1] = (char)(group >> 8);
@@ -256,146 +253,3 @@ fn char[]! decode_buffer(char[] src, char[] dst, char padding = DEFAULT_PAD, Bas

 const MASK @private = 0b111111;

-struct Base64Encoder @deprecated
-{
-	char padding;
-	String alphabet;
-}
-
-fault Base64Error
-{
-	DUPLICATE_IN_ALPHABET,
-	PADDING_IN_ALPHABET,
-	DESTINATION_TOO_SMALL,
-	INVALID_PADDING,
-	INVALID_CHARACTER,
-}
-
-<*
- @param alphabet "The alphabet used for encoding."
- @param padding "Set to a negative value to disable padding."
- @require alphabet.len == 64
- @require padding < 256
- @return! Base64Error.DUPLICATE_IN_ALPHABET, Base64Error.PADDING_IN_ALPHABET
-*>
-fn Base64Encoder*! Base64Encoder.init(&self, String alphabet, int padding = '=')
-{
-	check_alphabet(alphabet, padding)!;
-	*self = { .padding = padding < 0 ? 0 : (char)padding, .alphabet = alphabet };
-	return self;
-}
-
-<*
- Calculate the size of the encoded data.
- @param n "Size of the input to be encoded."
- @return "The size of the input once encoded."
-*>
-fn usz Base64Encoder.encode_len(&self, usz n)
-{
-	return encode_len(n, self.padding);
-}
-
-<*
- Encode the content of src into dst, which must be properly sized.
- @param src "The input to be encoded."
- @param dst "The encoded input."
- @return "The encoded size."
- @return! Base64Error.DESTINATION_TOO_SMALL
-*>
-fn usz! Base64Encoder.encode(&self, char[] src, char[] dst)
-{
-	if (src.len == 0) return 0;
-	usz dn = self.encode_len(src.len);
-	if (dst.len < dn) return Base64Error.DESTINATION_TOO_SMALL?;
-	Base64Alphabet a = { .encoding = self.alphabet[:64] };
-	return encode_buffer(src, dst, self.padding, &a).len;
-}
-
-struct Base64Decoder @deprecated
-{
-	char padding;
-	Base64Alphabet encoding;
-	bool init_done;
-}
-
-import std;
-<*
- @param alphabet "The alphabet used for encoding."
- @param padding "Set to a negative value to disable padding."
- @require alphabet.len == 64
- @require padding < 256
- @return! Base64Error.DUPLICATE_IN_ALPHABET, Base64Error.PADDING_IN_ALPHABET
-*>
-fn void! Base64Decoder.init(&self, String alphabet, int padding = '=')
-{
-	self.init_done = true;
-	check_alphabet(alphabet, padding)!;
-	*self = { .padding = padding < 0 ? 0 : (char)padding, .encoding.encoding = alphabet[:64] };
-
-	self.encoding.reverse[..] = 0xFF;
-
-	foreach (i, c : alphabet)
-	{
-		self.encoding.reverse[c] = (char)i;
-	}
-}
-
-<*
- Calculate the size of the decoded data.
- @param n "Size of the input to be decoded."
- @return "The size of the input once decoded."
- @return! Base64Error.INVALID_PADDING
-*>
-fn usz! Base64Decoder.decode_len(&self, usz n)
-{
-	return decode_len(n, self.padding) ?? Base64Error.INVALID_PADDING?;
-}
-
-<*
- Decode the content of src into dst, which must be properly sized.
- @param src "The input to be decoded."
- @param dst "The decoded input."
- @return "The decoded size."
- @return! Base64Error.DESTINATION_TOO_SMALL, Base64Error.INVALID_PADDING, Base64Error.INVALID_CHARACTER
-*>
-fn usz! Base64Decoder.decode(&self, char[] src, char[] dst)
-{
-	if (src.len == 0) return 0;
-	usz dn = self.decode_len(src.len)!;
-	if (dst.len < dn) return Base64Error.DESTINATION_TOO_SMALL?;
-	char[]! decoded = decode_buffer(src, dst, self.padding, &self.encoding);
-	if (catch err = decoded)
-	{
-		case DecodingFailure.INVALID_PADDING:
-			return Base64Error.INVALID_PADDING?;
-		case DecodingFailure.INVALID_CHARACTER:
-			return Base64Error.INVALID_CHARACTER?;
-		default:
-			return err?;
-	}
-	return decoded.len;
-}
-
-// Make sure that all bytes in the alphabet are unique and
-// the padding is not present in the alphabet.
-fn void! check_alphabet(String alphabet, int padding) @local
-{
-	bool[256] checked;
-	if (padding < 0)
-	{
-		foreach (c : alphabet)
-		{
-			if (checked[c]) return Base64Error.DUPLICATE_IN_ALPHABET?;
-			checked[c] = true;
-		}
-		return;
-	}
-	char pad = (char)padding;
-	foreach (c : alphabet)
-	{
-		if (c == pad) return Base64Error.PADDING_IN_ALPHABET?;
-		if (checked[c]) return Base64Error.DUPLICATE_IN_ALPHABET?;
-		checked[c] = true;
-	}
-}
-
--- a/lib/std/encoding/csv.c3
+++ b/lib/std/encoding/csv.c3
@@ -15,7 +15,7 @@ struct CsvRow (Printable)
 	Allocator allocator;
 }

-fn usz! CsvRow.to_format(&self, Formatter* f) @dynamic
+fn usz? CsvRow.to_format(&self, Formatter* f) @dynamic
 {
 	return f.printf("%s", self.list);
 }
@@ -38,30 +38,24 @@ fn void CsvReader.init(&self, InStream stream, String separator = ",")
 	self.stream = stream;
 	self.separator = separator;
 }
-
-fn CsvRow! CsvReader.read_new_row(self)
-{
-	return self.read_row(allocator::heap()) @inline;
-}
-
 <*
 @param [&inout] allocator
 *>
-fn CsvRow! CsvReader.read_row(self, Allocator allocator)
+fn CsvRow? CsvReader.read_row(self, Allocator allocator)
 {
-	String row = io::readline(self.stream, allocator: allocator)!;
+	String row = io::readline(allocator, self.stream)!;
 	defer catch allocator::free(allocator, row);
-	String[] list = row.split(self.separator, allocator: allocator);
+	String[] list = row.split(allocator, self.separator);
 	return { list, row, allocator };
 }

-fn CsvRow! CsvReader.read_temp_row(self)
+fn CsvRow? CsvReader.tread_row(self)
 {
-	return self.read_row(allocator::temp()) @inline;
+	return self.read_row(tmem) @inline;
 }

 <*
- @require self.allocator != null  `Row already freed`
+ @require self.allocator != null  : `Row already freed`
 *>
 fn void CsvRow.free(&self)
 {
@@ -70,26 +64,32 @@ fn void CsvRow.free(&self)
 	self.allocator = null;
 }

-fn void! CsvReader.skip_row(self) @maydiscard => @pool()
+fn void? CsvReader.skip_row(self) @maydiscard => @pool()
 {
 	(void)io::treadline(self.stream);
 }

-macro void! CsvReader.@each_row(self, int rows = int.max; @body(String[] row)) @maydiscard
+macro void? @each_row(InStream stream, String separator = ",", int max_rows = int.max; @body(String[] row)) @maydiscard
 {
-	InStream stream = self.stream;
-	String sep = self.separator;
-	while (rows--)
+	while (max_rows--)
 	{
-		@stack_mem(512; Allocator mem)
+		@stack_mem(512; mem)
 		{
-			String! s = io::readline(stream, mem);
+			String? s = io::readline(mem, stream);
 			if (catch err = s)
 			{
-				if (err == IoError.EOF) return;
+				if (err == io::EOF) return;
 				return err?;
 			}
-			@body(s.split(sep, allocator: mem));
+			@body(s.split(mem, separator));
 		};
 	}
+}
+
+macro void? CsvReader.@each_row(self, int rows = int.max; @body(String[] row)) @maydiscard
+{
+	return @each_row(self.stream, self.separator, rows; row)
+	{
+		@body(row);
+	};
 }
--- a/lib/std/encoding/encoding.c3
+++ b/lib/std/encoding/encoding.c3
@@ -1,7 +1,3 @@
 module std::encoding;

-fault DecodingFailure
-{
-	INVALID_CHARACTER,
-	INVALID_PADDING,
-}
+faultdef INVALID_CHARACTER, INVALID_PADDING;
--- a/lib/std/encoding/hex.c3
+++ b/lib/std/encoding/hex.c3
@@ -8,41 +8,40 @@ fn String encode_buffer(char[] code, char[] buffer)
 	return (String)buffer[:encode_bytes(code, buffer)];
 }

-fn char[]! decode_buffer(char[] code, char[] buffer)
+fn char[]? decode_buffer(char[] code, char[] buffer)
 {
 	return buffer[:decode_bytes(code, buffer)!];
 }

-fn String encode(char[] code, Allocator allocator)
+fn String encode(Allocator allocator, char[] code)
 {
 	char[] data = allocator::alloc_array(allocator, char, encode_len(code.len));
 	return (String)data[:encode_bytes(code, data)];
 }

-fn char[]! decode(char[] code, Allocator allocator)
+fn char[]? decode(Allocator allocator, char[] code)
 {
 	char[] data = allocator::alloc_array(allocator, char, decode_len(code.len));
 	return data[:decode_bytes(code, data)!];
 }

-fn String encode_new(char[] code) @inline => encode(code, allocator::heap());
-fn String encode_temp(char[] code) @inline => encode(code, allocator::temp());
-fn char[]! decode_new(char[] code) @inline => decode(code, allocator::heap());
-fn char[]! decode_temp(char[] code) @inline => decode(code, allocator::temp());
+fn String tencode(char[] code) @inline => encode(tmem, code);
+fn char[]? tdecode(char[] code) @inline => decode(tmem, code);
+

 <*
 Calculate the size of the encoded data.
- @param n "Size of the input to be encoded."
+ @param n : "Size of the input to be encoded."
 @return "The size of the input once encoded."
 *>
 fn usz encode_len(usz n) => n * 2;

 <*
 Encode the content of src into dst, which must be properly sized.
- @param src "The input to be encoded."
- @param dst "The encoded input."
+ @param src : "The input to be encoded."
+ @param dst : "The encoded input."
 @return "The encoded size."
- @require dst.len >= encode_len(src.len) "Destination array is not large enough"
+ @require dst.len >= encode_len(src.len) : "Destination array is not large enough"
 *>
 fn usz encode_bytes(char[] src, char[] dst)
 {
@@ -58,7 +57,7 @@ fn usz encode_bytes(char[] src, char[] dst)

 <*
 Calculate the size of the decoded data.
- @param n "Size of the input to be decoded."
+ @param n : "Size of the input to be decoded."
 @return "The size of the input once decoded."
 *>
 macro usz decode_len(usz n) => n / 2;
@@ -69,28 +68,28 @@ macro usz decode_len(usz n) => n / 2;
 Expects that src only contains hexadecimal characters and that src has even
 length.

- @param src "The input to be decoded."
- @param dst "The decoded input."
- @require src.len % 2 == 0 "src is not of even length"
- @require dst.len >= decode_len(src.len) "Destination array is not large enough"
- @return! DecodingFailure.INVALID_CHARACTER
+ @param src : "The input to be decoded."
+ @param dst : "The decoded input."
+ @require src.len % 2 == 0 : "src is not of even length"
+ @require dst.len >= decode_len(src.len) : "Destination array is not large enough"
+ @return? encoding::INVALID_CHARACTER
 *>
-fn usz! decode_bytes(char[] src, char[] dst)
+fn usz? decode_bytes(char[] src, char[] dst)
 {
 	usz i;
 	for (usz j = 1; j < src.len; j += 2)
 	{
 		char a = HEXREVERSE[src[j - 1]];
 		char b = HEXREVERSE[src[j]];
-		if (a > 0x0f || b > 0x0f) return DecodingFailure.INVALID_CHARACTER?;
+		if (a > 0x0f || b > 0x0f) return encoding::INVALID_CHARACTER?;
 		dst[i] = (a << 4) | b;
 		i++;
 	}
 	return i;
 }

-const char[?] HEXALPHABET @private = "0123456789abcdef";
-const char[?] HEXREVERSE @private =
+const char[*] HEXALPHABET @private = "0123456789abcdef";
+const char[*] HEXREVERSE @private =
 x`ffffffffffffffffffffffffffffffff
  ffffffffffffffffffffffffffffffff
  ffffffffffffffffffffffffffffffff
--- a/Show More
+++ b/Show More