Address/memory/thread sanitizer.

Add path test windows and escape in double quote.
Add path test windows.
2026-02-27 20:11:17 +00:00 · 2024-08-21 16:01:45 +02:00 · 2024-08-21 10:37:50 +02:00 · 2024-08-21 10:15:45 +02:00 · 2024-08-20 22:42:38 +02:00 · 2024-08-20 22:42:01 +02:00
640 changed files with 40367 additions and 27741 deletions
--- a/.github/FUNDING.yml
+++ b/.github/FUNDING.yml
@@ -0,0 +1,14 @@
+# These are supported funding model platforms
+
+github: [c3lang]
+patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: c3lang
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+otechie: # Replace with a single Otechie username
+lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry
+polar: # Replace with a single Polar username
+custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -2,13 +2,16 @@ name: CI

 on:
  push:
-    branches: [ master, dev, ci_testing ]
+    branches: [ master, dev, ci_testing, experiments ]
  pull_request:
-    branches: [ master ]
+    branches: [ master, dev ]

 env:
-  LLVM_RELEASE_VERSION: 16
-
+  LLVM_RELEASE_VERSION_WINDOWS: 18
+  LLVM_RELEASE_VERSION_MAC: 18
+  LLVM_RELEASE_VERSION_LINUX: 17
+  LLVM_RELEASE_VERSION_UBUNTU20: 17
+  LLVM_DEV_VERSION: 20
 jobs:

  build-msvc:
@@ -33,34 +36,45 @@ jobs:
      - name: Compile and run some examples
        run: |
          cd resources
-          ..\build\${{ matrix.build_type }}\c3c.exe compile-run examples\hello_world_many.c3
-          ..\build\${{ matrix.build_type }}\c3c.exe compile-run examples\time.c3
-          ..\build\${{ matrix.build_type }}\c3c.exe compile-run examples\fannkuch-redux.c3
+          ..\build\${{ matrix.build_type }}\c3c.exe compile-run -L C:\ --print-linking examples\hello_world_many.c3
+          ..\build\${{ matrix.build_type }}\c3c.exe compile-run --print-linking examples\time.c3
+          ..\build\${{ matrix.build_type }}\c3c.exe compile-run --print-linking examples\fannkuch-redux.c3
          ..\build\${{ matrix.build_type }}\c3c.exe compile-run examples\contextfree\boolerr.c3
          ..\build\${{ matrix.build_type }}\c3c.exe compile-run examples\ls.c3
          ..\build\${{ matrix.build_type }}\c3c.exe compile-run examples\load_world.c3
          ..\build\${{ matrix.build_type }}\c3c.exe compile-run examples\process.c3
-          ..\build\${{ matrix.build_type }}\c3c.exe compile --test -g -O0 --threads 1 --target macos-x64 examples\constants.c3                  
+          ..\build\${{ matrix.build_type }}\c3c.exe compile-run examples\args.c3 -- foo -bar "baz baz"
+          ..\build\${{ matrix.build_type }}\c3c.exe compile --no-entry --test -g -O0 --threads 1 --target macos-x64 examples\constants.c3
          ..\build\${{ matrix.build_type }}\c3c.exe compile-run msvc_stack.c3

      - name: Build testproject
        run: |
+          call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvarsall.bat" x64
          cd resources/testproject
          ..\..\build\${{ matrix.build_type }}\c3c.exe --debug-log --emit-llvm run hello_world_win32
          dir build\llvm_ir
          ..\..\build\${{ matrix.build_type }}\c3c.exe clean
          dir build\llvm_ir
-          
+

      - name: Build testproject lib
        run: |
          cd resources/testproject
+          call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvarsall.bat" x64
          ..\..\build\${{ matrix.build_type }}\c3c.exe --debug-log build hello_world_win32_lib

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

+      - name: Try raylib
+        run: |
+          cd resources
+          ..\build\${{ matrix.build_type }}\c3c.exe vendor-fetch raylib
+          ..\build\${{ matrix.build_type }}\c3c.exe compile --lib raylib --wincrt=none examples\raylib\raylib_arkanoid.c3
+          ..\build\${{ matrix.build_type }}\c3c.exe compile --lib raylib --wincrt=none examples\raylib\raylib_snake.c3
+          ..\build\${{ matrix.build_type }}\c3c.exe compile --lib raylib --wincrt=none examples\raylib\raylib_tetris.c3
+
      - name: run compiler tests
        run: |
          cd test
@@ -71,11 +85,18 @@ jobs:
          cd test
          ..\build\${{ matrix.build_type }}\c3c.exe compile-test unit -O1

+      - name: Test python script
+        run: |
+          py msvc_build_libraries.py --accept-license
+          dir msvc_sdk
+
      - name: upload artifacts
        uses: actions/upload-artifact@v3
        with:
          name: c3-windows-${{ matrix.build_type }}
-          path: build\${{ matrix.build_type }}\c3c.exe
+          path: |
+            build\${{ matrix.build_type }}\c3c.exe
+            build\${{ matrix.build_type }}\c3c_rt

  build-msys2-mingw:
    runs-on: windows-latest
@@ -99,8 +120,8 @@ 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-17.0.6-1-any.pkg.tar.zst
-            pacman --noconfirm -U https://mirror.msys2.org/mingw/mingw64/mingw-w64-x86_64-lld-17.0.6-1-any.pkg.tar.zst
+            pacman --noconfirm -U https://mirror.msys2.org/mingw/mingw64/mingw-w64-x86_64-llvm-18.1.8-1-any.pkg.tar.zst
+            pacman --noconfirm -U https://mirror.msys2.org/mingw/mingw64/mingw-w64-x86_64-lld-18.1.8-1-any.pkg.tar.zst
      - name: CMake
        run: |
          cmake -B build -G Ninja -DCMAKE_C_COMPILER=clang -DCMAKE_BUILD_TYPE=${{ matrix.build_type }}
@@ -109,12 +130,13 @@ jobs:
      - name: Compile and run some examples
        run: |
          cd resources
-          ../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 --test -g -O0 --threads 1 --target macos-x64 examples/constants.c3
+          ../build/c3c compile-run --print-linking examples/hello_world_many.c3
+          ../build/c3c compile-run --print-linking examples/time.c3
+          ../build/c3c compile-run --print-linking examples/fannkuch-redux.c3
+          ../build/c3c compile-run --print-linking examples/contextfree/boolerr.c3
+          ../build/c3c compile-run --print-linking examples/load_world.c3
+          ../build/c3c compile-run --print-linking examples/args.c3 -- foo -bar "baz baz"
+          ../build/c3c compile --no-entry --test -g -O0 --threads 1 --target macos-x64 examples/constants.c3

      - name: Build testproject
        run: |
@@ -128,7 +150,7 @@ jobs:
      - name: Build testproject lib
        run: |
          cd resources/testproject
-          ../../build/c3c build hello_world_lib --debug-log
+          ../../build/c3c build hello_world_lib --cc cc --debug-log

      - name: run compiler tests
        run: |
@@ -170,7 +192,8 @@ jobs:
          ../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 --test -g -O0 --threads 1 --target macos-x64 examples/constants.c3
+          ../build/c3c compile-run examples/args.c3 -- foo -bar "baz baz"
+          ../build/c3c compile --no-entry --test -g -O0 --threads 1 --target macos-x64 examples/constants.c3
      - name: Build testproject
        run: |
          cd resources/testproject
@@ -193,7 +216,7 @@ jobs:
      fail-fast: false
      matrix:
        build_type: [Release, Debug]
-        llvm_version: [15, 16, 17, 18]
+        llvm_version: [17, 18, 19, 20]

    steps:
      - uses: actions/checkout@v4
@@ -204,24 +227,29 @@ jobs:
      - name: Install Clang ${{matrix.llvm_version}}
        run: |
          wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -
-          if [[ "${{matrix.llvm_version}}" < 16 ]]; then
-            sudo apt remove libllvm15
-          fi
          if [[ "${{matrix.llvm_version}}" < 18 ]]; then
            sudo add-apt-repository "deb http://apt.llvm.org/focal/ llvm-toolchain-focal-${{matrix.llvm_version}} main"
            sudo apt-get update
            sudo apt-get install -y -t llvm-toolchain-focal-${{matrix.llvm_version}} libpolly-${{matrix.llvm_version}}-dev \
              clang-${{matrix.llvm_version}} llvm-${{matrix.llvm_version}} llvm-${{matrix.llvm_version}}-dev \
              lld-${{matrix.llvm_version}} liblld-${{matrix.llvm_version}}-dev libmlir-${{matrix.llvm_version}} \
-              libmlir-${{matrix.llvm_version}}-dev mlir-${{matrix.llvm_version}}-tools 
+              libmlir-${{matrix.llvm_version}}-dev mlir-${{matrix.llvm_version}}-tools
          else
-            sudo add-apt-repository "deb http://apt.llvm.org/focal/ llvm-toolchain-focal main"
-            sudo apt-get install -y -t llvm-toolchain-focal libpolly-${{matrix.llvm_version}}-dev \
-              clang-${{matrix.llvm_version}} llvm-${{matrix.llvm_version}} llvm-${{matrix.llvm_version}}-dev \
-              lld-${{matrix.llvm_version}} liblld-${{matrix.llvm_version}}-dev libmlir-${{matrix.llvm_version}} \
-              libmlir-${{matrix.llvm_version}}-dev mlir-${{matrix.llvm_version}}-tools 
+            if [[ "${{matrix.llvm_version}}" < "${{env.LLVM_DEV_VERSION}}" ]]; then
+              sudo add-apt-repository "deb http://apt.llvm.org/focal/ llvm-toolchain-focal-${{matrix.llvm_version}} main"
+              sudo apt-get update
+              sudo apt-get install -y -t llvm-toolchain-focal-${{matrix.llvm_version}} libpolly-${{matrix.llvm_version}}-dev \
+                clang-${{matrix.llvm_version}} llvm-${{matrix.llvm_version}} llvm-${{matrix.llvm_version}}-dev \
+                lld-${{matrix.llvm_version}} liblld-${{matrix.llvm_version}}-dev
+            else
+              sudo add-apt-repository "deb http://apt.llvm.org/focal/ llvm-toolchain-focal main"
+              sudo apt-get install -y -t llvm-toolchain-focal libpolly-${{matrix.llvm_version}}-dev \
+                clang-${{matrix.llvm_version}} llvm-${{matrix.llvm_version}} llvm-${{matrix.llvm_version}}-dev \
+                lld-${{matrix.llvm_version}} liblld-${{matrix.llvm_version}}-dev
+            fi
          fi
      - name: CMake
+        if: matrix.llvm_version < 18 || matrix.llvm_version == env.LLVM_DEV_VERSION
        run: |
          cmake -B build \
                -G Ninja \
@@ -234,6 +262,20 @@ jobs:
                -DCMAKE_DLLTOOL=llvm-dlltool-${{matrix.llvm_version}} \
                -DC3_LLVM_VERSION=${{matrix.llvm_version}}
          cmake --build build
+      - name: CMake18
+        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}} \
+                -DC3_LLVM_VERSION=${{matrix.llvm_version}}.1
+          cmake --build build

      - name: Compile and run some examples
        run: |
@@ -245,9 +287,9 @@ jobs:
          ../build/c3c compile examples/fasta.c3
          ../build/c3c compile examples/gameoflife.c3
          ../build/c3c compile examples/hash.c3
-          ../build/c3c compile examples/levenshtein.c3
+          ../build/c3c compile-only examples/levenshtein.c3
          ../build/c3c compile examples/load_world.c3
-          ../build/c3c compile examples/map.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
@@ -256,8 +298,8 @@ jobs:
          ../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 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
@@ -265,8 +307,9 @@ jobs:
          ../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 --system-linker=no linux_stack.c3
+          ../build/c3c compile-run --linker=builtin linux_stack.c3
          ../build/c3c compile-run linux_stack.c3
+          ../build/c3c compile-run examples/args.c3 -- foo -bar "baz baz"

      - name: Compile run unit tests
        run: |
@@ -278,10 +321,31 @@ jobs:
          cd resources/testproject
          ../../build/c3c run --debug-log

+      - name: Test WASM
+        run: |
+          cd resources/testfragments
+          ../../build/c3c compile --reloc=none --target wasm32 -g0 --link-libc=no --no-entry -Os wasm4.c3
+
+      - name: Install QEMU and Risc-V toolchain
+        run: |
+          sudo apt-get install opensbi qemu-system-misc u-boot-qemu gcc-riscv64-unknown-elf
+
+      - 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: |
          cd resources/testproject
-          ../../build/c3c run --debug-log --system-linker=no
+          ../../build/c3c run --debug-log --linker=builtin
+
+      - name: Init a library & a project
+        run: |
+          ./build/c3c init-lib mylib
+          ls mylib.c3l
+          ./build/c3c init myproject
+          ls myproject

      - name: run compiler tests
        run: |
@@ -289,16 +353,16 @@ jobs:
          python3 src/tester.py ../build/c3c test_suite/

      - name: bundle_output
-        if: matrix.llvm_version == 16
+        if: matrix.llvm_version == env.LLVM_RELEASE_VERSION_LINUX
        run: |
-          mkdir linux
-          cp -r lib linux
-          cp msvc_build_libraries.py linux
-          cp build/c3c linux
-          tar czf c3-linux-${{matrix.build_type}}.tar.gz linux
+          mkdir c3
+          cp -r lib c3
+          cp msvc_build_libraries.py c3
+          cp build/c3c c3
+          tar czf c3-linux-${{matrix.build_type}}.tar.gz c3

      - name: upload artifacts
-        if: matrix.llvm_version == 16
+        if: matrix.llvm_version == env.LLVM_RELEASE_VERSION_LINUX
        uses: actions/upload-artifact@v3
        with:
          name: c3-linux-${{matrix.build_type}}
@@ -311,8 +375,7 @@ jobs:
      fail-fast: false
      matrix:
        build_type: [Release, Debug]
-        llvm_version: [16]
-
+        llvm_version: [17, 18, 19]
    steps:
      - uses: actions/checkout@v4
      - name: Install common deps
@@ -322,16 +385,17 @@ jobs:
      - name: Install Clang ${{matrix.llvm_version}}
        run: |
          wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -
-          if [[ "${{matrix.llvm_version}}" < 17 ]]; then
+          if [[ "${{matrix.llvm_version}}" < "${{env.LLVM_DEV_VERSION}}" ]]; then
            sudo add-apt-repository "deb http://apt.llvm.org/focal/ llvm-toolchain-focal-${{matrix.llvm_version}} main"
          else
            sudo add-apt-repository "deb http://apt.llvm.org/focal/ llvm-toolchain-focal main"
          fi
-          sudo apt-get update      
+          sudo apt-get update
          sudo apt-get install -y clang-${{matrix.llvm_version}} llvm-${{matrix.llvm_version}} llvm-${{matrix.llvm_version}}-dev lld-${{matrix.llvm_version}} liblld-${{matrix.llvm_version}}-dev
-          sudo apt-get install -y libmlir-${{matrix.llvm_version}} libmlir-${{matrix.llvm_version}}-dev mlir-${{matrix.llvm_version}}-tools 
+          sudo apt-get install -y libmlir-${{matrix.llvm_version}} libmlir-${{matrix.llvm_version}}-dev mlir-${{matrix.llvm_version}}-tools
          sudo apt-get install -y libpolly-${{matrix.llvm_version}}-dev
-      - name: CMake
+      - name: CMake Old
+        if: matrix.llvm_version < 18 || matrix.llvm_version == env.LLVM_DEV_VERSION
        run: |
          cmake -B build \
                -G Ninja \
@@ -344,13 +408,26 @@ jobs:
                -DCMAKE_DLLTOOL=llvm-dlltool-${{matrix.llvm_version}} \
                -DC3_LLVM_VERSION=${{matrix.llvm_version}}
          cmake --build build
-
+      - name: CMake
+        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}} \
+                -DC3_LLVM_VERSION=${{matrix.llvm_version}}.1
+          cmake --build build
      - name: Compile and run some examples
        run: |
          cd resources
          ../build/c3c compile examples/gameoflife.c3
-          ../build/c3c compile examples/levenshtein.c3
-          ../build/c3c compile examples/map.c3
+          ../build/c3c compile-only examples/levenshtein.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/spectralnorm.c3
@@ -360,8 +437,8 @@ jobs:
          ../build/c3c compile-run examples/nbodies.c3
          ../build/c3c compile-run examples/contextfree/boolerr.c3
          ../build/c3c compile-run examples/contextfree/dynscope.c3
-          ../build/c3c compile-run examples/contextfree/multi.c3          
-          ../build/c3c compile-run examples/contextfree/cleanup.c3          
+          ../build/c3c compile-run examples/contextfree/multi.c3
+          ../build/c3c compile-run 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
@@ -372,8 +449,9 @@ jobs:
          ../build/c3c compile-run examples/factorial_macro.c3
          ../build/c3c compile-run examples/fasta.c3
          ../build/c3c compile-run examples/process.c3
-          ../build/c3c compile-run --system-linker=no linux_stack.c3
+          ../build/c3c compile-run --linker=builtin linux_stack.c3
          ../build/c3c compile-run linux_stack.c3
+          ../build/c3c compile-run examples/args.c3 -- foo -bar "baz baz"

      - name: Compile run unit tests
        run: |
@@ -388,7 +466,7 @@ jobs:
      - name: Build testproject direct linker
        run: |
          cd resources/testproject
-          ../../build/c3c run --debug-log --system-linker=no
+          ../../build/c3c run --debug-log --linker=builtin

      - name: run compiler tests
        run: |
@@ -396,20 +474,108 @@ jobs:
          python3 src/tester.py ../build/c3c test_suite/

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

      - name: upload artifacts
-        if: matrix.llvm_version == 16
+        if: matrix.llvm_version == env.LLVM_RELEASE_VERSION_UBUNTU20
        uses: actions/upload-artifact@v3
        with:
          name: c3-ubuntu-20-${{matrix.build_type}}
          path: c3-ubuntu-20-${{matrix.build_type}}.tar.gz
+  
+  build-with-docker:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        ubuntu_version: [20.04, 22.04]
+        build_type: [Release, Debug]
+        llvm_version: [17, 18, 19, 20]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Make script executable
+        run: chmod +x ./build-with-docker.sh
+
+      - name: Run build
+        run: |
+          LLVM_VERSION=${{ matrix.llvm_version }} UBUNTU_VERSION=${{ matrix.ubuntu_version }} CMAKE_BUILD_TYPE=${{ matrix.build_type }} ./build-with-docker.sh
+      
+      - name: Compile and run some examples
+        run: |
+          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 --linker=builtin linux_stack.c3
+          ../build/c3c compile-run linux_stack.c3
+          ../build/c3c compile-run examples/args.c3 -- foo -bar "baz baz"
+
+      - name: Compile run unit tests
+        run: |
+          cd test
+          ../build/c3c compile-test unit
+
+      - name: Build testproject
+        run: |
+          cd resources/testproject
+          ../../build/c3c run --debug-log
+
+      - name: Test WASM
+        run: |
+          cd resources/testfragments
+          ../../build/c3c compile --reloc=none --target wasm32 -g0 --link-libc=no --no-entry -Os wasm4.c3
+
+      - name: Build testproject direct linker
+        run: |
+          cd resources/testproject
+          ../../build/c3c run --debug-log --linker=builtin
+
+      - name: Init a library & a project
+        run: |
+          ./build/c3c init-lib mylib
+          ls mylib.c3l
+          ./build/c3c init myproject
+          ls myproject
+
+      - name: run compiler tests
+        run: |
+          cd test
+          python3 src/tester.py ../build/c3c test_suite/

  build-mac:
    runs-on: macos-latest
@@ -418,20 +584,26 @@ jobs:
      fail-fast: false
      matrix:
        build_type: [Release, Debug]
-        llvm_version: [15, 16]
+        llvm_version: [17, 18]
    steps:
      - uses: actions/checkout@v4
      - name: Download LLVM
        run: |
          brew install llvm@${{ matrix.llvm_version }} ninja curl
-          echo "/usr/local/opt/llvm@${{ matrix.llvm_version }}/bin" >> $GITHUB_PATH
+          echo "/opt/homebrew/opt/llvm@${{ matrix.llvm_version }}/bin" >> $GITHUB_PATH
          TMP_PATH=$(xcrun --show-sdk-path)/user/include
          echo "CPATH=$TMP_PATH" >> $GITHUB_ENV

      - name: CMake
+        if: matrix.llvm_version < 18
        run: |
          cmake -B build -G Ninja -DC3_LLVM_VERSION=${{matrix.llvm_version}} -DCMAKE_BUILD_TYPE=${{ matrix.build_type }}
          cmake --build build
+      - name: CMake18
+        if: matrix.llvm_version >= 18
+        run: |
+          cmake -B build -G Ninja -DC3_LLVM_VERSION=${{matrix.llvm_version}}.1 -DCMAKE_BUILD_TYPE=${{ matrix.build_type }}
+          cmake --build build

      - name: Vendor-fetch
        run: |
@@ -446,6 +618,8 @@ jobs:
          ../build/c3c compile-run examples/contextfree/boolerr.c3
          ../build/c3c compile-run examples/process.c3
          ../build/c3c compile-run examples/load_world.c3
+          ../build/c3c compile-run -O5 examples/load_world.c3
+          ../build/c3c compile-run examples/args.c3 -- foo -bar "baz baz"

      - name: Compile run unit tests
        run: |
@@ -460,7 +634,7 @@ jobs:
      - name: Build testproject direct linker
        run: |
          cd resources/testproject
-          ../../build/c3c run --debug-log --system-linker=no
+          ../../build/c3c run --debug-log --linker=builtin

      - name: Build testproject lib
        run: |
@@ -473,7 +647,7 @@ jobs:
          python3 src/tester.py ../build/c3c test_suite/

      - name: bundle_output
-        if: matrix.llvm_version == env.LLVM_RELEASE_VERSION
+        if: matrix.llvm_version == env.LLVM_RELEASE_VERSION_MAC
        run: |
          mkdir macos
          cp -r lib macos
@@ -482,7 +656,7 @@ jobs:
          zip -r c3-macos-${{matrix.build_type}}.zip macos

      - name: upload artifacts
-        if: matrix.llvm_version == env.LLVM_RELEASE_VERSION
+        if: matrix.llvm_version == env.LLVM_RELEASE_VERSION_MAC
        uses: actions/upload-artifact@v3
        with:
          name: c3-macos-${{matrix.build_type}}
@@ -523,8 +697,6 @@ jobs:
      - run: cp -r lib c3-windows-Debug
      - run: cp msvc_build_libraries.py c3-windows-Release
      - run: cp msvc_build_libraries.py c3-windows-Debug
-      - run: cp install_win_reqs.bat c3-windows-Release
-      - run: cp install_win_reqs.bat c3-windows-Debug
      - run: zip -r c3-windows-Release.zip c3-windows-Release
      - run: zip -r c3-windows-Debug.zip c3-windows-Debug

--- a/.gitignore
+++ b/.gitignore
@@ -67,3 +67,6 @@ out/

 /cmake-build-debug/
 /cmake-build-release/
+
+# Emacs files
+TAGS
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.15)
+cmake_minimum_required(VERSION 3.20)

 # Grab the version
 file(READ "src/version.h" ver)
@@ -10,6 +10,11 @@ endif()
 project(c3c VERSION ${CMAKE_MATCH_1})
 message("C3C version: ${CMAKE_PROJECT_VERSION}")

+# Avoid warning for FetchContent
+if (CMAKE_VERSION VERSION_GREATER_EQUAL "3.24.0")
+    cmake_policy(SET CMP0135 NEW)
+endif()
+
 if (NOT DEFINED CMAKE_INSTALL_LIBDIR)
    if (MSVC)
        set(CMAKE_INSTALL_LIBDIR "c:\\c3c\\lib")
@@ -32,6 +37,7 @@ set(CMAKE_C_STANDARD 11)
 set(CMAKE_CXX_STANDARD 17)

 if(MSVC)
+    message(STATUS "MSVC version ${MSVC_VERSION}")
    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /O2 /EHsc")
    set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} /O2 /EHsc")
    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /Od /Zi /EHa")
@@ -75,7 +81,7 @@ if (NOT WIN32)
    find_package(CURL)
 endif()
 if (NOT C3_LLVM_VERSION STREQUAL "auto")
-    if (${C3_LLVM_VERSION} VERSION_LESS 15 OR ${C3_LLVM_VERSION} VERSION_GREATER 18)
+    if (${C3_LLVM_VERSION} VERSION_LESS 17 OR ${C3_LLVM_VERSION} VERSION_GREATER 20)
        message(FATAL_ERROR "LLVM ${C3_LLVM_VERSION} is not supported!")
    endif()
 endif()
@@ -97,25 +103,27 @@ endif()

 if(CMAKE_C_COMPILER_ID STREQUAL "MSVC")
    if (C3_LLVM_VERSION STREQUAL "auto")
-        set(C3_LLVM_VERSION "16")
+        set(C3_LLVM_VERSION "18")
    endif()
    FetchContent_Declare(
            LLVM_Windows
-            URL https://github.com/c3lang/win-llvm/releases/download/llvm_16_0_2/llvm-16.0.2-windows-amd64-msvc17-libcmt.7z
+            URL https://github.com/c3lang/win-llvm/releases/download/llvm_18_1_8_with_rt/llvm-18.1.8-windows-amd64-msvc17-libcmt.7z
    )
    FetchContent_Declare(
            LLVM_Windows_debug
-            URL https://github.com/c3lang/win-llvm/releases/download/llvm_16_0_2/llvm-16.0.2-windows-amd64-msvc17-libcmt-dbg.7z
+            URL https://github.com/c3lang/win-llvm/releases/download/llvm_18_1_8_with_rt/llvm-18.1.8-windows-amd64-msvc17-libcmt-dbg.7z
    )
    if(CMAKE_BUILD_TYPE STREQUAL "Debug")
        message("Loading Windows LLVM debug libraries, this may take a while...")
        FetchContent_MakeAvailable(LLVM_Windows_debug)
-        set(CMAKE_SYSTEM_PREFIX_PATH ${llvm_windows_debug_SOURCE_DIR} ${CMAKE_SYSTEM_PREFIX_PATH})
+        set(llvm_dir ${llvm_windows_debug_SOURCE_DIR})
    else()
        message("Loading Windows LLVM libraries, this may take a while...")
        FetchContent_MakeAvailable(LLVM_Windows)
-        set(CMAKE_SYSTEM_PREFIX_PATH ${llvm_windows_SOURCE_DIR} ${CMAKE_SYSTEM_PREFIX_PATH})
+        set(llvm_dir ${llvm_windows_SOURCE_DIR})
    endif()
+    set(CMAKE_SYSTEM_PREFIX_PATH ${llvm_dir} ${CMAKE_SYSTEM_PREFIX_PATH})
+
    find_package(LLVM REQUIRED CONFIG)
    find_package(LLD REQUIRED CONFIG)
 else()
@@ -130,12 +138,19 @@ message(STATUS "Found LLVM ${LLVM_PACKAGE_VERSION}")
 message(STATUS "Using LLVMConfig.cmake in: ${LLVM_DIR}")
 message(STATUS "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.")
+endif()
+
 if(LLVM_ENABLE_RTTI)
    message(STATUS "LLVM was built with RTTI")
 else()
    message(STATUS "LLVM was not built with RTTI")
 endif()

+string(REPLACE "." ";" VERSION_LIST ${LLVM_PACKAGE_VERSION})
+list(GET VERSION_LIST 0 LLVM_MAJOR_VERSION)
+
 include_directories(${LLVM_INCLUDE_DIRS})
 link_directories(${LLVM_LIBRARY_DIRS})
 add_definitions(${LLVM_DEFINITIONS})
@@ -195,33 +210,35 @@ else()
    find_library(LLD_WASM NAMES liblldWasm.so PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
 endif()

-file(REMOVE_RECURSE ${CMAKE_BINARY_DIR}/lib)
-file(COPY ${CMAKE_SOURCE_DIR}/lib DESTINATION ${CMAKE_BINARY_DIR})
-
-if (${LLVM_PACKAGE_VERSION} VERSION_GREATER_EQUAL 16)
-    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_COMMON}
-        ${LLD_WASM}
-        ${LLD_MINGW}
-        ${LLD_ELF}
-        ${LLD_MACHO}
-        )
-else()
-    set(lld_libs
-        ${LLD_COFF}
-        ${LLD_COMMON}
-        ${LLD_WASM}
-        ${LLD_MINGW}
-        ${LLD_ELF}
-        ${LLD_MACHO}
-        )
+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()

+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_COMMON}
+    ${LLD_WASM}
+    ${LLD_MINGW}
+    ${LLD_ELF}
+    ${LLD_MACHO}
+    )
+
 if (APPLE)
    set(lld_libs ${lld_libs} xar)
-endif ()
+    find_file(RT_ASAN_DYNAMIC NAMES libclang_rt.asan_osx_dynamic.dylib PATHS "${LLVM_LIBRARY_DIRS}/clang/${LLVM_MAJOR_VERSION}/lib/darwin")
+    find_file(RT_TSAN_DYNAMIC NAMES libclang_rt.tsan_osx_dynamic.dylib PATHS "${LLVM_LIBRARY_DIRS}/clang/${LLVM_MAJOR_VERSION}/lib/darwin")
+    find_file(RT_UBSAN_DYNAMIC NAMES libclang_rt.ubsan_osx_dynamic.dylib PATHS "${LLVM_LIBRARY_DIRS}/clang/${LLVM_MAJOR_VERSION}/lib/darwin")
+    find_file(RT_LSAN_DYNAMIC NAMES libclang_rt.lsan_osx_dynamic.dylib PATHS "${LLVM_LIBRARY_DIRS}/clang/${LLVM_MAJOR_VERSION}/lib/darwin")
+    set(sanitizer_runtime_libraries
+            ${RT_ASAN_DYNAMIC}
+            ${RT_TSAN_DYNAMIC}
+            # Unused
+            # ${RT_UBSAN_DYNAMIC}
+            # ${RT_LSAN_DYNAMIC}
+        )
+endif()

 message(STATUS "linking to llvm libs ${lld_libs}")
 message(STATUS "Found lld libs ${lld_libs}")
@@ -234,11 +251,15 @@ add_executable(c3c
        src/build/builder.c
        src/build/build_options.c
        src/build/project_creation.c
+        src/build/project_manipulation.c
+        src/build/libraries.c
        src/compiler/ast.c
        src/compiler/bigint.c
        src/compiler/codegen_general.c
        src/compiler/compiler.c
        src/compiler/compiler.h
+        src/compiler/subprocess.c
+        src/compiler/subprocess.h
        src/compiler/context.c
        src/compiler/copying.c
        src/compiler/diagnostics.c
@@ -246,7 +267,6 @@ add_executable(c3c
        src/compiler/headers.c
        src/compiler/json_output.c
        src/compiler/lexer.c
-        src/compiler/libraries.c
        src/compiler/linker.c
        src/compiler/llvm_codegen.c
        src/compiler/abi/c_abi_aarch64.c
@@ -315,7 +335,8 @@ add_executable(c3c
        src/compiler/expr.c
        src/utils/time.c
        src/utils/http.c
-        src/compiler/sema_liveness.c)
+        src/compiler/sema_liveness.c
+        src/build/common_build.c)


 if (C3_USE_TB)
@@ -356,11 +377,12 @@ endif()


 target_include_directories(c3c PRIVATE
-        "${CMAKE_SOURCE_DIR}/src/")
+        "${CMAKE_SOURCE_DIR}/src/"
+        "${CMAKE_SOURCE_DIR}/wrapper/include/")


 target_include_directories(c3c_wrappers PRIVATE
-        "${CMAKE_SOURCE_DIR}/wrapper/src/")
+        "${CMAKE_SOURCE_DIR}/wrapper/include/")

 target_include_directories(miniz PUBLIC
        "${CMAKE_SOURCE_DIR}/dependencies/miniz/")
@@ -388,6 +410,9 @@ if(MSVC)
    message("Adding MSVC options")
    target_compile_options(c3c PRIVATE /wd4068 /wd4090 /WX /Wv:18)
    target_compile_options(c3c_wrappers PUBLIC /wd4624 /wd4267 /wd4244 /WX /Wv:18)
+    if (NOT LLVM_ENABLE_RTTI)
+        target_compile_options(c3c_wrappers PUBLIC /GR-)
+    endif()
    target_link_options(c3c_wrappers PUBLIC /ignore:4099)
    if(CMAKE_BUILD_TYPE STREQUAL "Debug")
        target_compile_options(c3c PUBLIC /MTd)
@@ -404,16 +429,41 @@ if(MSVC)
            target_compile_options(tilde-backend PUBLIC /MT)
        endif()
    endif()
-
+    set(clang_lib_dir ${llvm_dir}/lib/clang/${C3_LLVM_VERSION}/lib/windows)
+    set(sanitizer_runtime_libraries
+        ${clang_lib_dir}/clang_rt.asan-x86_64.lib
+        ${clang_lib_dir}/clang_rt.asan_dynamic-x86_64.lib
+        ${clang_lib_dir}/clang_rt.asan_dynamic-x86_64.dll
+        ${clang_lib_dir}/clang_rt.asan_dynamic_runtime_thunk-x86_64.lib)
 else()
    message(STATUS "using gcc/clang warning switches")
    target_link_options(c3c PRIVATE -pthread)
+    if (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)
 endif()

-
 install(TARGETS c3c DESTINATION bin)
 install(DIRECTORY lib/ DESTINATION lib/c3)

+if (DEFINED sanitizer_runtime_libraries)
+    add_custom_command(TARGET c3c POST_BUILD
+        COMMAND "${CMAKE_COMMAND}" -E rm -rf -- $<TARGET_FILE_DIR:c3c>/c3c_rt
+        COMMAND "${CMAKE_COMMAND}" -E make_directory $<TARGET_FILE_DIR:c3c>/c3c_rt
+        COMMAND "${CMAKE_COMMAND}" -E copy ${sanitizer_runtime_libraries} $<TARGET_FILE_DIR:c3c>/c3c_rt
+        VERBATIM
+        COMMENT "Copying sanitizer runtime libraries to output directory")
+
+    if (APPLE)
+        # Change LC_ID_DYLIB to be rpath-based instead of having an absolute path
+        add_custom_command(TARGET c3c POST_BUILD
+            COMMAND find $<TARGET_FILE_DIR:c3c>/c3c_rt -type f -name "*.dylib" -execdir ${LLVM_TOOLS_BINARY_DIR}/llvm-install-name-tool -id @rpath/{} {} $<SEMICOLON>
+            VERBATIM)
+    endif()
+
+    install(DIRECTORY $<TARGET_FILE_DIR:c3c>/c3c_rt/ DESTINATION bin/c3c_rt)
+endif()
+
 feature_summary(WHAT ALL)
--- a/README.md
+++ b/README.md
@@ -32,10 +32,10 @@ whole new language.

 ### Example code

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

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

 struct Stack
@@ -122,7 +122,7 @@ fn void main()
 - No mandatory header files
 - New semantic macro system
 - Module based name spacing
- Subarrays (slices)
+- Slices
 - Compile time reflection
 - Enhanced compile time execution
 - Generics based on generic modules
@@ -137,9 +137,9 @@ fn void main()

 ### Current status

-The current stable version of the compiler is **version 0.5**.
+The current stable version of the compiler is **version 0.6.1**.

-The upcoming 0.6 release will focus on expanding the standard library.
+The upcoming 0.6.x releases will focus on expanding the standard library.
 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) 
@@ -212,6 +212,8 @@ More platforms will be supported in the future.
 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 Arch Linux
 There is an AUR package for the c3c compiler : [c3c-git](https://aur.archlinux.org/packages/c3c-git).

@@ -251,7 +253,7 @@ A `c3c` executable will be found under `bin/`.
 #### Installing on OS X using Homebrew

 2. Install CMake: `brew install cmake`
-3. Install LLVM 15: `brew install llvm`
+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`
@@ -306,7 +308,7 @@ You can try it out by running some sample code: `c3c.exe compile ../resources/ex

 1. Make sure you have a C compiler that handles C11 and a C++ compiler, such as GCC or Clang. Git also needs to be installed.
 2. Install CMake: `sudo apt install cmake`
-3. Install LLVM 15 (or greater: C3C supports LLVM 15-17): `sudo apt-get install clang-15 zlib1g zlib1g-dev libllvm15 llvm-15 llvm-15-dev llvm-15-runtime liblld-15-dev liblld-15`
+3. Install LLVM 17+ (or greater: C3C supports LLVM 17+): `sudo apt-get install clang-17 zlib1g zlib1g-dev libllvm17 llvm-17 llvm-17-dev llvm-17-runtime liblld-17-dev liblld-17`
 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`
@@ -319,10 +321,25 @@ You should now have a `c3c` executable.
 You can try it out by running some sample code: `./c3c compile ../resources/examples/hash.c3`


+#### Compiling on Void Linux
+
+1. As root, ensure that all project dependencies are installed: `xbps-install git cmake llvm17 lld17-devel libcurl-devel ncurses-devel zlib-devel libzstd-devel libxml2-devel`
+2. Clone the C3C repository: `git clone https://github.com/c3lang/c3c.git`
+    - If you only need the latest commit, you may want to make a shallow clone instead: `git clone https://github.com/c3lang/c3c.git --depth=1`
+3. Enter the directory: `cd c3c`
+4. Create a build directory: `mkdir build`
+5. Enter the build directory: `cd build`
+6. Create the CMake build cache: `cmake ..`
+7. Build: `cmake --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 .`
+
+
 #### Compiling on other Linux / Unix variants

 1. Install CMake.
-2. Install or compile LLVM and LLD *libraries* (version 15+ or higher)
+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`
--- a/build-with-docker.sh
+++ b/build-with-docker.sh
@@ -1,43 +1,44 @@
 #!/bin/bash
-## build-with-docker.sh
-## @author gdm85
-## @modified by Kenta
-##
-## Script to build c3c for Ubuntu 22
-##
-#

-read -p "Select Build Type: Debug/Release: " config
+: ${DOCKER:=docker}
+: ${IMAGE:="c3c-builder"}
+: ${CMAKE_BUILD_TYPE:=Release}
+: ${LLVM_VERSION:=18}
+: ${UBUNTU_VERSION:="22.04"}
+: ${CMAKE_VERSION:="3.20.0"}

-set -e
+cd docker || exit 1  # Exit if the 'docker' directory doesn't exist

-DOCKER=docker
-DOCKER_RUN=""
-IMAGE="c3c-builder"
-if type podman 2>/dev/null >/dev/null; then
-    DOCKER=podman
-    DOCKER_RUN="--userns=keep-id"
-    IMAGE="localhost/$IMAGE"
+$DOCKER build \
+    --build-arg LLVM_VERSION=$LLVM_VERSION \
+    --build-arg CMAKE_VERSION=$CMAKE_VERSION \
+    --build-arg UBUNTU_VERSION=$UBUNTU_VERSION \
+    -t $IMAGE .
+
+if [ $? -ne 0 ]; then
+    echo "Docker image build failed. Exiting."
+    exit 1
 fi

-if [ $config == "Debug" ]; then
-    CMAKE_BUILD_TYPE=Debug
-else
-    CMAKE_BUILD_TYPE="$config"
-fi
-
-UBUNTU_VERSION="22.10"
-LLVM_VERSION="15"
-
-IMAGE="$IMAGE:22"
-
-cd docker && $DOCKER build -t $IMAGE\
-    --build-arg DEPS="llvm-$LLVM_VERSION-dev liblld-$LLVM_VERSION-dev clang-$LLVM_VERSION libllvm$LLVM_VERSION llvm-$LLVM_VERSION-runtime" \
-    --build-arg UBUNTU_VERSION="$UBUNTU_VERSION" .
 cd ..

 rm -rf build bin
 mkdir -p build bin

-exec $DOCKER run -ti --rm --tmpfs=/tmp $DOCKER_RUN -v "$PWD":/home/c3c/source -w /home/c3c/source $IMAGE bash -c \
-    "cd build && cmake -DCMAKE_BUILD_TYPE=$CMAKE_BUILD_TYPE -DC3_LLVM_VERSION=$LLVM_VERSION .. && cmake --build . && mv c3c lib ../bin/"
+chmod -R 777 build bin
+
+exec $DOCKER run -i --rm \
+    -v "$PWD":/home/c3c/source \
+    -w /home/c3c/source $IMAGE bash -c \
+    "cmake -S . -B build \
+            -G Ninja \
+            -DCMAKE_BUILD_TYPE=$CMAKE_BUILD_TYPE \
+            -DCMAKE_C_COMPILER=clang-$LLVM_VERSION \
+            -DCMAKE_CXX_COMPILER=clang++-$LLVM_VERSION \
+            -DCMAKE_LINKER=lld-$LLVM_VERSION \
+            -DCMAKE_OBJCOPY=llvm-objcopy-$LLVM_VERSION \
+            -DCMAKE_STRIP=llvm-strip-$LLVM_VERSION \
+            -DCMAKE_DLLTOOL=llvm-dlltool-$LLVM_VERSION \
+            -DC3_LLVM_VERSION=auto && \
+    cmake --build build && \
+    cp -r build/c3c build/lib bin"
--- a/docker/Dockerfile
+++ b/docker/Dockerfile
@@ -1,16 +1,49 @@
+ARG UBUNTU_VERSION=22.04
+FROM ubuntu:${UBUNTU_VERSION}

-ARG UBUNTU_VERSION
-FROM ubuntu:$UBUNTU_VERSION
+ARG LLVM_VERSION=18
+ENV LLVM_DEV_VERSION=20

-ARG DEPS
+ARG CMAKE_VERSION=3.20

-RUN export DEBIAN_FRONTEND=noninteractive && export TERM=xterm && apt-get update && apt-get install -y build-essential cmake zlib1g zlib1g-dev  \
-        $DEPS && \
-	rm -rf /var/lib/apt/lists/*
+RUN apt-get update && apt-get install -y wget gnupg software-properties-common zlib1g zlib1g-dev python3 ninja-build curl g++ && \
+    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 && \
+    rm cmake-${CMAKE_VERSION}-linux-x86_64.sh && \
+    ln -s /opt/cmake/bin/cmake /usr/local/bin/cmake

-ARG GID=1000
-ARG UID=1000
+RUN wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | apt-key add - && \
+    if [ "${LLVM_VERSION}" -lt 18 ]; then \
+        add-apt-repository "deb http://apt.llvm.org/focal/ llvm-toolchain-focal-${LLVM_VERSION} main" && \
+        apt-get update && \
+        apt-get install -y -t llvm-toolchain-focal-${LLVM_VERSION} \
+          libpolly-${LLVM_VERSION}-dev \
+          clang-${LLVM_VERSION} llvm-${LLVM_VERSION} llvm-${LLVM_VERSION}-dev \
+          lld-${LLVM_VERSION} liblld-${LLVM_VERSION}-dev libmlir-${LLVM_VERSION} \
+          libmlir-${LLVM_VERSION}-dev mlir-${LLVM_VERSION}-tools; \
+    elif [ "${LLVM_VERSION}" -lt "${LLVM_DEV_VERSION}" ]; then \
+        add-apt-repository "deb http://apt.llvm.org/focal/ llvm-toolchain-focal-${LLVM_VERSION} main" && \
+        apt-get update && \
+        apt-get install -y -t llvm-toolchain-focal-${LLVM_VERSION} \
+          libpolly-${LLVM_VERSION}-dev \
+          clang-${LLVM_VERSION} clang++-${LLVM_VERSION} llvm-${LLVM_VERSION} llvm-${LLVM_VERSION}-dev \
+          lld-${LLVM_VERSION} liblld-${LLVM_VERSION}-dev; \
+    else \
+        add-apt-repository "deb http://apt.llvm.org/focal/ llvm-toolchain-focal main" && \
+        apt-get update && \
+        apt-get install -y -t llvm-toolchain-focal \
+          libpolly-${LLVM_VERSION}-dev \
+          clang-${LLVM_VERSION} llvm-${LLVM_VERSION} llvm-${LLVM_VERSION}-dev \
+          lld-${LLVM_VERSION} liblld-${LLVM_VERSION}-dev; \
+    fi && \
+    rm -rf /var/lib/apt/lists/*

-RUN groupadd -o --gid=$GID c3c && useradd --gid=$GID --uid=$GID --create-home --shell /bin/bash c3c
+RUN groupadd -g 1337 c3c && \
+    useradd -m -u 1337 -g c3c c3c

+# Add cmake to PATH for user c3c
 USER c3c
+ENV PATH="/opt/cmake/bin:${PATH}"
+
+WORKDIR /home/c3c
--- a/install_win_reqs.bat
+++ b/install_win_reqs.bat
@@ -1,17 +0,0 @@
-@echo off
-
-set DOWNLOAD_URL=https://aka.ms/vs/17/release
-
-mkdir tmp 2> NUL
-
-if not exist "tmp\vs_buildtools.exe" (
-    bitsadmin /transfer /download /priority foreground %DOWNLOAD_URL%/vs_buildtools.exe %CD%\tmp\vs_buildtools.exe
-)
-
-echo Preparing Build Tools, please wait...
-tmp\vs_BuildTools.exe --quiet --wait --layout tmp\ --add Microsoft.VisualStudio.Component.Windows10SDK.19041
-
-echo Installing Build Tools, please wait...
-tmp\vs_BuildTools.exe --quiet --wait --noweb --add Microsoft.VisualStudio.Component.Windows10SDK.19041
-
-REM rmdir tmp /s /q
--- a/lib/std/atomic.c3
+++ b/lib/std/atomic.c3
@@ -124,7 +124,7 @@ macro @atomic_exec(#func, data, value, ordering) @local
 		case RELEASE: return #func(data, value, RELEASE);
 		case ACQUIRE_RELEASE: return #func(data, value, ACQUIRE_RELEASE);
 		case SEQ_CONSISTENT: return #func(data, value, SEQ_CONSISTENT);
-		default: assert(false, "Ordering may not be non-atomic or unordered.");
+		default: unreachable("Ordering may not be non-atomic or unordered.");
 	}
 }

--- a/lib/std/atomic_nolibc.c3
+++ b/lib/std/atomic_nolibc.c3
@@ -9,7 +9,7 @@ macro @__atomic_compare_exchange_ordering_failure(ptr, expected, desired, $succe
 		case AtomicOrdering.RELAXED.ordinal: return $$compare_exchange(ptr, expected, desired, false, false, $success, AtomicOrdering.RELAXED.ordinal, $alignment);
 		case AtomicOrdering.ACQUIRE.ordinal: return $$compare_exchange(ptr, expected, desired, false, false, $success, AtomicOrdering.ACQUIRE.ordinal, $alignment);
 		case AtomicOrdering.SEQ_CONSISTENT.ordinal: return $$compare_exchange(ptr, expected, desired, false, false, $success, AtomicOrdering.SEQ_CONSISTENT.ordinal, $alignment);
-		default: assert(false, "Unrecognized failure ordering");
+		default: unreachable("Unrecognized failure ordering");
 	}
 	return 0;
 }
@@ -23,12 +23,12 @@ macro @__atomic_compare_exchange_ordering_success(ptr, expected, desired, succes
 		case AtomicOrdering.RELEASE.ordinal: return @__atomic_compare_exchange_ordering_failure(ptr, expected, desired, AtomicOrdering.RELEASE.ordinal, failure, $alignment);
 		case AtomicOrdering.ACQUIRE_RELEASE.ordinal: return @__atomic_compare_exchange_ordering_failure(ptr, expected, desired, AtomicOrdering.ACQUIRE_RELEASE.ordinal, failure, $alignment);
 		case AtomicOrdering.SEQ_CONSISTENT.ordinal: return @__atomic_compare_exchange_ordering_failure(ptr, expected, desired, AtomicOrdering.SEQ_CONSISTENT.ordinal, failure, $alignment);
-		default: assert(false, "Unrecognized success ordering");
+		default: unreachable("Unrecognized success ordering");
 	}
 	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) @extern("__atomic_compare_exchange") @export
 {
 	switch (size)
 	{
@@ -57,7 +57,7 @@ fn CInt __atomic_compare_exchange(CInt size, any* ptr, any* expected, any* desir
 				nextcase;
 			$endif
 		default:
-			assert(false, "Unsuported size (%d) for atomic_compare_exchange", size);
+			unreachable("Unsuported size (%d) for atomic_compare_exchange", size);
 	}
 	return 0;
 }
--- a/lib/std/collections/anylist.c3
+++ b/lib/std/collections/anylist.c3
@@ -0,0 +1,458 @@
+// Copyright (c) 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::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;
+}
+
+
+/**
+ * @param initial_capacity "The initial capacity to reserve"
+ * @param [&inout] allocator "The allocator to use, defaults to the heap allocator"
+ **/
+fn AnyList* AnyList.new_init(&self, usz initial_capacity = 16, Allocator allocator = allocator::heap())
+{
+	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;
+}
+
+/**
+ * Initialize the list using the temp allocator.
+ *
+ * @param initial_capacity "The initial capacity to reserve"
+ **/
+fn AnyList* AnyList.temp_init(&self, usz initial_capacity = 16)
+{
+	return self.new_init(initial_capacity, allocator::temp()) @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 = allocator::heap()) @dynamic
+{
+	return string::new_format("%s", *self, .allocator = allocator);
+}
+
+fn String AnyList.to_tstring(&self)
+{
+	return 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);
+}
+
+/**
+ * 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.new_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 temp allocator
+ * @return! IteratorResult.NO_MORE_ELEMENT
+ **/
+fn any! AnyList.temp_pop(&self) => self.new_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.
+ **/
+macro AnyList.pop_first(&self, $Type)
+{
+	if (!self.size) return IteratorResult.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];
+}
+
+/**
+ * Same as new_pop() but pops the first value instead.
+ **/
+fn any! AnyList.new_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.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"
+ **/
+macro AnyList.get(&self, usz index, $Type)
+{
+	return *anycast(self.entries[index], $Type);
+}
+
+/**
+ * @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;
+}
+
+/**
+ * @param filter "The function to determine if it should be removed or not"
+ * @return "the number of deleted elements"
+ **/
+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);
+}
--- a/lib/std/collections/bitset.c3
+++ b/lib/std/collections/bitset.c3
@@ -86,15 +86,15 @@ struct GrowableBitSet
 * @param initial_capacity
 * @param [&inout] allocator "The allocator to use, defaults to the heap allocator"
 **/
-fn GrowableBitSet* GrowableBitSet.init_new(&self, usz initial_capacity = 1, Allocator* allocator = mem::heap())
+fn GrowableBitSet* GrowableBitSet.new_init(&self, usz initial_capacity = 1, Allocator allocator = allocator::heap())
 {
-	self.data.init_new(initial_capacity, allocator);
+	self.data.new_init(initial_capacity, allocator);
 	return self;
 }

-fn GrowableBitSet* GrowableBitSet.init_temp(&self, usz initial_capacity = 1)
+fn GrowableBitSet* GrowableBitSet.temp_init(&self, usz initial_capacity = 1)
 {
-	return self.init_new(initial_capacity, mem::temp()) @inline;
+	return self.new_init(initial_capacity, allocator::temp()) @inline;
 }

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

-fn String EnumMap.to_new_string(&self, Allocator* allocator = mem::heap()) @dynamic
+fn String EnumMap.to_new_string(&self, Allocator allocator = allocator::heap()) @dynamic
 {
 	return string::new_format("%s", *self, .allocator = allocator);
 }
--- a/lib/std/collections/enumset.c3
+++ b/lib/std/collections/enumset.c3
@@ -1,4 +1,4 @@
-// Copyright (c) 2021 Christoffer Lerno. All rights reserved.
+// 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.

@@ -6,8 +6,9 @@
 * @require Enum.kindof == TypeKind.ENUM : "Only enums maybe be used with an enumset"
 **/
 module std::collections::enumset(<Enum>);
+import std::io;

-def EnumSetType = $typefrom(private::type_for_enum_elements(Enum.elements)) @private ;
+def EnumSetType = $typefrom(private::type_for_enum_elements(Enum.elements)) @private;

 const IS_CHAR_ARRAY = Enum.elements > 128;
 distinct EnumSet (Printable) = EnumSetType;
@@ -140,7 +141,7 @@ fn usz! EnumSet.to_format(&set, Formatter* formatter) @dynamic
 	return n;
 }

-fn String EnumSet.to_new_string(&set, Allocator* allocator = mem::heap()) @dynamic
+fn String EnumSet.to_new_string(&set, Allocator allocator = allocator::heap()) @dynamic
 {
 	return string::new_format("%s", *set, .allocator = allocator);
 }
--- a/lib/std/collections/hashmap.c3
+++ b/lib/std/collections/hashmap.c3
@@ -0,0 +1,400 @@
+// 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;
+
+struct HashMap
+{
+	Entry*[] table;
+	Allocator allocator;
+	uint count; // Number of elements
+	uint threshold; // Resize limit
+	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 = allocator::heap())
+{
+	capacity = math::next_power_of_2(capacity);
+	self.allocator = allocator;
+	self.load_factor = load_factor;
+	self.threshold = (uint)(capacity * load_factor);
+	self.table = allocator::new_array(allocator, Entry*, capacity);
+	return self;
+}
+
+/**
+ * @require capacity > 0 "The capacity must be 1 or higher"
+ * @require load_factor > 0.0 "The load factor must be higher than 0"
+ * @require !self.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)
+{
+	return self.new_init(capacity, load_factor, allocator::temp()) @inline;
+}
+
+
+/**
+ * Has this hash map been initialized yet?
+ *
+ * @param [&in] map "The hash map we are testing"
+ * @return "Returns true if it has been initialized, false otherwise"
+ **/
+fn bool HashMap.is_initialized(&map)
+{
+	return (bool)map.allocator;
+}
+
+/**
+ * @param [&inout] allocator "The allocator to use"
+ * @param [&in] other_map "The map to copy from."
+ **/
+fn HashMap* HashMap.new_init_from_map(&self, HashMap* other_map, Allocator allocator = allocator::heap())
+{
+	self.new_init(other_map.table.len, other_map.load_factor, allocator);
+	self.put_all_for_create(other_map);
+	return self;
+}
+
+/**
+ * @param [&in] other_map "The map to copy from."
+ **/
+fn HashMap* HashMap.temp_init_from_map(&map, HashMap* other_map)
+{
+	return map.new_init_from_map(other_map, allocator::temp()) @inline;
+}
+
+fn bool HashMap.is_empty(&map) @inline
+{
+	return !map.count;
+}
+
+fn usz HashMap.len(&map) @inline
+{
+	return map.count;
+}
+
+fn Value*! HashMap.get_ref(&map, Key key)
+{
+	if (!map.count) return 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*! HashMap.get_entry(&map, Key key)
+{
+	if (!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;
+	}
+	return SearchResult.MISSING?;
+}
+
+/**
+ * Get the value or update and
+ * @require $assignable(#expr, Value)
+ **/
+macro Value HashMap.@get_or_set(&map, Key key, Value #expr)
+{
+	if (!map.count)
+	{
+		Value val = #expr;
+		map.set(key, val);
+		return val;
+	}
+	uint hash = rehash(key.hash());
+	uint index = index_for(hash, map.table.len);
+	for (Entry *e = map.table[index]; e != null; e = e.next)
+	{
+		if (e.hash == hash && equals(key, e.key)) return e.value;
+	}
+	Value val = #expr;
+	map.add_entry(hash, key, val, index);
+	return val;
+}
+
+fn Value! HashMap.get(&map, Key key) @operator([])
+{
+	return *map.get_ref(key) @inline;
+}
+
+fn bool HashMap.has_key(&map, Key key)
+{
+	return @ok(map.get_ref(key));
+}
+
+fn bool HashMap.set(&map, Key key, Value value) @operator([]=)
+{
+	// If the map isn't initialized, use the defaults to initialize it.
+	if (!map.allocator)
+	{
+		map.new_init();
+	}
+	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! HashMap.remove(&map, Key key) @maydiscard
+{
+	if (!map.remove_entry_for_key(key)) return SearchResult.MISSING?;
+}
+
+fn void HashMap.clear(&map)
+{
+	if (!map.count) return;
+	foreach (Entry** &entry_ref : map.table)
+	{
+		Entry* entry = *entry_ref;
+		if (!entry) continue;
+		Entry *next = entry.next;
+		while (next)
+		{
+			Entry *to_delete = next;
+			next = next.next;
+			map.free_entry(to_delete);
+		}
+		map.free_entry(entry);
+		*entry_ref = null;
+	}
+	map.count = 0;
+}
+
+fn void HashMap.free(&map)
+{
+	if (!map.allocator) return;
+	map.clear();
+	map.free_internal(map.table.ptr);
+	map.table = {};
+}
+
+fn Key[] HashMap.key_tlist(&map)
+{
+	return map.key_new_list(allocator::temp()) @inline;
+}
+
+fn Key[] HashMap.key_new_list(&map, Allocator allocator = allocator::heap())
+{
+	if (!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 HashMap.@each(map; @body(key, value))
+{
+	map.@each_entry(; Entry* entry) {
+		@body(entry.key, entry.value);
+	};
+}
+
+macro HashMap.@each_entry(map; @body(entry))
+{
+	if (map.count)
+	{
+		foreach (Entry* entry : map.table)
+		{
+			while (entry)
+			{
+				@body(entry);
+				entry = entry.next;
+			}
+		}
+	}
+}
+
+fn Value[] HashMap.value_tlist(&map)
+{
+	return map.value_new_list(allocator::temp()) @inline;
+}
+
+fn Value[] HashMap.value_new_list(&map, Allocator allocator = allocator::heap())
+{
+	if (!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 HashMap.has_value(&map, Value v) @if(VALUE_IS_EQUATABLE)
+{
+	if (!map.count) return false;
+	foreach (Entry* entry : map.table)
+	{
+		while (entry)
+		{
+			if (equals(v, entry.value)) return true;
+			entry = entry.next;
+		}
+	}
+	return false;
+}
+
+// --- private methods
+
+fn void HashMap.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 HashMap.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 void HashMap.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 HashMap.put_all_for_create(&map, HashMap* other_map) @private
+{
+	if (!other_map.count) return;
+	foreach (Entry *e : other_map.table)
+	{
+		if (!e) continue;
+		map.put_for_create(e.key, e.value);
+	}
+}
+
+fn void HashMap.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 HashMap.free_internal(&map, void* ptr) @inline @private
+{
+	allocator::free(map.allocator, ptr);
+}
+
+fn bool HashMap.remove_entry_for_key(&map, Key key) @private
+{
+	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 HashMap.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 HashMap.free_entry(&self, Entry *entry) @local
+{
+	$if COPY_KEYS:
+	allocator::free(self.allocator, entry.key);
+	$endif
+	self.free_internal(entry);
+}
+
--- a/lib/std/collections/linkedlist.c3
+++ b/lib/std/collections/linkedlist.c3
@@ -1,8 +1,10 @@
-// Copyright (c) 2021 Christoffer Lerno. All rights reserved.
+// 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>);

+const ELEMENT_IS_EQUATABLE = types::is_equatable_type(Type);
+
 struct Node @private
 {
 	Node *next;
@@ -12,35 +14,26 @@ struct Node @private

 struct LinkedList
 {
-	Allocator *allocator;
+	Allocator allocator;
 	usz size;
 	Node *_first;
 	Node *_last;
 }

-fn void LinkedList.push(&self, Type value)
-{
-	self.link_first(value);
-}
-
-fn void LinkedList.push_last(&self, Type value)
-{
-	self.link_last(value);
-}
-
 /**
 * @param [&inout] allocator "The allocator to use, defaults to the heap allocator"
 * @return "the initialized list"
 **/
-fn LinkedList* LinkedList.init_new(&self, Allocator* allocator = mem::heap())
+fn LinkedList* LinkedList.new_init(&self, Allocator allocator = allocator::heap())
 {
 	*self = { .allocator = allocator };
 	return self;
 }

-fn LinkedList* LinkedList.init_temp(&self)
+
+fn LinkedList* LinkedList.temp_init(&self)
 {
-	return self.init_new(mem::temp()) @inline;
+	return self.new_init(allocator::temp()) @inline;
 }

 /**
@@ -48,15 +41,16 @@ fn LinkedList* LinkedList.init_temp(&self)
 **/
 macro void LinkedList.free_node(&self, Node* node) @private
 {
-	self.allocator.free(node);
-}
-macro Node* LinkedList.alloc_node(&self) @private
-{
-	if (!self.allocator) self.allocator = mem::heap();
-	return self.allocator.new(Node);
+	allocator::free(self.allocator, node);
 }

-fn void LinkedList.link_first(&self, Type value) @private
+macro Node* LinkedList.alloc_node(&self) @private
+{
+	if (!self.allocator) self.allocator = allocator::heap();
+	return allocator::alloc(self.allocator, Node);
+}
+
+fn void LinkedList.push_front(&self, Type value)
 {
 	Node *first = self._first;
 	Node *new_node = self.alloc_node();
@@ -73,7 +67,7 @@ fn void LinkedList.link_first(&self, Type value) @private
 	self.size++;
 }

-fn void LinkedList.link_last(&self, Type value) @private
+fn void LinkedList.push(&self, Type value)
 {
 	Node *last = self._last;
 	Node *new_node = self.alloc_node();
@@ -157,7 +151,7 @@ fn void LinkedList.set(&self, usz index, Type element)
 /**
 * @require index < self.size
 **/
-fn void LinkedList.remove(&self, usz index)
+fn void LinkedList.remove_at(&self, usz index)
 {
 	self.unlink(self.node_at_index(index));
 }
@@ -165,14 +159,14 @@ fn void LinkedList.remove(&self, usz index)
 /**
 * @require index <= self.size
 **/
-fn void LinkedList.insert(&self, usz index, Type element)
+fn void LinkedList.insert_at(&self, usz index, Type element)
 {
 	switch (index)
 	{
 		case 0:
-			self.push(element);
+			self.push_front(element);
 		case self.size:
-			self.push_last(element);
+			self.push(element);
 		default:
 			self.link_before(self.node_at_index(index), element);
 	}
@@ -217,7 +211,53 @@ fn void LinkedList.unlink_first(&self) @private
 	self.size--;
 }

-fn bool LinkedList.remove_value(&self, Type t)
+fn usz LinkedList.remove(&self, Type t) @if(ELEMENT_IS_EQUATABLE)
+{
+	usz start = self.size;
+	Node* node = self._first;
+	while (node)
+	{
+		switch
+		{
+			case equals(node.value, t):
+				Node* next = node.next;
+				self.unlink(node);
+				node = next;
+			default:
+				node = node.next;
+		}
+	}
+	return start - self.size;
+}
+
+fn Type! LinkedList.pop(&self)
+{
+	if (!self._last) return IteratorResult.NO_MORE_ELEMENT?;
+	defer self.unlink_last();
+	return self._last.value;
+}
+
+fn Type! LinkedList.pop_front(&self)
+{
+	if (!self._first) return IteratorResult.NO_MORE_ELEMENT?;
+	defer self.unlink_first();
+	return self._first.value;
+}
+
+fn void! LinkedList.remove_last(&self) @maydiscard
+{
+	if (!self._first) return IteratorResult.NO_MORE_ELEMENT?;
+	self.unlink_last();
+}
+
+fn void! LinkedList.remove_first(&self) @maydiscard
+{
+	if (!self._first) return IteratorResult.NO_MORE_ELEMENT?;
+	self.unlink_first();
+}
+
+
+fn bool LinkedList.remove_first_match(&self, Type t) @if(ELEMENT_IS_EQUATABLE)
 {
 	for (Node* node = self._first; node != null; node = node.next)
 	{
@@ -230,7 +270,7 @@ fn bool LinkedList.remove_value(&self, Type t)
 	return false;
 }

-fn bool LinkedList.remove_last_value(&self, Type t)
+fn bool LinkedList.remove_last_match(&self, Type t)  @if(ELEMENT_IS_EQUATABLE)
 {
 	for (Node* node = self._last; node != null; node = node.prev)
 	{
@@ -242,26 +282,6 @@ fn bool LinkedList.remove_last_value(&self, Type t)
 	}
 	return false;
 }
-
-fn Type! LinkedList.pop(&self)
-{
-	if (!self._first) return IteratorResult.NO_MORE_ELEMENT?;
-	defer self.unlink_first();
-	return self._first.value;
-}
-
-fn void! LinkedList.remove_last(&self)
-{
-	if (!self._first) return IteratorResult.NO_MORE_ELEMENT?;
-	self.unlink_last();
-}
-
-fn void! LinkedList.remove_first(&self)
-{
-	if (!self._first) return IteratorResult.NO_MORE_ELEMENT?;
-	self.unlink_first();
-}
-
 /**
 * @require self._last
 **/
--- a/lib/std/collections/list.c3
+++ b/lib/std/collections/list.c3
@@ -1,20 +1,21 @@
-// Copyright (c) 2021 Christoffer Lerno. All rights reserved.
+// Copyright (c) 2021-2024 Christoffer Lerno. All rights reserved.
 // Use of self source code is governed by the MIT license
 // a copy of which can be found in the LICENSE_STDLIB file.
 module std::collections::list(<Type>);
-import std::io;
-import std::math;
+import std::io, std::math, std::collections::list_common;

 def ElementPredicate = fn bool(Type *type);
-def ElementTest = fn bool(Type *type, any* context);
+def 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;
+
 struct List (Printable)
 {
 	usz size;
 	usz capacity;
-	Allocator *allocator;
+	Allocator allocator;
 	Type *entries;
 }

@@ -22,20 +23,13 @@ struct List (Printable)
 * @param initial_capacity "The initial capacity to reserve"
 * @param [&inout] allocator "The allocator to use, defaults to the heap allocator"
 **/
-fn List* List.init_new(&self, usz initial_capacity = 16, Allocator* allocator = mem::heap())
+fn List* List.new_init(&self, usz initial_capacity = 16, Allocator allocator = allocator::heap())
 {
 	self.allocator = allocator;
 	self.size = 0;
-	if (initial_capacity > 0)
-	{
-		initial_capacity = math::next_power_of_2(initial_capacity);
-		self.entries = allocator.alloc_aligned(Type.sizeof * initial_capacity, .alignment = Type[1].alignof)!!;
-	}
-	else
-	{
-		self.entries = null;
-	}
-	self.capacity = initial_capacity;
+	self.capacity = 0;
+	self.entries = null;
+	self.reserve(initial_capacity);
 	return self;
 }

@@ -44,20 +38,46 @@ fn List* List.init_new(&self, usz initial_capacity = 16, Allocator* allocator =
 *
 * @param initial_capacity "The initial capacity to reserve"
 **/
-fn List* List.init_temp(&self, usz initial_capacity = 16)
+fn List* List.temp_init(&self, usz initial_capacity = 16)
 {
-	return self.init_new(initial_capacity, mem::temp()) @inline;
+	return self.new_init(initial_capacity, allocator::temp()) @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 void List.init_wrapping_array(&self, Type[] types, Allocator* allocator = mem::heap())
+fn List* List.new_init_with_array(&self, Type[] values, Allocator allocator = allocator::heap())
+{
+	self.new_init(values.len, allocator) @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"
+ **/
+fn List* List.temp_init_with_array(&self, Type[] values)
+{
+	self.temp_init(values.len) @inline;
+	self.add_array(values) @inline;
+	return self;
+}
+
+/**
+ * @require self.capacity == 0 "The List must not be allocated"
+ **/
+fn void List.init_wrapping_array(&self, Type[] types, Allocator allocator = allocator::heap())
 {
 	self.allocator = allocator;
-	self.size = types.len;
 	self.capacity = types.len;
 	self.entries = types.ptr;
+	self.set_size(types.len);
 }

 fn usz! List.to_format(&self, Formatter* formatter) @dynamic
@@ -80,7 +100,7 @@ fn usz! List.to_format(&self, Formatter* formatter) @dynamic
 	}
 }

-fn String List.to_new_string(&self, Allocator* allocator = mem::heap()) @dynamic
+fn String List.to_new_string(&self, Allocator allocator = allocator::heap()) @dynamic
 {
 	return string::new_format("%s", *self, .allocator = allocator);
 }
@@ -92,36 +112,30 @@ fn String List.to_tstring(&self)

 fn void List.push(&self, Type element) @inline
 {
-	self.append(element);
+	self.reserve(1);
+	self.entries[self.set_size(self.size + 1)] = element;
 }

-fn void List.append(&self, Type element)
+fn Type! List.pop(&self)
 {
-	self.ensure_capacity();
-	self.entries[self.size++] = element;
-}
-
-/**
- * @require self.size > 0
- **/
-fn Type List.pop(&self)
-{
-	return self.entries[--self.size];
+	if (!self.size) return IteratorResult.NO_MORE_ELEMENT?;
+	defer self.set_size(self.size - 1);
+	return self.entries[self.size - 1];
 }

 fn void List.clear(&self)
 {
-	self.size = 0;
+	self.set_size(0);
 }

 /**
 * @require self.size > 0
 **/
-fn Type List.pop_first(&self)
+fn Type! List.pop_first(&self)
 {
-	Type value = self.entries[0];
-	self.remove_at(0);
-	return value;
+	if (!self.size) return IteratorResult.NO_MORE_ELEMENT?;
+	defer self.remove_at(0);
+	return self.entries[0];
 }

 /**
@@ -129,35 +143,46 @@ fn Type List.pop_first(&self)
 **/
 fn void List.remove_at(&self, usz index)
 {
-	for (usz i = index + 1; i < self.size; i++)
-	{
-		self.entries[i - 1] = self.entries[i];
-	}
-	self.size--;
+	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];
 }

 fn void List.add_all(&self, List* other_list)
 {
 	if (!other_list.size) return;
 	self.reserve(other_list.size);
+	usz index = self.set_size(self.size + other_list.size);
 	foreach (&value : other_list)
 	{
-		self.entries[self.size++] = *value;
+		self.entries[index++] = *value;
 	}
 }


-fn Type[] List.to_new_array(&self, Allocator* allocator = mem::heap())
+/**
+ * IMPORTANT The returned array must be freed using free_aligned.
+ **/
+fn Type[] List.to_new_aligned_array(&self, Allocator allocator = allocator::heap())
 {
-	if (!self.size) return Type[] {};
-	Type[] result = allocator.new_array(Type, self.size);
-	result[..] = self.entries[:self.size];
-	return result;
+	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[] List.to_new_array(&self, Allocator allocator = allocator::heap())
+{
+	return list_common::list_to_new_array(Type, self, allocator);
 }

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

 /**
@@ -165,13 +190,7 @@ fn Type[] List.to_tarray(&self)
 **/
 fn void List.reverse(&self)
 {
-	if (self.size < 2) return;
-	usz half = self.size / 2U;
-	usz end = self.size - 1;
-	for (usz i = 0; i < half; i++)
-	{
-		@swap(self.entries[i], self.entries[end - i]);
-	}
+	list_common::list_reverse(self);
 }

 fn Type[] List.array_view(&self)
@@ -179,14 +198,18 @@ fn Type[] List.array_view(&self)
 	return self.entries[:self.size];
 }

+/**
+ * Add the values of an array to this list.
+ *
+ * @param [in] array
+ * @ensure self.size >= array.len
+ **/
 fn void List.add_array(&self, Type[] array)
 {
 	if (!array.len) return;
 	self.reserve(array.len);
-	foreach (&value : array)
-	{
-		self.entries[self.size++] = *value;
-	}
+	usz index = self.set_size(self.size + array.len);
+	self.entries[index : array.len] = array[..];
 }

 fn void List.push_front(&self, Type type) @inline
@@ -195,16 +218,16 @@ fn void List.push_front(&self, Type type) @inline
 }

 /**
- * @require index < self.size
+ * @require index <= self.size
 **/
 fn void List.insert_at(&self, usz index, Type type)
 {
-	self.ensure_capacity();
+	self.reserve(1);
 	for (usz i = self.size; i > index; i--)
 	{
 		self.entries[i] = self.entries[i - 1];
 	}
-	self.size++;
+	self.set_size(self.size + 1);
 	self.entries[index] = type;
 }

@@ -216,30 +239,28 @@ fn void List.set_at(&self, usz index, Type type)
 	self.entries[index] = type;
 }

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

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

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

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

 fn bool List.is_empty(&self) @inline
@@ -247,6 +268,11 @@ fn bool List.is_empty(&self) @inline
 	return !self.size;
 }

+fn usz List.byte_size(&self) @inline
+{
+	return Type.sizeof * self.size;
+}
+
 fn usz List.len(&self) @operator(len) @inline
 {
 	return self.size;
@@ -259,8 +285,15 @@ fn Type List.get(&self, usz index) @inline

 fn void List.free(&self)
 {
-	if (!self.allocator) return;
-	self.allocator.free_aligned(self.entries);
+	if (!self.allocator || !self.capacity) return;
+
+	self.pre_free(); // Remove sanitizer annotation
+
+	$if type_is_overaligned():
+		allocator::free_aligned(self.allocator, self.entries);
+	$else
+		allocator::free(self.allocator, self.entries);
+	$endif;
 	self.capacity = 0;
 	self.size = 0;
 	self.entries = null;
@@ -277,7 +310,7 @@ fn void List.swap(&self, usz i, usz j)
 **/
 fn usz List.remove_if(&self, ElementPredicate filter)
 {
-	return self._remove_if(filter, false);
+	return list_common::list_remove_if(self, filter, false);
 }

 /**
@@ -286,80 +319,46 @@ fn usz List.remove_if(&self, ElementPredicate filter)
 **/
 fn usz List.retain_if(&self, ElementPredicate selection)
 {
-	return self._remove_if(selection, true);
+	return list_common::list_remove_if(self, selection, true);
 }

-macro usz List._remove_if(&self, ElementPredicate filter, bool $invert) @local
+fn usz List.remove_using_test(&self, ElementTest filter, any context)
 {
-	usz size = self.size;
-	for (usz i = size, usz k = size; k > 0; k = i)
-	{
-		// Find last index of item to be deleted.
-		$if $invert:
-			while (i > 0 && !filter(&self.entries[i - 1])) i--;
-		$else
-			while (i > 0 && filter(&self.entries[i - 1])) i--;
-		$endif
-		// Remove the items from this index up to the one not to be deleted.
-		usz n = self.size - k;
-		self.entries[i:n] = self.entries[k:n];
-		self.size -= k - i;
-		// Find last index of item not to be deleted.
-		$if $invert:
-			while (i > 0 && filter(&self.entries[i - 1])) i--;
-		$else
-			while (i > 0 && !filter(&self.entries[i - 1])) i--;
-		$endif
+	usz old_size = self.size;
+	defer {
+		if (old_size != self.size) self._update_size_change(old_size, self.size);
 	}
-	return size - self.size;
+	return list_common::list_remove_using_test(self, filter, false, context);
 }

-fn usz List.remove_using_test(&self, ElementTest filter, any* context)
-{
-	return self._remove_using_test(filter, false, context);
-}

-fn usz List.retain_using_test(&self, ElementTest filter, any* context)
-{
-	return self._remove_using_test(filter, true, context);
-}

-macro usz List._remove_using_test(&self, ElementTest filter, bool $invert, ctx) @local
+fn usz List.retain_using_test(&self, ElementTest filter, any context)
 {
-	usz size = self.size;
-	for (usz i = size, usz k = size; k > 0; k = i)
-	{
-		// Find last index of item to be deleted.
-		$if $invert:
-			while (i > 0 && !filter(&self.entries[i - 1], ctx)) i--;
-		$else
-			while (i > 0 && filter(&self.entries[i - 1], ctx)) i--;
-		$endif
-		// Remove the items from this index up to the one not to be deleted.
-		usz n = self.size - k;
-		self.entries[i:n] = self.entries[k:n];
-		self.size -= k - i;
-		// Find last index of item not to be deleted.
-		$if $invert:
-			while (i > 0 && filter(&self.entries[i - 1], ctx)) i--;
-		$else
-			while (i > 0 && !filter(&self.entries[i - 1], ctx)) i--;
-		$endif
+	usz old_size = self.size;
+	defer {
+		if (old_size != self.size) self._update_size_change(old_size, self.size);
 	}
-	return size - self.size;
+	return list_common::list_remove_using_test(self, filter, true, context);
 }

-/**
- * Reserve at least min_capacity
- **/
-fn void List.reserve(&self, usz min_capacity)
+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 = mem::heap();
+	if (!self.allocator) self.allocator = allocator::heap();
+
+	self.pre_free(); // Remove sanitizer annotation
+
 	min_capacity = math::next_power_of_2(min_capacity);
-	self.entries = self.allocator.realloc_aligned(self.entries, Type.sizeof * min_capacity, .alignment = Type[1].alignof) ?? null;
+	$if type_is_overaligned():
+		self.entries = allocator::realloc_aligned(self.allocator, self.entries, Type.sizeof * min_capacity, .alignment = Type[1].alignof)!!;
+	$else
+		self.entries = allocator::realloc(self.allocator, self.entries, Type.sizeof * min_capacity);
+	$endif;
 	self.capacity = min_capacity;
+
+	self.post_alloc(); // Add sanitizer annotation
 }

 macro Type List.@item_at(&self, usz index) @operator([])
@@ -377,7 +376,7 @@ fn void List.set(&self, usz index, Type value) @operator([]=)
 	self.entries[index] = value;
 }

-fn void List.ensure_capacity(&self, usz added = 1) @inline @private
+fn void List.reserve(&self, usz added)
 {
 	usz new_size = self.size + added;
 	if (self.capacity >= new_size) return;
@@ -385,7 +384,40 @@ fn void List.ensure_capacity(&self, usz added = 1) @inline @private
 	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);
+	self.ensure_capacity(new_capacity);
+}
+
+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,
+	                                         &self.entries[self.capacity],
+	                                         &self.entries[old_size],
+	                                         &self.entries[new_size]);
+}
+/**
+ * @require new_size == 0 || self.capacity != 0
+ **/
+fn usz List.set_size(&self, usz new_size) @inline @private
+{
+	usz old_size = self.size;
+	self._update_size_change(old_size, new_size);
+	self.size = new_size;
+	return old_size;
+}
+
+macro void List.pre_free(&self) @private
+{
+	if (!self.capacity) return;
+	self._update_size_change(self.size, self.capacity);
+}
+
+/**
+ * @require self.capacity
+ **/
+macro void List.post_alloc(&self) @private
+{
+	self._update_size_change(self.capacity, self.size);
 }

 // Functions for equatable types
@@ -435,31 +467,49 @@ fn bool List.contains(&self, Type value) @if(ELEMENT_IS_EQUATABLE)
 	return false;
 }

+/**
+ * @param [&inout] self "The list to remove elements from"
+ * @param value "The value to remove"
+ * @return "true if the value was found"
+ **/
+fn bool List.remove_last_item(&self, Type value) @if(ELEMENT_IS_EQUATABLE)
+{
+	return @ok(self.remove_at(self.rindex_of(value)));
+}

+/**
+ * @param [&inout] self "The list to remove elements from"
+ * @param value "The value to remove"
+ * @return "true if the value was found"
+ **/
+fn bool List.remove_first_item(&self, Type value) @if(ELEMENT_IS_EQUATABLE)
+{
+	return @ok(self.remove_at(self.index_of(value)));
+}
 /**
 * @param [&inout] self "The list to remove elements from"
 * @param value "The value to remove"
 * @return "the number of deleted elements."
 **/
-fn usz List.remove(&self, Type value) @if(ELEMENT_IS_EQUATABLE)
+fn usz List.remove_item(&self, Type value) @if(ELEMENT_IS_EQUATABLE)
 {
-	usz size = self.size;
-	for (usz i = size; i > 0; i--)
-	{
-		if (!equals(self.entries[i - 1], value)) continue;
-		for (usz j = i; j < size; j++)
-		{
-			self.entries[j - 1] = self.entries[j];
-		}
-		self.size--;
+	usz old_size = self.size;
+	defer {
+		if (old_size != self.size) self._update_size_change(old_size, self.size);
 	}
-	return size - self.size;
+	return list_common::list_remove_item(self, value);
 }

-fn void List.remove_all(&self, List* other_list) @if(ELEMENT_IS_EQUATABLE)
+
+
+fn void List.remove_all_from(&self, List* other_list) @if(ELEMENT_IS_EQUATABLE)
 {
 	if (!other_list.size) return;
-	foreach (v : other_list) self.remove(v);
+	usz old_size = self.size;
+	defer {
+		if (old_size != self.size) self._update_size_change(old_size, self.size);
+	}
+	foreach (v : other_list) self.remove_item(v);
 }

 /**
@@ -475,15 +525,42 @@ fn usz List.compact_count(&self) @if(ELEMENT_IS_POINTER)

 fn usz List.compact(&self) @if(ELEMENT_IS_POINTER)
 {
-	usz size = self.size;
-	for (usz i = size; i > 0; i--)
-	{
-		if (self.entries[i - 1]) continue;
-		for (usz j = i; j < size; j++)
-		{
-			self.entries[j - 1] = self.entries[j];
-		}
-		self.size--;
+	usz old_size = self.size;
+	defer {
+		if (old_size != self.size) self._update_size_change(old_size, self.size);
 	}
-	return size - self.size;
+	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;
 }
--- a/lib/std/collections/list_common.c3
+++ b/lib/std/collections/list_common.c3
@@ -0,0 +1,112 @@
+module std::collections::list_common;
+
+/**
+ * IMPORTANT The returned array must be freed using free_aligned.
+ **/
+macro list_to_new_aligned_array($Type, self, Allocator allocator)
+{
+	if (!self.size) return $Type[] {};
+	$Type[] result = allocator::alloc_array_aligned(allocator, $Type, self.size);
+	result[..] = self.entries[:self.size];
+	return result;
+}
+
+macro list_to_new_array($Type, self, Allocator allocator)
+{
+	if (!self.size) return $Type[] {};
+	$Type[] result = allocator::alloc_array(allocator, $Type, self.size);
+	result[..] = self.entries[:self.size];
+	return result;
+}
+
+macro void list_reverse(self)
+{
+	if (self.size < 2) return;
+	usz half = self.size / 2U;
+	usz end = self.size - 1;
+	for (usz i = 0; i < half; i++)
+	{
+		@swap(self.entries[i], self.entries[end - i]);
+	}
+}
+
+macro usz list_remove_using_test(self, filter, bool $invert, ctx)
+{
+	usz size = self.size;
+	for (usz i = size, usz k = size; k > 0; k = i)
+	{
+		// Find last index of item to be deleted.
+		$if $invert:
+			while (i > 0 && !filter(&self.entries[i - 1], ctx)) i--;
+		$else
+			while (i > 0 && filter(&self.entries[i - 1], ctx)) i--;
+		$endif
+		// Remove the items from this index up to the one not to be deleted.
+		usz n = self.size - k;
+		self.entries[i:n] = self.entries[k:n];
+		self.size -= k - i;
+		// Find last index of item not to be deleted.
+		$if $invert:
+			while (i > 0 && filter(&self.entries[i - 1], ctx)) i--;
+		$else
+			while (i > 0 && !filter(&self.entries[i - 1], ctx)) i--;
+		$endif
+	}
+	return size - self.size;
+}
+
+macro usz list_compact(self)
+{
+	usz size = self.size;
+	for (usz i = size; i > 0; i--)
+	{
+		if (self.entries[i - 1]) continue;
+		for (usz j = i; j < size; j++)
+		{
+			self.entries[j - 1] = self.entries[j];
+		}
+		self.size--;
+	}
+	return size - self.size;
+}
+
+macro usz list_remove_item(self, value)
+{
+	usz size = self.size;
+	for (usz i = size; i > 0; i--)
+	{
+		if (!equals(self.entries[i - 1], value)) continue;
+		for (usz j = i; j < self.size; j++)
+		{
+			self.entries[j - 1] = self.entries[j];
+		}
+		self.size--;
+	}
+	return size - self.size;
+}
+
+
+macro usz list_remove_if(self, filter, bool $invert)
+{
+	usz size = self.size;
+	for (usz i = size, usz k = size; k > 0; k = i)
+	{
+		// Find last index of item to be deleted.
+		$if $invert:
+			while (i > 0 && !filter(&self.entries[i - 1])) i--;
+		$else
+			while (i > 0 && filter(&self.entries[i - 1])) i--;
+		$endif
+		// Remove the items from this index up to the one not to be deleted.
+		usz n = self.size - k;
+		self.entries[i:n] = self.entries[k:n];
+		self.size -= k - i;
+		// Find last index of item not to be deleted.
+		$if $invert:
+			while (i > 0 && filter(&self.entries[i - 1])) i--;
+		$else
+			while (i > 0 && !filter(&self.entries[i - 1])) i--;
+		$endif
+	}
+	return size - self.size;
+}
--- a/lib/std/collections/map.c3
+++ b/lib/std/collections/map.c3
@@ -10,86 +10,84 @@ const float DEFAULT_LOAD_FACTOR = 0.75;
 const VALUE_IS_EQUATABLE = Value.is_eq;
 const bool COPY_KEYS = types::implements_copy(Key);

-struct HashMap
+distinct Map = void*;
+
+struct MapImpl
 {
 	Entry*[] table;
-	Allocator* allocator;
+	Allocator allocator;
 	uint count; // Number of elements
 	uint threshold; // Resize limit
 	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 !map.allocator "Map was already initialized"
 * @require capacity < MAXIMUM_CAPACITY "Capacity cannot exceed maximum"
 **/
-fn HashMap* HashMap.init_new(&map, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR, Allocator* allocator = mem::heap())
+fn Map new(uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR, Allocator allocator = allocator::heap())
 {
-	capacity = math::next_power_of_2(capacity);
-	map.allocator = allocator;
-	map.load_factor = load_factor;
-	map.threshold = (uint)(capacity * load_factor);
-	map.table = allocator.new_zero_array(Entry*, capacity);
-	return map;
+	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 !map.allocator "Map was already initialized"
 * @require capacity < MAXIMUM_CAPACITY "Capacity cannot exceed maximum"
 **/
-fn HashMap* HashMap.init_temp(&map, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
+fn Map temp(uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
 {
-	return map.init_new(capacity, load_factor, mem::temp());
-}
-
-/**
- * Has this hash map been initialized yet?
- *
- * @param [&in] map "The hash map we are testing"
- * @return "Returns true if it has been initialized, false otherwise"
- **/
-fn bool HashMap.is_initialized(&map)
-{
-	return (bool)map.allocator;
-}
-
-/**
- * @param [&inout] allocator "The allocator to use"
- * @param [&in] other_map "The map to copy from."
- **/
-fn HashMap* HashMap.init_new_from_map(&self, HashMap* other_map, Allocator* allocator = mem::heap())
-{
-	self.init_new(other_map.table.len, other_map.load_factor, allocator);
-	self.put_all_for_create(other_map);
-	return self;
+	MapImpl* map = mem::temp_alloc(MapImpl);
+	_init(map, capacity, load_factor, allocator::temp());
+	return (Map)map;
 }

 /**
 * @param [&in] other_map "The map to copy from."
 **/
-fn HashMap* HashMap.init_temp_from_map(&map, HashMap* other_map)
+fn Map new_from_map(Map other_map, Allocator allocator = null)
 {
-	return map.init_new_from_map(other_map, mem::temp()) @inline;
+	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)
+    {
+    	if (!e) continue;
+    	map._put_for_create(e.key, e.value);
+    }
+	return (Map)map;
 }

-fn bool HashMap.is_empty(&map) @inline
+/**
+ * @param [&in] other_map "The map to copy from."
+ **/
+fn Map temp_from_map(Map other_map)
 {
-	return !map.count;
+	return new_from_map(other_map, allocator::temp());
 }

-fn usz HashMap.len(&map) @inline
+fn bool Map.is_empty(map) @inline
 {
-	return map.count;
+	return !map || !((MapImpl*)map).count;
 }

-fn Value*! HashMap.get_ref(&map, Key key)
+fn usz Map.len(map) @inline
 {
-	if (!map.count) return SearchResult.MISSING?;
+	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)
 	{
@@ -98,11 +96,12 @@ fn Value*! HashMap.get_ref(&map, Key key)
 	return SearchResult.MISSING?;
 }

-fn Entry*! HashMap.get_entry(&map, Key key)
+fn Entry*! Map.get_entry(map, Key key)
 {
-	if (!map.count) return SearchResult.MISSING?;
+	MapImpl *map_impl = (MapImpl*)map;
+	if (!map_impl || !map_impl.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)
+	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;
 	}
@@ -111,10 +110,12 @@ fn Entry*! HashMap.get_entry(&map, Key key)

 /**
 * Get the value or update and
+ * @require $assignable(#expr, Value)
 **/
-macro Value HashMap.@get_or_set(&map, Key key, Value #expr)
+macro Value Map.@get_or_set(&self, Key key, Value #expr)
 {
-	if (!map.count)
+	MapImpl *map = (MapImpl*)*self;
+	if (!map || !map.count)
 	{
 		Value val = #expr;
 		map.set(key, val);
@@ -131,23 +132,27 @@ macro Value HashMap.@get_or_set(&map, Key key, Value #expr)
 	return val;
 }

-fn Value! HashMap.get(&map, Key key) @operator([])
+fn Value! Map.get(map, Key key) @operator([])
 {
 	return *map.get_ref(key) @inline;
 }

-fn bool HashMap.has_key(&map, Key key)
+fn bool Map.has_key(map, Key key)
 {
 	return @ok(map.get_ref(key));
 }

-fn bool HashMap.set(&map, Key key, Value value) @operator([]=)
+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 (!map.allocator)
-	{
-		map.init_new();
-	}
+	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)
@@ -158,18 +163,19 @@ fn bool HashMap.set(&map, Key key, Value value) @operator([]=)
 			return true;
 		}
 	}
-	map.add_entry(hash, key, value, index);
+	map._add_entry(hash, key, value, index);
 	return false;
 }

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

-fn void HashMap.clear(&map)
+fn void Map.clear(self)
 {
-	if (!map.count) return;
+	MapImpl* map = (MapImpl*)self;
+	if (!map || !map.count) return;
 	foreach (Entry** &entry_ref : map.table)
 	{
 		Entry* entry = *entry_ref;
@@ -179,32 +185,35 @@ fn void HashMap.clear(&map)
 		{
 			Entry *to_delete = next;
 			next = next.next;
-			map.free_entry(to_delete);
+			map._free_entry(to_delete);
 		}
-		map.free_entry(entry);
+		map._free_entry(entry);
 		*entry_ref = null;
 	}
 	map.count = 0;
 }

-fn void HashMap.free(&map)
+fn void Map.free(self)
 {
-	if (!map.allocator) return;
-	map.clear();
-	map.free_internal(map.table.ptr);
+	if (!self) return;
+	MapImpl* map = (MapImpl*)self;
+	self.clear();
+	map._free_internal(map.table.ptr);
 	map.table = {};
+	allocator::free(map.allocator, map);
 }

-fn Key[] HashMap.key_tlist(&map)
+fn Key[] Map.temp_keys_list(map)
 {
-	return map.key_new_list(mem::temp()) @inline;
+	return map.new_keys_list(allocator::temp()) @inline;
 }

-fn Key[] HashMap.key_new_list(&map, Allocator* allocator = mem::heap())
+fn Key[] Map.new_keys_list(self, Allocator allocator = allocator::heap())
 {
-	if (!map.count) return {};
+	MapImpl* map = (MapImpl*)self;
+	if (!map || !map.count) return {};

-	Key[] list = allocator.new_array(Key, map.count);
+	Key[] list = allocator::alloc_array(allocator, Key, map.count);
 	usz index = 0;
 	foreach (Entry* entry : map.table)
 	{
@@ -217,37 +226,37 @@ fn Key[] HashMap.key_new_list(&map, Allocator* allocator = mem::heap())
 	return list;
 }

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

-macro HashMap.@each_entry(map; @body(entry))
+macro Map.@each_entry(self; @body(entry))
 {
-	if (map.count)
+	MapImpl *map = (MapImpl*)self;
+	if (!map || !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;
 		}
 	}
 }

-fn Value[] HashMap.value_tlist(&map)
+fn Value[] Map.temp_values_list(map)
 {
-	return map.value_new_list(mem::temp()) @inline;
+	return map.new_values_list(allocator::temp()) @inline;
 }

-fn Value[] HashMap.value_new_list(&map, Allocator* allocator = mem::heap())
+fn Value[] Map.new_values_list(self, Allocator allocator = allocator::heap())
 {
-	if (!map.count) return {};
-	Value[] list = allocator.new_array(Value, map.count);
+	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)
 	{
@@ -260,9 +269,10 @@ fn Value[] HashMap.value_new_list(&map, Allocator* allocator = mem::heap())
 	return list;
 }

-fn bool HashMap.has_value(&map, Value v) @if(VALUE_IS_EQUATABLE)
+fn bool Map.has_value(self, Value v) @if(VALUE_IS_EQUATABLE)
 {
-	if (!map.count) return false;
+	MapImpl* map = (MapImpl*)self;
+	if (!map || !map.count) return false;
 	foreach (Entry* entry : map.table)
 	{
 		while (entry)
@@ -276,21 +286,20 @@ fn bool HashMap.has_value(&map, Value v) @if(VALUE_IS_EQUATABLE)

 // --- private methods

-fn void HashMap.add_entry(&map, uint hash, Key key, Value value, uint bucket_index) @private
+fn void MapImpl._add_entry(&map, uint hash, Key key, Value value, uint bucket_index) @private
 {
-	Entry* entry = map.allocator.new(Entry);
 	$if COPY_KEYS:
 	key = key.copy(map.allocator);
 	$endif
-	*entry = { .hash = hash, .key = key, .value = value, .next = map.table[bucket_index] };
+	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);
+		map._resize(map.table.len * 2);
 	}
 }

-fn void HashMap.resize(&map, uint new_capacity) @private
+fn void MapImpl._resize(&map, uint new_capacity) @private
 {
 	Entry*[] old_table = map.table;
 	uint old_capacity = old_table.len;
@@ -299,10 +308,10 @@ fn void HashMap.resize(&map, uint new_capacity) @private
 		map.threshold = uint.max;
 		return;
 	}
-	Entry*[] new_table = map.allocator.new_zero_array(Entry*, new_capacity);
-	map.transfer(new_table);
+	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._free_internal(old_table.ptr);
 	map.threshold = (uint)(new_capacity * map.load_factor);
 }

@@ -317,7 +326,7 @@ macro uint index_for(uint hash, uint capacity) @private
 	return hash & (capacity - 1);
 }

-fn void HashMap.transfer(&map, Entry*[] new_table) @private
+fn void MapImpl._transfer(&map, Entry*[] new_table) @private
 {
 	Entry*[] src = map.table;
 	uint new_capacity = new_table.len;
@@ -336,17 +345,18 @@ fn void HashMap.transfer(&map, Entry*[] new_table) @private
 	}
 }

-fn void HashMap.put_all_for_create(&map, HashMap* other_map) @private
+fn void _init(MapImpl* impl, uint capacity, float load_factor, Allocator allocator) @private
 {
-	if (!other_map.count) return;
-	foreach (Entry *e : other_map.table)
-	{
-		if (!e) continue;
-		map.put_for_create(e.key, e.value);
-	}
+	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 HashMap.put_for_create(&map, Key key, Value value) @private
+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);
@@ -358,16 +368,17 @@ fn void HashMap.put_for_create(&map, Key key, Value value) @private
 			return;
 		}
 	}
-	map.create_entry(hash, key, value, i);
+	map._create_entry(hash, key, value, i);
 }

-fn void HashMap.free_internal(&map, void* ptr) @inline @private
+fn void MapImpl._free_internal(&map, void* ptr) @inline @private
 {
-	map.allocator.free(ptr);
+	allocator::free(map.allocator, ptr);
 }

-fn bool HashMap.remove_entry_for_key(&map, Key key) @private
+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];
@@ -386,7 +397,7 @@ fn bool HashMap.remove_entry_for_key(&map, Key key) @private
 			{
 				prev.next = next;
 			}
-			map.free_entry(e);
+			map._free_entry(e);
 			return true;
 		}
 		prev = e;
@@ -395,24 +406,23 @@ fn bool HashMap.remove_entry_for_key(&map, Key key) @private
 	return false;
 }

-fn void HashMap.create_entry(&map, uint hash, Key key, Value value, int bucket_index) @private
+fn void MapImpl._create_entry(&map, uint hash, Key key, Value value, int bucket_index) @private
 {
 	Entry *e = map.table[bucket_index];
-	Entry* entry = map.allocator.new(Entry);
 	$if COPY_KEYS:
 	key = key.copy(map.allocator);
 	$endif
-	*entry = { .hash = hash, .key = key, .value = value, .next = map.table[bucket_index] };
+	Entry* entry = allocator::new(map.allocator, Entry, { .hash = hash, .key = key, .value = value, .next = map.table[bucket_index] });
 	map.table[bucket_index] = entry;
 	map.count++;
 }

-fn void HashMap.free_entry(&self, Entry *entry) @local
+fn void MapImpl._free_entry(&self, Entry *entry) @local
 {
 	$if COPY_KEYS:
-	self.allocator.free(entry.key);
+	allocator::free(self.allocator, entry.key);
 	$endif
-	self.free_internal(entry);
+	self._free_internal(entry);
 }

 struct Entry
@@ -421,4 +431,4 @@ struct Entry
 	Key key;
 	Value value;
 	Entry* next;
-}
+}
--- a/lib/std/collections/object.c3
+++ b/lib/std/collections/object.c3
@@ -2,9 +2,7 @@
 // Use of this source code is governed by the MIT license
 // a copy of which can be found in the LICENSE_STDLIB file.
 module std::collections::object;
-import std::collections::map;
-import std::collections::list;
-import std::io;
+import std::collections::map, std::collections::list, std::io;

 const Object TRUE_OBJECT = { .b = true, .type = bool.typeid };
 const Object FALSE_OBJECT = { .b = false, .type = bool.typeid };
@@ -13,7 +11,7 @@ const Object NULL_OBJECT = { .type = void*.typeid };
 struct Object (Printable)
 {
 	typeid type;
-	Allocator* allocator;
+	Allocator allocator;
 	union
 	{
 		uint128 i;
@@ -50,9 +48,9 @@ fn usz! Object.to_format(&self, Formatter* formatter) @dynamic
 			return n;
 		case ObjectInternalMap:
 			usz n = formatter.printf("{")!;
-			@pool()
+			@stack_mem(1024; Allocator mem)
 			{
-				foreach (i, key : self.map.key_tlist())
+				foreach (i, key : self.map.key_new_list(mem))
 				{
 					if (i > 0) n += formatter.printf(",")!;
 					n += formatter.printf(`"%s":`, key)!;
@@ -78,11 +76,9 @@ fn usz! Object.to_format(&self, Formatter* formatter) @dynamic
 	}
 }

-fn Object* new_obj(Allocator* allocator)
+fn Object* new_obj(Allocator allocator)
 {
-	Object* o = allocator.new(Object);
-	*o = { .allocator = allocator, .type = void.typeid };
-	return o;
+	return allocator::new(allocator, Object, { .allocator = allocator, .type = void.typeid });
 }

 fn Object* new_null()
@@ -90,32 +86,24 @@ fn Object* new_null()
 	return &NULL_OBJECT;
 }

-fn Object* new_int(int128 i, Allocator* allocator)
+fn Object* new_int(int128 i, Allocator allocator)
 {
-	Object* o = allocator.new(Object);
-	*o = { .i = i, .allocator = allocator, .type = int128.typeid };
-	return o;
+	return allocator::new(allocator, Object, { .i = i, .allocator = allocator, .type = int128.typeid });
 }

-macro Object* new_enum(e, Allocator* allocator)
+macro Object* new_enum(e, Allocator allocator)
 {
-	Object* o = allocator.new(Object);
-	*o = { .i = (int128)e, .allocator = allocator, .type = @typeid(e) };
-	return o;
+	return allocator::new(allocator, Object, { .i = (int128)e, .allocator = allocator, .type = @typeid(e) });
 }

-fn Object* new_float(double f, Allocator* allocator)
+fn Object* new_float(double f, Allocator allocator)
 {
-	Object* o = allocator.new(Object);
-	*o = { .f = f, .allocator = allocator, .type = double.typeid };
-	return o;
+	return allocator::new(allocator, Object, { .f = f, .allocator = allocator, .type = double.typeid });
 }

-fn Object* new_string(String s, Allocator* allocator)
+fn Object* new_string(String s, Allocator allocator)
 {
-	Object* o = allocator.new(Object);
-	*o = { .s = s.copy(allocator), .allocator = allocator, .type = String.typeid };
-	return o;
+	return allocator::new(allocator, Object, { .s = s.copy(allocator), .allocator = allocator, .type = String.typeid });
 }


@@ -131,7 +119,7 @@ fn void Object.free(&self)
 		case void:
 			break;
 		case String:
-			self.allocator.free(self.s);
+			allocator::free(self.allocator, self.s);
 		case ObjectInternalList:
 			foreach (ol : self.array)
 			{
@@ -140,13 +128,13 @@ fn void Object.free(&self)
 			self.array.free();
 		case ObjectInternalMap:
 			self.map.@each_entry(; ObjectInternalMapEntry* entry) {
-				self.allocator.free(entry.key);
+				allocator::free(self.allocator, entry.key);
 				entry.value.free();
 			};
 		default:
 			break;
 	}
-	if (self.allocator) self.allocator.free(self);
+	if (self.allocator) allocator::free(self.allocator, self);
 }

 fn bool Object.is_null(&self) @inline => self == &NULL_OBJECT;
@@ -168,7 +156,7 @@ fn void Object.init_map_if_needed(&self) @private
 	if (self.is_empty())
 	{
 		self.type = ObjectInternalMap.typeid;
-		self.map.init_new(.allocator = self.allocator);
+		self.map.new_init(.allocator = self.allocator);
 	}
 }

@@ -180,7 +168,7 @@ fn void Object.init_array_if_needed(&self) @private
 	if (self.is_empty())
 	{
 		self.type = ObjectInternalList.typeid;
-		self.array.init_new(.allocator = self.allocator);
+		self.array.new_init(.allocator = self.allocator);
 	}
 }

@@ -193,7 +181,7 @@ fn void Object.set_object(&self, String key, Object* new_object) @private
 	ObjectInternalMapEntry*! entry = self.map.get_entry(key);
 	defer
 	{
-		(void)self.allocator.free(entry.key);
+		(void)allocator::free(self.allocator, entry.key);
 		(void)entry.value.free();
 	}
 	self.map.set(key.copy(self.map.allocator), new_object);
@@ -202,7 +190,6 @@ fn void Object.set_object(&self, String key, Object* new_object) @private
 macro Object* Object.object_from_value(&self, value) @private
 {
 	var $Type = $typeof(value);
-
 	$switch
 		$case types::is_int($Type):
 			return new_int(value, self.allocator);
@@ -246,10 +233,10 @@ macro Object* Object.set_at(&self, usz index, String key, value)
 * @require self.is_indexable()
 * @ensure return != null
 **/
-macro Object* Object.append(&self, value)
+macro Object* Object.push(&self, value)
 {
 	Object* val = self.object_from_value(value);
-	self.append_object(val);
+	self.push_object(val);
 	return val;
 }

@@ -280,10 +267,10 @@ fn usz Object.get_len(&self)
 /**
 * @require self.is_indexable()
 **/
-fn void Object.append_object(&self, Object* to_append)
+fn void Object.push_object(&self, Object* to_append)
 {
 	self.init_array_if_needed();
-	self.array.append(to_append);
+	self.array.push(to_append);
 }

 /**
@@ -294,11 +281,11 @@ fn void Object.set_object_at(&self, usz index, Object* to_set)
 	self.init_array_if_needed();
 	while (self.array.len() < index)
 	{
-		self.array.append(&NULL_OBJECT);
+		self.array.push(&NULL_OBJECT);
 	}
 	if (self.array.len() == index)
 	{
-		self.array.append(to_set);
+		self.array.push(to_set);
 		return;
 	}
 	self.array.get(index).free();
--- a/lib/std/collections/priorityqueue.c3
+++ b/lib/std/collections/priorityqueue.c3
@@ -27,7 +27,7 @@ distinct PriorityQueue = inline PrivatePriorityQueue(<Type, false>);
 distinct PriorityQueueMax = inline PrivatePriorityQueue(<Type, true>);

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

 def Heap = List(<Type>);

@@ -36,14 +36,14 @@ struct PrivatePriorityQueue (Printable)
 	Heap heap;
 }

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

-fn void PrivatePriorityQueue.init_temp(&self, usz initial_capacity = 16) @inline
+fn void PrivatePriorityQueue.temp_init(&self, usz initial_capacity = 16) @inline
 {
-	self.heap.init_new(initial_capacity, mem::temp()) @inline;
+	self.heap.new_init(initial_capacity, allocator::temp()) @inline;
 }

 fn void PrivatePriorityQueue.push(&self, Type element)
@@ -74,29 +74,32 @@ fn Type! PrivatePriorityQueue.pop(&self)
 	usz i = 0;
 	usz len = self.heap.len();
 	if (!len) return IteratorResult.NO_MORE_ELEMENT?;
-	usz newCount = len - 1;
-	self.heap.swap(0, newCount);
-	while ((2 * i + 1) < newCount)
+	usz new_count = len - 1;
+	self.heap.swap(0, new_count);
+	while OUTER: ((2 * i + 1) < new_count)
 	{
 		usz j = 2 * i + 1;
-		Type itemj = self.heap[j];
-		if ((j + 1) < newCount)
-		{
-			Type nextj = self.heap[j + 1];
-			$if MAX:
-				bool ok = greater(nextj, itemj);
-			$else
-				bool ok = less(nextj, itemj);
-			$endif
-			if (ok) j++;
-		}
+		Type left = self.heap[j];
 		Type item = self.heap[i];
-		$if MAX:
-			bool ok = less(item, itemj);
-		$else
-			bool ok = greater(item, itemj);
-		$endif
-		if (!ok) break;
+		switch
+		{
+			case j + 1 < new_count:
+				Type right = self.heap[j + 1];
+				$if MAX:
+				if (!greater(right, left)) nextcase;
+				if (!greater(right, item)) break OUTER;
+				$else
+				if (!greater(left, right)) nextcase;
+				if (!greater(item, right)) break OUTER;
+				$endif
+				j++;
+			default:
+				$if MAX:
+				if (!greater(left, item)) break OUTER;
+				$else
+				if (!greater(item, left)) break OUTER;
+				$endif
+		}
 		self.heap.swap(i, j);
 		i = j;
 	}
@@ -104,7 +107,7 @@ fn Type! PrivatePriorityQueue.pop(&self)
 	return self.heap.pop();
 }

-fn Type! PrivatePriorityQueue.peek(&self)
+fn Type! PrivatePriorityQueue.first(&self)
 {
 	if (!self.len()) return IteratorResult.NO_MORE_ELEMENT?;
 	return self.heap.get(0);
@@ -128,7 +131,7 @@ fn bool PrivatePriorityQueue.is_empty(&self)
 /**
 * @require index < self.len()
 */
-fn Type PrivatePriorityQueue.peek_at(&self, usz index) @operator([])
+fn Type PrivatePriorityQueue.get(&self, usz index) @operator([])
 {
 	return self.heap[index];
 }
@@ -138,7 +141,7 @@ fn usz! PrivatePriorityQueue.to_format(&self, Formatter* formatter) @dynamic
 	return self.heap.to_format(formatter);
 }

-fn String PrivatePriorityQueue.to_new_string(&self, Allocator* allocator = mem::heap()) @dynamic
+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
@@ -2,6 +2,7 @@
 * @require Type.is_ordered : "The type must be ordered"
 **/
 module std::collections::range(<Type>);
+import std::io;

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

-fn String Range.to_new_string(&self, Allocator* allocator = mem::heap()) @dynamic
+fn String Range.to_new_string(&self, Allocator allocator = allocator::heap()) @dynamic
 {
 	return string::new_format("[%s..%s]", self.start, self.end, .allocator = allocator);
 }

 fn String Range.to_tstring(&self)
 {
-	return self.to_new_string(mem::temp());
+	return self.to_new_string(allocator::temp());
 }

 fn usz! Range.to_format(&self, Formatter* formatter) @dynamic
@@ -65,14 +66,14 @@ 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 = mem::heap()) @dynamic
+fn String ExclusiveRange.to_new_string(&self, Allocator allocator = allocator::heap()) @dynamic
 {
 	return string::new_format("[%s..<%s]", self.start, self.end, .allocator = allocator);
 }

 fn String ExclusiveRange.to_tstring(&self)
 {
-	return self.to_new_string(mem::temp());
+	return self.to_new_string(allocator::temp());
 }

 /**
--- a/lib/std/collections/ringbuffer.c3
+++ b/lib/std/collections/ringbuffer.c3
@@ -12,7 +12,7 @@ fn void RingBuffer.init(&self) @inline
 	*self = {};
 }

-fn void RingBuffer.putc(&self, Type c)
+fn void RingBuffer.push(&self, Type c)
 {
 	if (self.written < SIZE)
 	{
@@ -26,7 +26,7 @@ fn void RingBuffer.putc(&self, Type c)
 	}
 }

-fn Type RingBuffer.getc(&self, usz index)
+fn Type RingBuffer.get(&self, usz index) @operator([])
 {
 	index %= SIZE;
 	usz avail = SIZE - self.head;
@@ -37,7 +37,7 @@ fn Type RingBuffer.getc(&self, usz index)
 	return self.buf[index - avail];
 }

-fn Type! RingBuffer.popc(&self)
+fn Type! RingBuffer.pop(&self)
 {
 	switch
 	{
@@ -52,7 +52,7 @@ fn Type! RingBuffer.popc(&self)
 	}
 }

-fn usz RingBuffer.get(&self, usz index, Type[] buffer)
+fn usz RingBuffer.read(&self, usz index, Type[] buffer)
 {
 	index %= SIZE;
 	if (self.written < SIZE)
@@ -87,7 +87,7 @@ fn usz RingBuffer.get(&self, usz index, Type[] buffer)
 	return n1 + n2;
 }

-fn void RingBuffer.push(&self, Type[] buffer)
+fn void RingBuffer.write(&self, Type[] buffer)
 {
 	usz i;
 	while (self.written < SIZE && i < buffer.len)
--- a/lib/std/core/allocators/arena_allocator.c3
+++ b/lib/std/core/allocators/arena_allocator.c3
@@ -2,6 +2,7 @@
 // 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;

 struct ArenaAllocator (Allocator)
 {
@@ -29,9 +30,11 @@ struct ArenaAllocatorHeader @local
 	char[*] data;
 }

+/*
+ * @require ptr != null
+ **/
 fn void ArenaAllocator.release(&self, void* ptr, bool) @dynamic
 {
-	if (!ptr) return;
 	assert((uptr)ptr >= (uptr)self.data.ptr, "Pointer originates from a different allocator.");
 	ArenaAllocatorHeader* header = ptr - ArenaAllocatorHeader.sizeof;
 	// Reclaim memory if it's the last element.
@@ -40,53 +43,40 @@ fn void ArenaAllocator.release(&self, void* ptr, bool) @dynamic
 		self.used -= header.size + ArenaAllocatorHeader.sizeof;
 	}
 }
+
 fn usz ArenaAllocator.mark(&self) @dynamic => self.used;
 fn void ArenaAllocator.reset(&self, usz mark) @dynamic => self.used = mark;

 /**
 * @require !alignment || math::is_power_of_2(alignment)
 * @require alignment <= mem::MAX_MEMORY_ALIGNMENT `alignment too big`
- * @require offset <= mem::MAX_MEMORY_ALIGNMENT `offset too big`
- * @require offset <= size && offset >= 0
- * @require mem::aligned_offset(offset, ArenaAllocatorHeader.alignof) == offset
+ * @require size > 0
 **/
-fn void*! ArenaAllocator.acquire(&self, usz size, bool clear, usz alignment, usz offset) @dynamic
+fn void*! ArenaAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic
 {
-	if (!size) return null;
 	alignment = alignment_for_allocation(alignment);
 	usz total_len = self.data.len;
 	if (size > total_len) return AllocationFailure.CHUNK_TOO_LARGE?;
 	void* start_mem = self.data.ptr;
-	void* unaligned_pointer_to_offset = start_mem + self.used + ArenaAllocatorHeader.sizeof + offset;
-	void* aligned_pointer_to_offset = mem::aligned_pointer(unaligned_pointer_to_offset, alignment);
-	usz end = (usz)(aligned_pointer_to_offset - self.data.ptr) + size - offset;
+	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?;
 	self.used = end;
-	void* mem = aligned_pointer_to_offset - offset;
 	ArenaAllocatorHeader* header = mem - ArenaAllocatorHeader.sizeof;
 	header.size = size;
-	if (clear) mem::clear(mem, size, mem::DEFAULT_MEM_ALIGNMENT);
+	if (init_type == ZERO) mem::clear(mem, size, mem::DEFAULT_MEM_ALIGNMENT);
 	return mem;
 }

 /**
 * @require !alignment || math::is_power_of_2(alignment)
 * @require alignment <= mem::MAX_MEMORY_ALIGNMENT `alignment too big`
- * @require offset <= mem::MAX_MEMORY_ALIGNMENT `offset too big`
- * @require offset <= size && offset >= 0
- * @require mem::aligned_offset(offset, ArenaAllocatorHeader.alignof) == offset
+ * @require old_pointer != null
+ * @require size > 0
 **/
-fn void*! ArenaAllocator.resize(&self, void *old_pointer, usz size, usz alignment, usz offset) @dynamic
+fn void*! ArenaAllocator.resize(&self, void *old_pointer, usz size, usz alignment) @dynamic
 {
-	if (!size)
-	{
-		self.release(old_pointer, alignment > 0);
-		return null;
-	}
-	if (!old_pointer)
-	{
-		return self.acquire(size, true, alignment, offset);
-	}
 	alignment = alignment_for_allocation(alignment);
 	assert(old_pointer >= self.data.ptr, "Pointer originates from a different allocator.");
 	usz total_len = self.data.len;
@@ -94,7 +84,7 @@ fn void*! ArenaAllocator.resize(&self, void *old_pointer, usz size, usz alignmen
 	ArenaAllocatorHeader* header = old_pointer - ArenaAllocatorHeader.sizeof;
 	usz old_size = header.size;
 	// Do last allocation and alignment match?
-	if (&self.data[self.used] == old_pointer + old_size && mem::ptr_is_aligned(old_pointer + offset, alignment))
+	if (&self.data[self.used] == old_pointer + old_size && mem::ptr_is_aligned(old_pointer, alignment))
 	{
 		if (old_size >= size)
 		{
@@ -110,7 +100,7 @@ fn void*! ArenaAllocator.resize(&self, void *old_pointer, usz size, usz alignmen
 		return old_pointer;
 	}
 	// Otherwise just allocate new memory.
-	void* mem = self.acquire(size, false, alignment, offset)!;
+	void* mem = self.acquire(size, NO_ZERO, alignment)!;
 	mem::copy(mem, old_pointer, old_size, mem::DEFAULT_MEM_ALIGNMENT, mem::DEFAULT_MEM_ALIGNMENT);
 	return mem;
 }
--- a/lib/std/core/allocators/dynamic_arena.c3
+++ b/lib/std/core/allocators/dynamic_arena.c3
@@ -1,11 +1,12 @@
-// Copyright (c) 2021 Christoffer Lerno. All rights reserved.
+// Copyright (c) 2021-2024 Christoffer Lerno. All rights reserved.
 // Use of this source code is governed by the MIT license
 // a copy of which can be found in the LICENSE_STDLIB file.
 module std::core::mem::allocator;
+import std::math;

 struct DynamicArenaAllocator (Allocator)
 {
-	Allocator* backing_allocator;
+	Allocator backing_allocator;
 	DynamicArenaPage* page;
 	DynamicArenaPage* unused_page;
 	usz page_size;
@@ -15,7 +16,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, usz page_size, Allocator allocator)
 {
 	self.page = null;
 	self.unused_page = null;
@@ -23,20 +24,23 @@ fn void DynamicArenaAllocator.init(&self, usz page_size, Allocator* allocator)
 	self.backing_allocator = allocator;
 }

+import std::io;
 fn void DynamicArenaAllocator.free(&self)
 {
 	DynamicArenaPage* page = self.page;
 	while (page)
 	{
 		DynamicArenaPage* next_page = page.prev_arena;
-		self.backing_allocator.free(page);
+		allocator::free(self.backing_allocator, page.memory);
+		allocator::free(self.backing_allocator, page);
 		page = next_page;
 	}
 	page = self.unused_page;
 	while (page)
 	{
 		DynamicArenaPage* next_page = page.prev_arena;
-		self.backing_allocator.free(page);
+		allocator::free(self.backing_allocator, page.memory);
+		allocator::free(self.backing_allocator, page);
 		page = next_page;
 	}
 	self.page = null;
@@ -58,11 +62,11 @@ struct DynamicArenaChunk @local
 }

 /**
+ * @require ptr
 * @require self.page `tried to free pointer on invalid allocator`
 */
 fn void DynamicArenaAllocator.release(&self, void* ptr, bool) @dynamic
 {
-	if (!ptr) return;
 	DynamicArenaPage* current_page = self.page;
 	if (ptr == current_page.current_stack_ptr)
 	{
@@ -72,19 +76,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 `tried to realloc pointer on invalid allocator`
 */
-fn void*! DynamicArenaAllocator.resize(&self, void* old_pointer, usz size, usz alignment, usz offset) @dynamic
+fn void*! DynamicArenaAllocator.resize(&self, void* old_pointer, usz size, usz alignment) @dynamic
 {
-	if (!size)
-	{
-		self.release(old_pointer, alignment > 0);
-		return null;
-	}
-	if (!old_pointer)
-	{
-		return self.acquire(size, true, alignment, offset);
-	}
 	DynamicArenaPage* current_page = self.page;
 	alignment = alignment_for_allocation(alignment);
 	usz* old_size_ptr = old_pointer - DEFAULT_SIZE_PREFIX;
@@ -108,7 +105,7 @@ fn void*! DynamicArenaAllocator.resize(&self, void* old_pointer, usz size, usz a
 		current_page.used += add_size;
 		return old_pointer;
 	}
-	void* new_mem = self.acquire(size, false, alignment, offset)!;
+	void* new_mem = self.acquire(size, NO_ZERO, alignment)!;
 	mem::copy(new_mem, old_pointer, old_size, mem::DEFAULT_MEM_ALIGNMENT);
 	return new_mem;
 }
@@ -134,21 +131,21 @@ fn void DynamicArenaAllocator.reset(&self, usz mark = 0) @dynamic
 * @require math::is_power_of_2(alignment)
 * @require size > 0
 */
-fn void*! DynamicArenaAllocator._alloc_new(&self, usz size, usz alignment, usz offset) @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 + offset, alignment) - offset);
-
+	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 = self.backing_allocator.alloc_checked(page_size)!;
-	DynamicArenaPage*! page = self.backing_allocator.new(DynamicArenaPage);
+	void* mem = allocator::malloc_try(self.backing_allocator, page_size)!;
+	DynamicArenaPage*! page = allocator::new_try(self.backing_allocator, DynamicArenaPage);
 	if (catch err = page)
 	{
-		self.backing_allocator.free(mem);
+		allocator::free(self.backing_allocator, mem);
 		return err?;
 	}
 	page.memory = mem;
-	void* mem_start = mem::aligned_pointer(mem + offset + DynamicArenaChunk.sizeof, alignment) - offset;
+	void* mem_start = mem::aligned_pointer(mem + DynamicArenaChunk.sizeof, alignment);
 	assert(mem_start + size < mem + page_size);
 	DynamicArenaChunk* chunk = (DynamicArenaChunk*)mem_start - 1;
 	chunk.size = size;
@@ -161,11 +158,11 @@ fn void*! DynamicArenaAllocator._alloc_new(&self, usz size, usz alignment, usz o
 }

 /**
+ * @require size > 0 `acquire expects size > 0`
 * @require !alignment || math::is_power_of_2(alignment)
 */
-fn void*! DynamicArenaAllocator.acquire(&self, usz size, bool clear, usz alignment, usz offset) @dynamic
+fn void*! DynamicArenaAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic
 {
-	if (!size) return null;
 	alignment = alignment_for_allocation(alignment);
 	DynamicArenaPage* page = self.page;
 	void* ptr = {|
@@ -175,14 +172,14 @@ fn void*! DynamicArenaAllocator.acquire(&self, usz size, bool clear, usz alignme
 			self.unused_page = page.prev_arena;
 			page.prev_arena = null;
 		}
-		if (!page) return self._alloc_new(size, alignment, offset);
-		void* start = mem::aligned_pointer(page.memory + page.used + DynamicArenaChunk.sizeof + offset, alignment) - offset;
+		if (!page) return self._alloc_new(size, alignment);
+		void* start = mem::aligned_pointer(page.memory + page.used + DynamicArenaChunk.sizeof, alignment);
 		usz new_used = start - page.memory + size;
 		if ALLOCATE_NEW: (new_used > page.total)
 		{
 			if ((page = self.unused_page))
 			{
-				start = mem::aligned_pointer(page.memory + page.used + DynamicArenaChunk.sizeof + offset, alignment) - offset;
+				start = mem::aligned_pointer(page.memory + page.used + DynamicArenaChunk.sizeof, alignment);
 				new_used = start + size - page.memory;
 				if (page.total >= new_used)
 				{
@@ -192,7 +189,7 @@ fn void*! DynamicArenaAllocator.acquire(&self, usz size, bool clear, usz alignme
 					break ALLOCATE_NEW;
 				}
 			}
-			return self._alloc_new(size, alignment, offset);
+			return self._alloc_new(size, alignment);
 		}
 		page.used = new_used;
 		assert(start + size == page.memory + page.used);
@@ -201,6 +198,6 @@ fn void*! DynamicArenaAllocator.acquire(&self, usz size, bool clear, usz alignme
 		chunk.size = size;
 		return mem;
 	|}!;
-	if (clear) mem::clear(ptr, size, mem::DEFAULT_MEM_ALIGNMENT);
+	if (init_type == ZERO) mem::clear(ptr, size, mem::DEFAULT_MEM_ALIGNMENT);
 	return ptr;
 }
--- a/lib/std/core/allocators/heap_allocator.c3
+++ b/lib/std/core/allocators/heap_allocator.c3
@@ -1,9 +1,9 @@
-// Copyright (c) 2021-2023 Christoffer Lerno. All rights reserved.
+// Copyright (c) 2021-2024 Christoffer Lerno. All rights reserved.
 // Use of this source code is governed by the MIT license
 // a copy of which can be found in the LICENSE_STDLIB file.

 module std::core::mem::allocator;
-
+import std::math;

 struct SimpleHeapAllocator (Allocator)
 {
@@ -21,29 +21,19 @@ fn void SimpleHeapAllocator.init(&self, MemoryAllocFn allocator)
 	self.free_list = null;
 }

-fn void*! SimpleHeapAllocator.acquire(&self, usz size, bool clear, usz alignment, usz offset) @dynamic
+fn void*! SimpleHeapAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic
 {
-	if (!size) return null;
-	if (clear)
+	if (init_type == ZERO)
 	{
-		return alignment > 0 ? @aligned_calloc(self._calloc, size, alignment, offset) : self._calloc(size);
+		return alignment > 0 ? @aligned_alloc(self._calloc, size, alignment) : self._calloc(size);
 	}
-	return alignment > 0 ? @aligned_alloc(self._alloc, size, alignment, offset) : self._alloc(size);
+	return alignment > 0 ? @aligned_alloc(self._alloc, size, alignment) : self._alloc(size);
 }

-fn void*! SimpleHeapAllocator.resize(&self, void* old_pointer, usz size, usz alignment, usz offset) @dynamic
+fn void*! SimpleHeapAllocator.resize(&self, void* old_pointer, usz size, usz alignment) @dynamic
 {
-	if (!size)
-	{
-		self.release(old_pointer, alignment > 0);
-		return null;
-	}
-	if (!old_pointer)
-	{
-		return self.acquire(size, true, alignment, offset);
-	}
 	return alignment > 0
-		? @aligned_realloc(self._calloc, self._free, old_pointer, size, alignment, offset)
+		? @aligned_realloc(self._calloc, self._free, old_pointer, size, alignment)
 		:  self._realloc(old_pointer, size);
 }

--- a/lib/std/core/allocators/libc_allocator.c3
+++ b/lib/std/core/allocators/libc_allocator.c3
@@ -1,4 +1,4 @@
-// Copyright (c) 2021 Christoffer Lerno. All rights reserved.
+// Copyright (c) 2021-2024 Christoffer Lerno. All rights reserved.
 // Use of this source code is governed by the MIT license
 // a copy of which can be found in the LICENSE_STDLIB file.

@@ -6,21 +6,123 @@ module std::core::mem::allocator;
 import libc;

 const LibcAllocator LIBC_ALLOCATOR = {};
-
-
 distinct LibcAllocator (Allocator) = uptr;

-fn void*! LibcAllocator.acquire(&self, usz bytes, bool clear, usz alignment, usz offset) @dynamic
+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
 {
-	assert(alignment != 0 || offset == 0);
-	if (clear)
+	if (init_type == ZERO)
 	{
-		void* data = alignment ? @aligned_calloc(fn void*(usz bytes) => libc::calloc(bytes, 1), bytes, alignment, offset)!! : libc::calloc(bytes, 1);
+		void* data @noinit;
+		if (alignment > mem::DEFAULT_MEM_ALIGNMENT)
+		{
+			if (posix::posix_memalign(&data, alignment, bytes)) return AllocationFailure.OUT_OF_MEMORY?;
+			mem::clear(data, bytes, mem::DEFAULT_MEM_ALIGNMENT);
+			return data;
+		}
+        return libc::calloc(1, bytes) ?: AllocationFailure.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?;
+		}
+		else
+		{
+			if (!(data = libc::malloc(bytes))) return AllocationFailure.OUT_OF_MEMORY?;
+		}
+        $if env::TESTING:
+		    for (usz i = 0; i < bytes; i++) ((char*)data)[i] = 0xAA;
+        $endif
+        return data;
+	}
+}
+
+fn void*! LibcAllocator.resize(&self, void* old_ptr, usz new_bytes, usz alignment) @dynamic
+{
+	if (alignment <= mem::DEFAULT_MEM_ALIGNMENT) return libc::realloc(old_ptr, new_bytes) ?: AllocationFailure.OUT_OF_MEMORY?;
+    void* new_ptr;
+	if (posix::posix_memalign(&new_ptr, alignment, new_bytes)) return AllocationFailure.OUT_OF_MEMORY?;
+
+	$switch
+	$case env::DARWIN:
+		usz old_usable_size = darwin::malloc_size(old_ptr);
+	$case env::LINUX:
+		usz old_usable_size = linux::malloc_usable_size(old_ptr);
+	$default:
+		usz old_usable_size = new_bytes;
+	$endswitch
+
+	usz copy_size = new_bytes < old_usable_size ? new_bytes : old_usable_size;
+	mem::copy(new_ptr, old_ptr, copy_size, mem::DEFAULT_MEM_ALIGNMENT, mem::DEFAULT_MEM_ALIGNMENT);
+	libc::free(old_ptr);
+	return new_ptr;
+}
+
+fn void LibcAllocator.release(&self, void* old_ptr, bool aligned) @dynamic
+{
+	libc::free(old_ptr);
+}
+
+module std::core::mem::allocator @if(env::WIN32);
+import std::os::win32;
+import libc;
+
+fn void*! LibcAllocator.acquire(&self, usz bytes, AllocInitType init_type, usz alignment) @dynamic
+{
+	if (init_type == ZERO)
+	{
+		if (alignment > 0)
+		{
+			return win32::_aligned_recalloc(null, 1, bytes, alignment) ?: AllocationFailure.OUT_OF_MEMORY?;
+		}
+		return libc::calloc(1, bytes) ?: AllocationFailure.OUT_OF_MEMORY?;
+	}
+	void* data = alignment > 0 ? win32::_aligned_malloc(bytes, alignment) : libc::malloc(bytes);
+	if (!data) return AllocationFailure.OUT_OF_MEMORY?;
+    $if env::TESTING:
+		for (usz i = 0; i < bytes; i++) ((char*)data)[i] = 0xAA;
+	$endif
+    return data;
+}
+
+fn void*! LibcAllocator.resize(&self, void* old_ptr, usz new_bytes, usz alignment) @dynamic
+{
+	if (alignment)
+	{
+		return win32::_aligned_realloc(old_ptr, new_bytes, alignment) ?: AllocationFailure.OUT_OF_MEMORY?;
+	}
+	return libc::realloc(old_ptr, new_bytes) ?: AllocationFailure.OUT_OF_MEMORY?;
+}
+
+fn void LibcAllocator.release(&self, void* old_ptr, bool aligned) @dynamic
+{
+	if (aligned)
+	{
+    	win32::_aligned_free(old_ptr);
+    	return;
+	}
+	libc::free(old_ptr);
+}
+
+module std::core::mem::allocator @if(!env::WIN32 && !env::POSIX);
+import libc;
+
+fn void*! LibcAllocator.acquire(&self, usz bytes, AllocInitType init_type, usz alignment) @dynamic
+{
+	if (init_type == ZERO)
+	{
+		void* data = alignment ? @aligned_alloc(fn void*(usz bytes) => libc::calloc(bytes, 1), bytes, alignment)!! : libc::calloc(bytes, 1);
        return data ?: AllocationFailure.OUT_OF_MEMORY?;
 	}
 	else
 	{
-		void* data = alignment ? @aligned_alloc(libc::malloc, bytes, alignment, offset)!! : libc::malloc(bytes);
+		void* data = alignment ? @aligned_alloc(libc::malloc, bytes, alignment)!! : libc::malloc(bytes);
        if (!data) return AllocationFailure.OUT_OF_MEMORY?;
        $if env::TESTING:
 		    for (usz i = 0; i < bytes; i++) ((char*)data)[i] = 0xAA;
@@ -29,21 +131,12 @@ fn void*! LibcAllocator.acquire(&self, usz bytes, bool clear, usz alignment, usz
 	}
 }

-fn void*! LibcAllocator.resize(&self, void* old_ptr, usz new_bytes, usz alignment, usz offset) @dynamic
+
+fn void*! LibcAllocator.resize(&self, void* old_ptr, usz new_bytes, usz alignment) @dynamic
 {
-	assert(alignment != 0 || offset == 0);
-	if (!new_bytes)
-	{
-		self.release(old_ptr, alignment > 0);
-		return null;
-	}
-	if (!old_ptr)
-	{
-		return self.acquire(new_bytes, true, alignment, offset);
-	}
 	if (alignment)
 	{
-		void* data = @aligned_realloc(fn void*(usz bytes) => libc::calloc(bytes, 1), libc::free, old_ptr, new_bytes, alignment, offset)!!;
+		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 libc::realloc(old_ptr, new_bytes) ?: AllocationFailure.OUT_OF_MEMORY?;
--- a/lib/std/core/allocators/on_stack_allocator.c3
+++ b/lib/std/core/allocators/on_stack_allocator.c3
@@ -2,7 +2,7 @@ module std::core::mem::allocator;

 struct OnStackAllocator (Allocator)
 {
-	Allocator* backing_allocator;
+	Allocator backing_allocator;
 	char[] data;
 	usz used;
 	OnStackAllocatorExtraChunk* chunk;
@@ -20,7 +20,7 @@ struct OnStackAllocatorExtraChunk @local
 * @param [&inout] allocator
 * Initialize a memory arena for use using the provided bytes.
 **/
-fn void OnStackAllocator.init(&self, char[] data, Allocator* allocator)
+fn void OnStackAllocator.init(&self, char[] data, Allocator allocator)
 {
 	self.data = data;
 	self.backing_allocator = allocator;
@@ -34,15 +34,15 @@ fn void OnStackAllocator.free(&self)
 	{
 		if (chunk.is_aligned)
 		{
-			self.backing_allocator.free_aligned(chunk.data);
+			allocator::free_aligned(self.backing_allocator, chunk.data);
 		}
 		else
 		{
-			self.backing_allocator.free(chunk.data);
+			allocator::free(self.backing_allocator, chunk.data);
 		}
 		void* old = chunk;
 		chunk = chunk.prev;
-		self.backing_allocator.free(old);
+		allocator::free(self.backing_allocator, old);
 	}
 	self.chunk = null;
 	self.used = 0;
@@ -54,9 +54,11 @@ struct OnStackAllocatorHeader
 	char[*] data;
 }

+/**
+ * @require old_pointer
+ **/
 fn void OnStackAllocator.release(&self, void* old_pointer, bool aligned) @dynamic
 {
-	if (!old_pointer) return;
 	if (allocation_in_stack_mem(self, old_pointer)) return;
 	on_stack_allocator_remove_chunk(self, old_pointer);
 	self.release(old_pointer, aligned);
@@ -76,7 +78,7 @@ fn void on_stack_allocator_remove_chunk(OnStackAllocator* a, void* ptr) @local
 		if (chunk.data == ptr)
 		{
 			*addr = chunk.prev;
-			a.backing_allocator.free(chunk);
+			allocator::free(a.backing_allocator, chunk);
 			return;
 		}
 		addr = &chunk.prev;
@@ -98,56 +100,49 @@ 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 offset <= mem::MAX_MEMORY_ALIGNMENT `offset too big`
- * @require offset <= size && offset >= 0
- * @require mem::aligned_offset(offset, OnStackAllocatorExtraChunk.alignof) == offset
 **/
-fn void*! OnStackAllocator.resize(&self, void* old_pointer, usz size, usz alignment, usz offset) @dynamic
+fn void*! OnStackAllocator.resize(&self, void* old_pointer, usz size, usz alignment) @dynamic
 {
 	if (!allocation_in_stack_mem(self, old_pointer))
 	{
 		OnStackAllocatorExtraChunk* chunk = on_stack_allocator_find_chunk(self, old_pointer);
 		assert(chunk, "Tried to realloc pointer not belonging to the allocator");
-		return chunk.data = self.backing_allocator.resize(old_pointer, size, alignment, offset)!;
+		return chunk.data = self.backing_allocator.resize(old_pointer, size, alignment)!;
 	}

 	OnStackAllocatorHeader* header = old_pointer - OnStackAllocatorHeader.sizeof;
 	usz old_size = header.size;
-	void* mem = self.acquire(size, true, alignment, offset)!;
+	void* mem = self.acquire(size, NO_ZERO, alignment)!;
 	mem::copy(mem, old_pointer, old_size, mem::DEFAULT_MEM_ALIGNMENT, mem::DEFAULT_MEM_ALIGNMENT);
 	return mem;
 }

 /**
 * @require alignment <= mem::MAX_MEMORY_ALIGNMENT `alignment too big`
- * @require offset <= mem::MAX_MEMORY_ALIGNMENT `offset too big`
- * @require offset <= size && offset >= 0
- * @require offset == 0 || alignment > 0
- * @require mem::aligned_offset(offset, OnStackAllocatorHeader.alignof) == offset
+ * @require size > 0
 **/
-fn void*! OnStackAllocator.acquire(&self, usz size, bool clear, usz alignment, usz offset) @dynamic
+fn void*! OnStackAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic
 {
-	if (size == 0) return null;
 	bool aligned = alignment > 0;
 	alignment = alignment_for_allocation(alignment);
 	usz total_len = self.data.len;
 	void* start_mem = self.data.ptr;
-	void* unaligned_pointer_to_offset = start_mem + self.used + OnStackAllocatorHeader.sizeof + offset;
-	void* aligned_pointer_to_offset = mem::aligned_pointer(unaligned_pointer_to_offset, alignment);
-	usz end = (usz)(aligned_pointer_to_offset - self.data.ptr) + size - offset;
-	Allocator* backing_allocator = self.backing_allocator;
+	void* unaligned_pointer_to_offset = start_mem + self.used + OnStackAllocatorHeader.sizeof ;
+	void* mem = mem::aligned_pointer(unaligned_pointer_to_offset, alignment);
+	usz end = (usz)(mem - self.data.ptr) + size;
+	Allocator backing_allocator = self.backing_allocator;

 	if (end > total_len)
 	{
-		OnStackAllocatorExtraChunk* chunk = backing_allocator.alloc_checked(OnStackAllocatorExtraChunk.sizeof)!;
-		defer catch backing_allocator.free(chunk);
+		OnStackAllocatorExtraChunk* chunk = allocator::alloc_try(backing_allocator, OnStackAllocatorExtraChunk)!;
+		defer catch allocator::free(backing_allocator, chunk);
 		defer try self.chunk = chunk;
 		*chunk = { .prev = self.chunk, .is_aligned = aligned };
-		return chunk.data = backing_allocator.acquire(size, clear, aligned ? alignment : 0, offset)!;
+		return chunk.data = backing_allocator.acquire(size, init_type, aligned ? alignment : 0)!;
 	}
 	self.used = end;
-	void *mem = aligned_pointer_to_offset - offset;
 	OnStackAllocatorHeader* header = mem - OnStackAllocatorHeader.sizeof;
 	header.size = size;
 	return mem;
--- a/lib/std/core/allocators/temp_allocator.c3
+++ b/lib/std/core/allocators/temp_allocator.c3
@@ -1,5 +1,5 @@
 module std::core::mem::allocator;
-import std::io;
+import std::io, std::math;

 struct TempAllocatorChunk @local
 {
@@ -9,7 +9,7 @@ struct TempAllocatorChunk @local

 struct TempAllocator (Allocator)
 {
-	Allocator* backing_allocator;
+	Allocator backing_allocator;
 	TempAllocatorPage* last_page;
 	usz used;
 	usz capacity;
@@ -35,9 +35,9 @@ macro bool TempAllocatorPage.is_aligned(&self) => self.size & PAGE_IS_ALIGNED ==
 /**
 * @require size >= 16
 **/
-fn TempAllocator*! new_temp(usz size, Allocator* allocator)
+fn TempAllocator*! new_temp_allocator(usz size, Allocator allocator)
 {
-	TempAllocator* temp = allocator.alloc_checked(TempAllocator.sizeof + size)!;
+	TempAllocator* temp = allocator::alloc_with_padding(allocator, TempAllocator, size)!;
 	temp.last_page = null;
 	temp.backing_allocator = allocator;
 	temp.used = 0;
@@ -45,6 +45,13 @@ fn TempAllocator*! new_temp(usz size, Allocator* allocator)
 	return temp;
 }

+fn void TempAllocator.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 void TempAllocator.release(&self, void* old_pointer, bool) @dynamic
@@ -53,6 +60,7 @@ fn void TempAllocator.release(&self, void* old_pointer, bool) @dynamic
 	if (old_pointer + old_size == &self.data[self.used])
 	{
 		self.used -= old_size;
+		asan::poison_memory_region(&self.data[self.used], old_size);
 	}
 }
 fn void TempAllocator.reset(&self, usz mark) @dynamic
@@ -65,17 +73,29 @@ fn void TempAllocator.reset(&self, usz mark) @dynamic
 		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:
+					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
 {
 	void* mem = page.start;
-	if (page.is_aligned()) return self.backing_allocator.free_aligned(mem);
-	return self.backing_allocator.free(mem);
+	return self.backing_allocator.release(mem, page.is_aligned());
 }

-fn void*! TempAllocator._realloc_page(&self, TempAllocatorPage* page, usz size, usz alignment, usz offset) @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;
@@ -90,53 +110,36 @@ fn void*! TempAllocator._realloc_page(&self, TempAllocatorPage* page, usz size,
 	*pointer_to_prev = page.prev_page;
 	usz page_size = page.pagesize();
 	// Clear on size > original size.
-	void* data = self.acquire(size, size > page_size, alignment, offset)!;
+	void* data = self.acquire(size, NO_ZERO, alignment)!;
 	mem::copy(data, &page.data[0], page_size, mem::DEFAULT_MEM_ALIGNMENT, mem::DEFAULT_MEM_ALIGNMENT);
-	if (page.is_aligned())
-	{
-		self.backing_allocator.free_aligned(real_pointer);
-	}
-	else
-	{
-		self.backing_allocator.free(real_pointer);
-	}
+	self.backing_allocator.release(real_pointer, page.is_aligned());
 	return data;
 }

-fn void*! TempAllocator.resize(&self, void* pointer, usz size, usz alignment, usz offset) @dynamic
+fn void*! TempAllocator.resize(&self, void* pointer, usz size, usz alignment) @dynamic
 {
-	if (!size)
-	{
-		self.release(pointer, alignment > 0);
-		return null;
-	}
-	if (!pointer)
-	{
-		return self.acquire(size, true, alignment, offset);
-	}
 	TempAllocatorChunk *chunk = pointer - TempAllocatorChunk.sizeof;
 	if (chunk.size == (usz)-1)
 	{
 		assert(self.last_page, "Realloc of non temp pointer");
 		// First grab the page
 		TempAllocatorPage *page = pointer - TempAllocatorPage.sizeof;
-		return self._realloc_page(page, size, alignment, offset);
+		return self._realloc_page(page, size, alignment);
 	}

-	// TODO optimize last allocation
-	TempAllocatorChunk* data = self.acquire(size, size > chunk.size, alignment, offset)!;
+	TempAllocatorChunk* data = self.acquire(size, NO_ZERO, alignment)!;
 	mem::copy(data, pointer, chunk.size, mem::DEFAULT_MEM_ALIGNMENT, mem::DEFAULT_MEM_ALIGNMENT);

 	return data;
 }

 /**
+ * @require size > 0
 * @require !alignment || math::is_power_of_2(alignment)
 * @require alignment <= mem::MAX_MEMORY_ALIGNMENT `alignment too big`
 **/
-fn void*! TempAllocator.acquire(&self, usz size, bool clear, usz alignment, usz offset) @dynamic
+fn void*! TempAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic
 {
-	if (!size) return null;
 	alignment = alignment_for_allocation(alignment);
 	void* start_mem = &self.data;
 	void* starting_ptr = start_mem + self.used;
@@ -144,17 +147,18 @@ fn void*! TempAllocator.acquire(&self, usz size, bool clear, usz alignment, usz
 	void* mem = aligned_header_start + TempAllocatorChunk.sizeof;
 	if (alignment > TempAllocatorChunk.alignof)
 	{
-		mem = mem::aligned_pointer(mem + offset, alignment) - offset;
+		mem = mem::aligned_pointer(mem, alignment);
 	}
 	usz new_usage = (usz)(mem - start_mem) + size;

-	// Arena alignment, simple!
+	// Arena allocation, simple!
 	if (new_usage <= self.capacity)
 	{
+		asan::unpoison_memory_region(starting_ptr, new_usage - self.used);
 		TempAllocatorChunk* chunk_start = mem - TempAllocatorChunk.sizeof;
 		chunk_start.size = size;
 		self.used = new_usage;
-		if (clear) mem::clear(mem, size, mem::DEFAULT_MEM_ALIGNMENT);
+		if (init_type == ZERO) mem::clear(mem, size, mem::DEFAULT_MEM_ALIGNMENT);
 		return mem;
 	}

@@ -162,19 +166,20 @@ fn void*! TempAllocator.acquire(&self, usz size, bool clear, usz alignment, usz
 	TempAllocatorPage* page;

 	// We have something we need to align.
-	if (alignment > mem::DEFAULT_MEM_ALIGNMENT || offset)
+	if (alignment > mem::DEFAULT_MEM_ALIGNMENT)
 	{
 		// This is actually simpler, since it will create the offset for us.
-		usz total_alloc_size = TempAllocatorPage.sizeof + size;
-		if (clear)
+		usz total_alloc_size = mem::aligned_offset(TempAllocatorPage.sizeof + size, alignment);
+		if (init_type == ZERO)
 		{
-			page = self.backing_allocator.calloc_aligned(total_alloc_size, alignment, TempAllocatorPage.sizeof + offset)!;
+			mem = allocator::calloc_aligned(self.backing_allocator, total_alloc_size, alignment)!;
 		}
 		else
 		{
-			page = self.backing_allocator.alloc_aligned(total_alloc_size, alignment, TempAllocatorPage.sizeof + offset)!;
+			mem = allocator::malloc_aligned(self.backing_allocator, total_alloc_size, alignment)!;
 		}
-		page.start = page;
+		page = (TempAllocatorPage*)mem - 1;
+		page.start = mem;
 		page.size = size | PAGE_IS_ALIGNED;
 	}
 	else
@@ -182,7 +187,7 @@ fn void*! TempAllocator.acquire(&self, usz size, bool clear, usz alignment, usz
 		// Here we might need to pad
 		usz padded_header_size = mem::aligned_offset(TempAllocatorPage.sizeof, mem::DEFAULT_MEM_ALIGNMENT);
 		usz total_alloc_size = padded_header_size + size;
-		void* alloc = self.backing_allocator.acquire(total_alloc_size, clear, 0, 0)!;
+		void* alloc = self.backing_allocator.acquire(total_alloc_size, init_type, 0)!;

 		// Find the page.
 		page = alloc + padded_header_size - TempAllocatorPage.sizeof;
--- a/lib/std/core/allocators/tracking_allocator.c3
+++ b/lib/std/core/allocators/tracking_allocator.c3
@@ -1,10 +1,9 @@
-// Copyright (c) 2021 Christoffer Lerno. All rights reserved.
+// Copyright (c) 2021-2024 Christoffer Lerno. All rights reserved.
 // Use of this source code is governed by the MIT license
 // a copy of which can be found in the LICENSE_STDLIB file.

 module std::core::mem::allocator;
-import std::collections::map;
-import std::collections::list;
+import std::collections, std::io, std::os::backtrace;

 const MAX_BACKTRACE = 16;
 struct Allocation
@@ -21,7 +20,7 @@ def AllocMap = HashMap(<uptr, Allocation>);
 // is not compatible with allocators that uses mark()
 struct TrackingAllocator (Allocator)
 {
-	Allocator* inner_allocator;
+	Allocator inner_allocator;
 	AllocMap map;
 	usz mem_total;
 	usz allocs_total;
@@ -32,10 +31,10 @@ struct TrackingAllocator (Allocator)
 *
 * @param [&inout] allocator "The allocator to track"
 **/
-fn void TrackingAllocator.init(&self, Allocator* allocator)
+fn void TrackingAllocator.init(&self, Allocator allocator)
 {
 	*self = { .inner_allocator = allocator };
-	self.map.init_new(.allocator = allocator);
+	self.map.new_init(.allocator = allocator);
 }

 /**
@@ -70,7 +69,7 @@ fn usz TrackingAllocator.total_allocated(&self) => self.mem_total;
 **/
 fn usz TrackingAllocator.total_allocation_count(&self) => self.allocs_total;

-fn Allocation[] TrackingAllocator.allocations_tlist(&self, Allocator* allocator)
+fn Allocation[] TrackingAllocator.allocations_tlist(&self, Allocator allocator)
 {
 	return self.map.value_tlist();
 }
@@ -80,48 +79,36 @@ fn Allocation[] TrackingAllocator.allocations_tlist(&self, Allocator* allocator)
 **/
 fn usz TrackingAllocator.allocation_count(&self) => self.map.count;

-fn void*! TrackingAllocator.acquire(&self, usz size, bool clear, usz alignment, usz offset) @dynamic
+fn void*! TrackingAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic
 {
-	void* data = self.inner_allocator.acquire(size, clear, alignment, offset)!;
+	void* data = self.inner_allocator.acquire(size, init_type, alignment)!;
+	self.allocs_total++;
+	void*[MAX_BACKTRACE] bt;
+	backtrace::capture_current(&bt);
+	self.map.set((uptr)data, { data, size, bt });
+    self.mem_total += size;
 	self.allocs_total++;
-	if (data)
-	{
-		void*[MAX_BACKTRACE] bt;
-		backtrace::capture_current(&bt);
-		self.map.set((uptr)data, { data, size, bt });
-    	self.mem_total += size;
-		self.allocs_total++;
-	}
 	return data;
 }

-fn void*! TrackingAllocator.resize(&self, void* old_pointer, usz size, usz alignment, usz offset) @dynamic
+fn void*! TrackingAllocator.resize(&self, void* old_pointer, usz size, usz alignment) @dynamic
 {
-	void* data = self.inner_allocator.resize(old_pointer, size, alignment, offset)!;
-	if (old_pointer)
-	{
-		self.map.remove((uptr)old_pointer);
-	}
-	if (data)
-	{
-		void*[MAX_BACKTRACE] bt;
-		backtrace::capture_current(&bt);
-		self.map.set((uptr)data, { data, size, bt });
-    	self.mem_total += size;
-		self.allocs_total++;
-	}
+	void* data = self.inner_allocator.resize(old_pointer, size, alignment)!;
+	self.map.remove((uptr)old_pointer);
+	void*[MAX_BACKTRACE] bt;
+	backtrace::capture_current(&bt);
+	self.map.set((uptr)data, { data, size, bt });
+    self.mem_total += size;
+	self.allocs_total++;
 	return data;
 }

 fn void TrackingAllocator.release(&self, void* old_pointer, bool is_aligned) @dynamic
 {
-	if (old_pointer)
-	{
-		if (catch self.map.remove((uptr)old_pointer))
-    	{
-    	    assert(false, "Attempt to release untracked pointer %p, this is likely a bug.", old_pointer);
-    	}
-	}
+	if (catch self.map.remove((uptr)old_pointer))
+    {
+        unreachable("Attempt to release untracked pointer %p, this is likely a bug.", old_pointer);
+    }
 	self.inner_allocator.release(old_pointer, is_aligned);
 }

@@ -132,7 +119,7 @@ fn void TrackingAllocator.clear(&self)

 fn void TrackingAllocator.print_report(&self) => self.fprint_report(io::stdout())!!;

-fn void! TrackingAllocator.fprint_report(&self, OutStream* out)
+fn void! TrackingAllocator.fprint_report(&self, OutStream out)
 {

 	usz total = 0;
@@ -168,7 +155,7 @@ fn void! TrackingAllocator.fprint_report(&self, OutStream* out)
 					Backtrace trace = backtrace::BACKTRACE_UNKNOWN;
 					if (allocation.backtrace[3])
 					{
-						trace = backtrace::symbolize_backtrace(allocation.backtrace[3:1], mem::temp()).get(0) ?? backtrace::BACKTRACE_UNKNOWN;
+						trace = backtrace::symbolize_backtrace(allocation.backtrace[3:1], allocator::temp()).get(0) ?? backtrace::BACKTRACE_UNKNOWN;
 					}
 					if (trace.function.len)	leaks = true;
 					io::fprintfn(out, "%13s   %p   %s:%d", allocation.size,
@@ -207,7 +194,7 @@ fn void! TrackingAllocator.fprint_report(&self, OutStream* out)
                	    break;
 					}
 				}
-        		BacktraceList list = backtrace::symbolize_backtrace(allocation.backtrace[3..(end - 1)], mem::temp())!;
+        		BacktraceList list = backtrace::symbolize_backtrace(allocation.backtrace[3..(end - 1)], allocator::temp())!;
                io::fprintfn(out, "Allocation %d (%d bytes): ", i + 1, allocation.size)!;
        		foreach (trace : list)
        		{
--- a/lib/std/core/array.c3
+++ b/lib/std/core/array.c3
@@ -1,4 +1,5 @@
 module std::core::array;
+import std::core::array::slice;

 /**
 * @param [in] array
@@ -15,6 +16,19 @@ macro index_of(array, element)
 	return SearchResult.MISSING?;
 }

+/**
+ * @require @typekind(array) == VECTOR || @typekind(array) == ARRAY
+ * @require @typekind(array[0]) == VECTOR || @typekind(array[0]) == ARRAY
+ **/
+macro slice2d(array, x = 0, xlen = 0, y = 0, ylen = 0)
+{
+	if (xlen < 1) xlen = $typeof(array[0]).len + xlen;
+	if (ylen < 1) ylen = $typeof(array).len + ylen;
+	var $ElementType = $typeof(array[0][0]);
+	return Slice2d(<$ElementType>) { ($ElementType*)&array, $typeof(array[0]).len, y, ylen, x, xlen };
+}
+
+
 /**
 * @param [in] array
 * @param [in] element
@@ -31,20 +45,20 @@ macro rindex_of(array, element)
 }

 /**
- * Concatenate two arrays or subarrays, returning a subarray containing the concatenation of them.
+ * 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) == SUBARRAY || @typekind(arr1) == ARRAY
- * @require @typekind(arr2) == SUBARRAY || @typekind(arr2) == ARRAY
+ * @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 result.len == arr1.len + arr2.len
 **/
-macro concat_new(arr1, arr2, Allocator* allocator = mem::heap())
+macro concat_new(arr1, arr2, Allocator allocator = allocator::heap())
 {
 	var $Type = $typeof(arr1[0]);
-	$Type[] result = allocator.new_array($Type, arr1.len + arr2.len);
+	$Type[] result = allocator::alloc_array(allocator, $Type, arr1.len + arr2.len);
 	if (arr1.len > 0)
 	{
 		mem::copy(result.ptr, &arr1[0], arr1.len * $Type.sizeof, $Type.alignof, $Type.alignof);
@@ -57,14 +71,77 @@ macro concat_new(arr1, arr2, Allocator* allocator = mem::heap())
 }

 /**
- * Concatenate two arrays or subarrays, returning a subarray containing the concatenation of them,
+ * Concatenate two arrays or slices, returning a slice containing the concatenation of them,
 * allocated using the temp allocator.
 *
 * @param [in] arr1
 * @param [in] arr2
- * @require @typekind(arr1) == SUBARRAY || @typekind(arr1) == ARRAY
- * @require @typekind(arr2) == SUBARRAY || @typekind(arr2) == ARRAY
+ * @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 result.len == arr1.len + arr2.len
 **/
-macro tconcat(arr1, arr2) => concat(arr1, arr2, mem::temp());
+macro tconcat(arr1, arr2) => concat(arr1, arr2, allocator::temp());
+
+module std::core::array::slice(<Type>);
+
+struct Slice2d
+{
+	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);
+		}
+	}
+}
+
+/**
+ * @require idy >= 0 && idy < self.ylen
+ **/
+macro Type[] Slice2d.get(self, usz idy) @operator([])
+{
+	return (self.ptr + self.inner_len * (idy + self.ystart))[self.xstart:self.xlen];
+}
+
+/**
+ * @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/bitorder.c3
+++ b/lib/std/core/bitorder.c3
@@ -88,7 +88,7 @@ bitstruct UInt128LE : uint128 @littleendian
 }

 /**
- * @require is_array_or_sub_of_char(bytes) "argument must be an array, a pointer to an array or a subarray of char"
+ * @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)
@@ -104,7 +104,7 @@ macro read(bytes, $Type)
 }

 /**
- * @require is_arrayptr_or_sub_of_char(bytes) "argument must be a pointer to an array or a subarray of char"
+ * @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)
@@ -144,7 +144,7 @@ macro is_bitorder($Type)
 	$endswitch
 }

-macro bool is_array_or_sub_of_char(bytes)
+macro bool is_array_or_slice_of_char(bytes)
 {
 	$switch (@typekind(bytes))
 	$case POINTER:
@@ -154,7 +154,7 @@ macro bool is_array_or_sub_of_char(bytes)
 			return $Inner2.typeid == char.typeid;
 		$endif
 	$case ARRAY:
-	$case SUBARRAY:
+	$case SLICE:
 		var $Inner = $typefrom($typeof(bytes).inner);
 		return $Inner.typeid == char.typeid;
 	$default:
@@ -162,7 +162,7 @@ macro bool is_array_or_sub_of_char(bytes)
 	$endswitch
 }

-macro bool is_arrayptr_or_sub_of_char(bytes)
+macro bool is_arrayptr_or_slice_of_char(bytes)
 {
 	$switch (@typekind(bytes))
 	$case POINTER:
@@ -171,7 +171,7 @@ macro bool is_arrayptr_or_sub_of_char(bytes)
 			var $Inner2 = $typefrom($Inner.inner);
 			return $Inner2.typeid == char.typeid;
 		$endif
-	$case SUBARRAY:
+	$case SLICE:
 		var $Inner = $typefrom($typeof(bytes).inner);
 		return $Inner.typeid == char.typeid;
 	$default:
--- a/lib/std/core/builtin.c3
+++ b/lib/std/core/builtin.c3
@@ -1,33 +1,25 @@
-// Copyright (c) 2021-2022 Christoffer Lerno and contributors. All rights reserved.
+// Copyright (c) 2021-2024 Christoffer Lerno and contributors. All rights reserved.
 // Use of this source code is governed by the MIT license
 // a copy of which can be found in the LICENSE_STDLIB file.
 module std::core::builtin;
-import libc;
-import std::hash;
+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
-}
+fault IteratorResult { NO_MORE_ELEMENT }

 /**
 * Use `SearchResult` when trying to return a value from some collection but the element is missing.
 **/
-fault SearchResult
-{
-	MISSING
-}
+fault SearchResult { MISSING }

 /**
 * Use `CastResult` when an attempt at conversion fails.
 **/
-fault CastResult
-{
-	TYPE_MISMATCH
-}
+fault CastResult { TYPE_MISMATCH }
+
+def VoidFn = fn void();

 /**
 * Stores a variable on the stack, then restores it at the end of the
@@ -62,7 +54,7 @@ macro void @swap(&a, &b) @builtin
 * @ensure @typeis(return, $Type*)
 * @return! CastResult.TYPE_MISMATCH
 **/
-macro anycast(any* v, $Type) @builtin
+macro anycast(any v, $Type) @builtin
 {
 	if (v.type != $Type.typeid) return CastResult.TYPE_MISMATCH?;
 	return ($Type*)v.ptr;
@@ -75,7 +67,7 @@ fn bool print_backtrace(String message, int backtraces_to_ignore) @if(env::NATIV
 		void*[256] buffer;
 		void*[] backtraces = backtrace::capture_current(&buffer);
 		backtraces_to_ignore++;
-		BacktraceList! backtrace = backtrace::symbolize_backtrace(backtraces, mem::temp());
+		BacktraceList! backtrace = backtrace::symbolize_backtrace(backtraces, allocator::temp());
 		if (catch backtrace) return false;
 		if (backtrace.len() <= backtraces_to_ignore) return false;
 		io::eprint("\nERROR: '");
@@ -84,17 +76,18 @@ fn bool print_backtrace(String message, int backtraces_to_ignore) @if(env::NATIV
 		foreach (i, &trace : backtrace)
        {
            if (i < backtraces_to_ignore) continue;
+            String inline_suffix = trace.is_inline ? " [inline]" : "";
            if (trace.is_unknown())
            {
-				io::eprintn("  in ???");
+				io::eprintfn("  in ???%s", inline_suffix);
 				continue;
 			}
 			if (trace.has_file())
            {
-                io::eprintfn("  in %s (%s:%d) [%s]", trace.function, trace.file, trace.line, trace.object_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]", trace.function, trace.object_file);
+            io::eprintfn("  in %s (source unavailable) [%s]%s", trace.function, trace.object_file, inline_suffix);
 		}
 		return true;
 	};
@@ -127,10 +120,10 @@ PanicFn panic = &default_panic;

 fn void panicf(String fmt, String file, String function, uint line, args...)
 {
-	@stack_mem(512; Allocator* allocator)
+	@stack_mem(512; Allocator allocator)
 	{
 		DString s;
-		s.init_new(.allocator = allocator);
+		s.new_init(.allocator = allocator);
 		s.appendf(fmt, ...args);
 		panic(s.str_view(), file, function, line);
 	};
@@ -143,7 +136,9 @@ fn void panicf(String fmt, String file, String function, uint line, args...)
 **/
 macro void unreachable(String string = "Unreachable statement reached.", ...) @builtin @noreturn
 {
-	panicf(string, $$FILE, $$FUNC, $$LINE, $vasplat());
+	$if env::COMPILER_SAFE_MODE:
+	panicf(string, $$FILE, $$FUNC, $$LINE, $vasplat);
+	$endif;
 	$$unreachable();
 }

@@ -153,10 +148,18 @@ macro void unreachable(String string = "Unreachable statement reached.", ...) @b
 **/
 macro void unsupported(String string = "Unsupported function invoked") @builtin @noreturn
 {
-	panicf(string, $$FILE, $$FUNC, $$LINE, $vasplat());
+	panicf(string, $$FILE, $$FUNC, $$LINE, $vasplat);
 	$$unreachable();
 }

+/**
+ * Unconditionally break into an attached debugger when reached.
+ **/
+macro void breakpoint() @builtin
+{
+	$$breakpoint();
+}
+
 macro any_make(void* ptr, typeid type) @builtin
 {
 	return $$any_make(ptr, type);
@@ -290,12 +293,12 @@ macro @prefetch(void* ptr, PrefetchLocality $locality = VERY_NEAR, bool $write =

 macro swizzle(v, ...) @builtin
 {
-	return $$swizzle(v, $vasplat());
+	return $$swizzle(v, $vasplat);
 }

 macro swizzle2(v, v2, ...) @builtin
 {
-	return $$swizzle2(v, v2, $vasplat());
+	return $$swizzle2(v, v2, $vasplat);
 }

 macro anyfault @catch(#expr) @builtin
@@ -315,6 +318,11 @@ macro char[] @as_char_view(&value) @builtin
 	return ((char*)value)[:$sizeof(*value)];
 }

+macro isz @str_find(String $string, String $needle) @builtin => $$str_find($string, $needle);
+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 uint int.hash(int i) => i;
 macro uint uint.hash(uint i) => i;
 macro uint short.hash(short s) => s;
@@ -331,6 +339,11 @@ macro uint String.hash(String c) => (uint)fnv32a::encode(c);
 macro uint char[].hash(char[] c) => (uint)fnv32a::encode(c);
 macro uint void*.hash(void* ptr) => ((ulong)(uptr)ptr).hash();

+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);
+
 const MAX_FRAMEADDRESS = 128;
 /**
 * @require n >= 0
@@ -615,7 +628,7 @@ macro void* get_returnaddress(int n)
 }

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

 fn void sig_panic(String message)
 {
@@ -663,7 +676,7 @@ fn void install_signal_handler(CInt signal, SignalFunction func) @local
 }

 // Clean this up
-fn void install_signal_handlers() @init(101) @local
+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);
--- a/lib/std/core/builtin_comparison.c3
+++ b/lib/std/core/builtin_comparison.c3
@@ -1,10 +1,10 @@
-// Copyright (c) 2021-2022 Christoffer Lerno and contributors. All rights reserved.
+// Copyright (c) 2021-2024 Christoffer Lerno and contributors. All rights reserved.
 // Use of this source code is governed by the MIT license
 // a copy of which can be found in the LICENSE_STDLIB file.
 module std::core::builtin;

 /**
- * @require types::is_comparable_value(a) && types::is_comparable_value(b)
+ * @require types::@comparable_value(a) && types::@comparable_value(b)
 **/
 macro less(a, b) @builtin
 {
@@ -19,7 +19,7 @@ macro less(a, b) @builtin
 }

 /**
- * @require types::is_comparable_value(a) && types::is_comparable_value(b)
+ * @require types::@comparable_value(a) && types::@comparable_value(b)
 **/
 macro less_eq(a, b) @builtin
 {
@@ -34,7 +34,7 @@ macro less_eq(a, b) @builtin
 }

 /**
- * @require types::is_comparable_value(a) && types::is_comparable_value(b)
+ * @require types::@comparable_value(a) && types::@comparable_value(b)
 **/
 macro greater(a, b) @builtin
 {
@@ -49,7 +49,7 @@ macro greater(a, b) @builtin
 }

 /**
- * @require types::is_comparable_value(a) && types::is_comparable_value(b)
+ * @require types::@comparable_value(a) && types::@comparable_value(b)
 **/
 macro int compare_to(a, b) @builtin
 {
@@ -63,7 +63,7 @@ macro int compare_to(a, b) @builtin
 	$endswitch
 }
 /**
- * @require types::is_comparable_value(a) && types::is_comparable_value(b)
+ * @require types::@comparable_value(a) && types::@comparable_value(b)
 **/
 macro greater_eq(a, b) @builtin
 {
@@ -78,7 +78,7 @@ macro greater_eq(a, b) @builtin
 }

 /**
- * @require types::is_equatable_value(a) && types::is_equatable_value(b) `values must be equatable`
+ * @require types::@equatable_value(a) && types::@equatable_value(b) `values must be equatable`
 **/
 macro bool equals(a, b) @builtin
 {
@@ -97,13 +97,13 @@ macro bool equals(a, b) @builtin
 macro min(x, ...) @builtin
 {
 	$if $vacount == 1:
-		return less(x, $vaarg(0)) ? x : $vaarg(0);
+		return less(x, $vaarg[0]) ? x : $vaarg[0];
 	$else
 		var result = x;
 		$for (var $i = 0; $i < $vacount; $i++)
-			if (less($vaarg($i), result))
+			if (less($vaarg[$i], result))
 			{
-				 result = $vaarg($i);
+				 result = $vaarg[$i];
 			}
 		$endfor
 		return result;
@@ -113,13 +113,13 @@ macro min(x, ...) @builtin
 macro max(x, ...) @builtin
 {
 	$if $vacount == 1:
-		return greater(x, $vaarg(0)) ? x : $vaarg(0);
+		return greater(x, $vaarg[0]) ? x : $vaarg[0];
 	$else
 		var result = x;
 		$for (var $i = 0; $i < $vacount; $i++)
-			if (greater($vaarg($i), result))
+			if (greater($vaarg[$i], result))
 			{
-				 result = $vaarg($i);
+				 result = $vaarg[$i];
 			}
 		$endfor
 		return result;
--- a/lib/std/core/cinterop.c3
+++ b/lib/std/core/cinterop.c3
@@ -1,4 +1,4 @@
-// Copyright (c) 2021 Christoffer Lerno. All rights reserved.
+// Copyright (c) 2021-2024 Christoffer Lerno. All rights reserved.
 // Use of this source code is governed by the MIT license
 // a copy of which can be found in the LICENSE_STDLIB file.
 module std::core::cinterop;
--- a/lib/std/core/conv.c3
+++ b/lib/std/core/conv.c3
@@ -108,14 +108,14 @@ fn usz char32_to_utf8_unsafe(Char32 c, char** output)
 {
 	switch
 	{
-		case c < 0x7f:
+		case c <= 0x7f:
 			(*output)++[0] = (char)c;
 			return 1;
-		case c < 0x7ff:
+		case c <= 0x7ff:
 			(*output)++[0] = (char)(0xC0 | c >> 6);
 			(*output)++[0] = (char)(0x80 | (c & 0x3F));
 			return 2;
-		case c < 0xffff:
+		case c <= 0xffff:
 			(*output)++[0] = (char)(0xE0 | c >> 12);
 			(*output)++[0] = (char)(0x80 | (c >> 6 & 0x3F));
 			(*output)++[0] = (char)(0x80 | (c & 0x3F));
@@ -210,11 +210,11 @@ fn usz utf8len_for_utf32(Char32[] utf32)
 	{
 		switch (true)
 		{
-			case uc < 0x7f:
+			case uc <= 0x7f:
 				len++;
-			case uc < 0x7ff:
+			case uc <= 0x7ff:
 				len += 2;
-			case uc < 0xffff:
+			case uc <= 0xffff:
 				len += 3;
 			default:
 				len += 4;
@@ -237,12 +237,12 @@ fn usz utf8len_for_utf16(Char16[] utf16)
 		Char16 c = utf16[i];
 		if (c & UTF16_SURROGATE_GENERIC_MASK != UTF16_SURROGATE_GENERIC_VALUE)
 		{
-			if (c < 0x7f)
+			if (c <= 0x7f)
 			{
 				len++;
 				continue;
 			}
-			if (c < 0x7ff)
+			if (c <= 0x7ff)
 			{
 				len += 2;
 				continue;
--- a/lib/std/core/dstring.c3
+++ b/lib/std/core/dstring.c3
@@ -8,10 +8,10 @@ const usz MIN_CAPACITY @private = 16;
 /**
 * @require !self.data() "String already initialized"
 **/
-fn DString DString.init_new(&self, usz capacity = MIN_CAPACITY, Allocator* allocator = mem::heap())
+fn DString DString.new_init(&self, usz capacity = MIN_CAPACITY, Allocator allocator = allocator::heap())
 {
 	if (capacity < MIN_CAPACITY) capacity = MIN_CAPACITY;
-	StringData* data = allocator.new(StringData, .end_padding = capacity);
+	StringData* data = allocator::alloc_with_padding(allocator, StringData, capacity)!!;
 	data.allocator = allocator;
 	data.len = 0;
 	data.capacity = capacity;
@@ -21,20 +21,20 @@ fn DString DString.init_new(&self, usz capacity = MIN_CAPACITY, Allocator* alloc
 /**
 * @require !self.data() "String already initialized"
 **/
-fn DString DString.init_temp(&self, usz capacity = MIN_CAPACITY)
+fn DString DString.temp_init(&self, usz capacity = MIN_CAPACITY)
 {
-	self.init_new(capacity, mem::temp()) @inline;
+	self.new_init(capacity, allocator::temp()) @inline;
 	return *self;
 }

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

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

-fn DString new(String c = "", Allocator* allocator = mem::heap())
+fn DString new(String c = "", Allocator allocator = allocator::heap())
 {
 	usz len = c.len;
 	StringData* data = (StringData*)new_with_capacity(len, allocator);
@@ -46,18 +46,68 @@ fn DString new(String c = "", Allocator* allocator = mem::heap())
 	return (DString)data;
 }

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

-fn DString DString.new_concat(self, DString b, Allocator* allocator = mem::heap())
+
+fn void DString.replace_char(self, char ch, char replacement)
+{
+	StringData* data = self.data();
+	foreach (&c : data.chars[:data.len])
+	{
+		if (*c == ch) *c = replacement;
+	}
+}
+
+fn void DString.replace(&self, String needle, String replacement)
+{
+	StringData* data = self.data();
+	usz needle_len = needle.len;
+	if (!data || data.len < needle_len) return;
+	usz replace_len = replacement.len;
+	if (needle_len == 1 && replace_len == 1)
+	{
+		self.replace_char(needle[0], replacement[0]);
+		return;
+	}
+	@pool(data.allocator) {
+		String str = self.tcopy_str();
+		self.clear();
+		usz len = str.len;
+		usz match = 0;
+		foreach (i, c : str)
+		{
+			if (c == needle[match])
+    	    {
+    	        match++;
+    		    if (match == needle_len)
+    		    {
+    			    self.append_chars(replacement);
+    			    match = 0;
+    			    continue;
+    		    }
+    		    continue;
+    		}
+    		if (match > 0)
+    		{
+    		    self.append_chars(str[i - match:match]);
+    		    match = 0;
+    		}
+    		self.append_char(c);
+    	}
+    	if (match > 0) self.append_chars(str[^match:match]);
+	};
+}
+
+fn DString DString.new_concat(self, DString b, Allocator allocator = allocator::heap())
 {
 	DString string;
-	string.init_new(self.len() + b.len(), allocator);
+	string.new_init(self.len() + b.len(), allocator);
 	string.append(self);
 	string.append(b);
 	return string;
 }

-fn DString DString.new_tconcat(self, DString b) => self.new_concat(b, mem::temp());
+fn DString DString.temp_concat(self, DString b) => self.new_concat(b, allocator::temp());

 fn ZString DString.zstr_view(&self)
 {
@@ -146,9 +196,9 @@ fn void DString.append_char32(&self, Char32 c)
 	data.len += n;
 }

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

-fn DString DString.copy(self, Allocator* allocator = null)
+fn DString DString.copy(self, Allocator allocator = null)
 {
 	if (!self)
 	{
@@ -156,32 +206,32 @@ fn DString DString.copy(self, Allocator* allocator = null)
 		return (DString)null;
 	}
 	StringData* data = self.data();
-	if (!allocator) allocator = mem::heap();
+	if (!allocator) allocator = allocator::heap();
 	DString new_string = new_with_capacity(data.capacity, allocator);
 	mem::copy((char*)new_string.data(), (char*)data, StringData.sizeof + data.len);
 	return new_string;
 }

-fn ZString DString.copy_zstr(self, Allocator* allocator = mem::heap())
+fn ZString DString.copy_zstr(self, Allocator allocator = allocator::heap())
 {
 	usz str_len = self.len();
 	if (!str_len)
 	{
-		return (ZString)allocator.calloc(1);
+		return (ZString)allocator::calloc(allocator, 1);
 	}
-	char* zstr = allocator.alloc(str_len + 1);
+	char* zstr = allocator::malloc(allocator, str_len + 1);
 	StringData* data = self.data();
 	mem::copy(zstr, &data.chars, str_len);
 	zstr[str_len] = 0;
 	return (ZString)zstr;
 }

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

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

 fn bool DString.equals(self, DString other_string)
 {
@@ -204,7 +254,7 @@ fn void DString.free(&self)
 	if (!*self) return;
 	StringData* data = self.data();
 	if (!data) return;
-	data.allocator.free(data);
+	allocator::free(data.allocator, data);
 	*self = (DString)null;
 }

@@ -240,7 +290,7 @@ fn void DString.append_chars(&self, String str)
 	data.len += other_len;
 }

-fn Char32[] DString.copy_utf32(&self, Allocator* allocator = mem::heap())
+fn Char32[] DString.copy_utf32(&self, Allocator allocator = allocator::heap())
 {
 	return self.str_view().to_new_utf32(allocator) @inline!!;
 }
@@ -371,21 +421,29 @@ fn void DString.insert_at(&self, usz index, String s)

 fn usz! DString.appendf(&self, String format, args...) @maydiscard
 {
-	Formatter formatter;
-	formatter.init(&out_string_append_fn, self);
-	return formatter.vprintf(format, args);
+	if (!self.data()) self.new_init(format.len + 20);
+	@pool(self.data().allocator)
+	{
+		Formatter formatter;
+		formatter.init(&out_string_append_fn, self);
+		return formatter.vprintf(format, args);
+	};
 }

 fn usz! DString.appendfn(&self, String format, args...) @maydiscard
 {
-	Formatter formatter;
-	formatter.init(&out_string_append_fn, self);
-	usz len = formatter.vprintf(format, args)!;
-	self.append('\n');
-	return len + 1;
+	if (!self.data()) self.new_init(format.len + 20);
+	@pool(self.data().allocator)
+	{
+		Formatter formatter;
+		formatter.init(&out_string_append_fn, self);
+		usz len = formatter.vprintf(format, args)!;
+		self.append('\n');
+		return len + 1;
+	};
 }

-fn DString new_join(String[] s, String joiner, Allocator* allocator = mem::heap())
+fn DString new_join(String[] s, String joiner, Allocator allocator = allocator::heap())
 {
 	if (!s.len) return (DString)null;
 	usz total_size = joiner.len * s.len;
@@ -429,10 +487,10 @@ fn void DString.reserve(&self, usz addition)
 	if (new_capacity < MIN_CAPACITY) new_capacity = MIN_CAPACITY;
 	while (new_capacity < len) new_capacity *= 2;
 	data.capacity = new_capacity;
-	*self = (DString)data.allocator.realloc(data, StringData.sizeof + new_capacity);
+	*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)
 	{
@@ -464,7 +522,7 @@ fn usz! DString.read_from_stream(&self, InStream* reader)

 struct StringData @private
 {
-	Allocator* allocator;
+	Allocator allocator;
 	usz len;
 	usz capacity;
 	char[*] chars;
--- a/lib/std/core/env.c3
+++ b/lib/std/core/env.c3
@@ -1,4 +1,4 @@
-// Copyright (c) 2021 Christoffer Lerno. All rights reserved.
+// Copyright (c) 2021-2024 Christoffer Lerno. All rights reserved.
 // Use of this source code is governed by the MIT license
 // a copy of which can be found in the LICENSE_STDLIB file.
 module std::core::env;
@@ -112,10 +112,13 @@ enum ArchType
 	WASM64,       // WebAssembly with 64-bit pointers
 	RSCRIPT32,    // 32-bit RenderScript
 	RSCRIPT64,    // 64-bit RenderScript
+	XTENSA,       // Xtensa
 }

 const OsType OS_TYPE = (OsType)$$OS_TYPE;
 const ArchType ARCH_TYPE = (ArchType)$$ARCH_TYPE;
+const bool ARCH_32_BIT = $$REGISTER_SIZE == 32;
+const bool ARCH_64_BIT = $$REGISTER_SIZE == 64;
 const bool LIBC = $$COMPILER_LIBC_AVAILABLE;
 const bool NO_LIBC = !$$COMPILER_LIBC_AVAILABLE;
 const CompilerOptLevel COMPILER_OPT_LEVEL = (CompilerOptLevel)$$COMPILER_OPT_LEVEL;
@@ -123,14 +126,17 @@ const bool BIG_ENDIAN = $$PLATFORM_BIG_ENDIAN;
 const bool I128_NATIVE_SUPPORT = $$PLATFORM_I128_SUPPORTED;
 const bool F16_SUPPORT = $$PLATFORM_F16_SUPPORTED;
 const bool F128_SUPPORT = $$PLATFORM_F128_SUPPORTED;
+const REGISTER_SIZE = $$REGISTER_SIZE;
 const bool COMPILER_SAFE_MODE = $$COMPILER_SAFE_MODE;
 const bool DEBUG_SYMBOLS = $$DEBUG_SYMBOLS;
+const bool BACKTRACE = $$BACKTRACE;
 const usz LLVM_VERSION = $$LLVM_VERSION;
 const bool BENCHMARKING = $$BENCHMARKING;
 const bool TESTING = $$TESTING;
 const MemoryEnvironment MEMORY_ENV = (MemoryEnvironment)$$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 LINUX = LIBC && OS_TYPE == LINUX;
@@ -142,8 +148,12 @@ const bool FREEBSD = LIBC && OS_TYPE == FREEBSD;
 const bool NETBSD = LIBC && OS_TYPE == NETBSD;
 const bool WASI = LIBC && OS_TYPE == WASI;
 const bool WASM_NOLIBC @builtin = !LIBC && ARCH_TYPE == ArchType.WASM32 || ARCH_TYPE == ArchType.WASM64;
+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;

-macro bool os_is_darwin()
+macro bool os_is_darwin() @const
 {
 	$switch (OS_TYPE)
 	$case IOS:
@@ -156,7 +166,7 @@ macro bool os_is_darwin()
 	$endswitch
 }

-macro bool os_is_posix()
+macro bool os_is_posix() @const
 {
 	$switch (OS_TYPE)
 	$case IOS:
--- a/lib/std/core/mem.c3
+++ b/lib/std/core/mem.c3
@@ -2,10 +2,16 @@
 // 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;
+import std::core::mem::allocator @public;
+import std::math;

 const MAX_MEMORY_ALIGNMENT = 0x1000_0000;
 const DEFAULT_MEM_ALIGNMENT = (void*.alignof) * 2;

+macro bool @constant_is_power_of_2($x) @const @private
+{
+	return $x != 0 && ($x & ($x - 1)) == 0;
+}

 /**
 * Load a vector from memory according to a mask assuming default alignment.
@@ -35,7 +41,7 @@ macro masked_load(ptr, bool[<*>] mask, passthru)
 * @require $assignable(&&passthru, $typeof(ptr)) : "Pointer and passthru must match"
 * @require @typekind(passthru) == VECTOR : "Expected passthru to be a vector"
 * @require passthru.len == mask.len : "Mask and passthru must have the same length"
- * @require math::is_power_of_2($alignment) : "The alignment must be a power of two"
+ * @require @constant_is_power_of_2($alignment) : "The alignment must be a power of two"
 *
 * @return "A vector with the loaded values where the mask is true, passthru where the mask is false"
 **/
@@ -78,7 +84,7 @@ macro gather(ptrvec, bool[<*>] mask, passthru)
 * @require $assignable(&&passthru[0], $typeof(ptrvec[0])) : "Pointer and passthru must match"
 * @require passthru.len == mask.len : "Mask and passthru must have the same length"
 * @require mask.len == ptrvec.len : "Mask and ptrvec must have the same length"
- * @require math::is_power_of_2($alignment) : "The alignment must be a power of two"
+ * @require @constant_is_power_of_2($alignment) : "The alignment must be a power of two"
 *
 * @return "A vector with the loaded values where the mask is true, passthru where the mask is false"
 **/
@@ -113,7 +119,7 @@ macro masked_store(ptr, value, bool[<*>] mask)
 * @require $assignable(&&value, $typeof(ptr)) : "Pointer and value must match"
 * @require @typekind(value) == VECTOR : "Expected value to be a vector"
 * @require value.len == mask.len : "Mask and value must have the same length"
- * @require math::is_power_of_2($alignment) : "The alignment must be a power of two"
+ * @require @constant_is_power_of_2($alignment) : "The alignment must be a power of two"
 *
 **/
 macro @masked_store_aligned(ptr, value, bool[<*>] mask, usz $alignment)
@@ -148,13 +154,39 @@ macro scatter(ptrvec, value, bool[<*>] mask)
 * @require $assignable(&&value[0], $typeof(ptrvec[0])) : "Pointer and value must match"
 * @require value.len == mask.len : "Mask and value must have the same length"
 * @require mask.len == ptrvec.len : "Mask and ptrvec must have the same length"
- * @require math::is_power_of_2($alignment) : "The alignment must be a power of two"
+ * @require @constant_is_power_of_2($alignment) : "The alignment must be a power of two"
 **/
 macro @scatter_aligned(ptrvec, value, bool[<*>] mask, usz $alignment)
 {
 	return $$scatter(ptrvec, value, mask, $alignment);
 }

+/**
+ * @param [in] x "The variable or dereferenced pointer to load."
+ * @param $alignment "The alignment to assume for the load"
+ * @return "The value of x"
+ *
+ * @require @constant_is_power_of_2($alignment) : "The alignment must be a power of two"
+ **/
+macro @unaligned_load(&x, usz $alignment) @builtin
+{
+	return $$unaligned_load(x, $alignment);
+}
+
+/**
+ * @param [out] x "The variable or dereferenced pointer to store to."
+ * @param value "The value to store."
+ * @param $alignment "The alignment to assume for the store"
+ * @return "The value of x"
+ *
+ * @require $assignable(value, $typeof(*x)) : "The value doesn't match the variable"
+ * @require @constant_is_power_of_2($alignment) : "The alignment must be a power of two"
+ **/
+macro @unaligned_store(&x, value, usz $alignment) @builtin
+{
+	return $$unaligned_store(x, ($typeof(*x))value, $alignment);
+}
+
 macro @volatile_load(&x) @builtin
 {
 	return $$volatile_load(x);
@@ -251,11 +283,12 @@ fn bool ptr_is_aligned(void* ptr, usz alignment) @inline

 macro void clear(void* dst, usz len, usz $dst_align = 0, bool $is_volatile = false, bool $inlined = false)
 {
-	$if $inlined:
-		$$memset_inline(dst, (char)0, len, $is_volatile, $dst_align);
-	$else
-		$$memset(dst, (char)0, len, $is_volatile, $dst_align);
-	$endif
+	$$memset(dst, (char)0, len, $is_volatile, $dst_align);
+}
+
+macro void clear_inline(void* dst, usz $len, usz $dst_align = 0, bool $is_volatile = false)
+{
+	$$memset_inline(dst, (char)0, $len, $is_volatile, $dst_align);
 }

 /**
@@ -267,17 +300,30 @@ macro void clear(void* dst, usz len, usz $dst_align = 0, bool $is_volatile = fal
 * @param $dst_align "the alignment of the destination if different from the default, 0 assumes the default"
 * @param $src_align "the alignment of the destination if different from the default, 0 assumes the default"
 * @param $is_volatile "True if this copy should be treated as volatile, i.e. it can't be optimized away."
- * @param $inlined "True if this copy should never call the OS memcpy."
 *
 * @require len == 0 || dst + len <= src || src + len <= dst : "Ranges may not overlap"
 **/
 macro void copy(void* dst, void* src, usz len, usz $dst_align = 0, usz $src_align = 0, bool $is_volatile = false, bool $inlined = false)
 {
-	$if $inlined:
-		$$memcpy_inline(dst, src, len, $is_volatile, $dst_align, $src_align);
-	$else
-		$$memcpy(dst, src, len, $is_volatile, $dst_align, $src_align);
-	$endif
+	$$memcpy(dst, src, len, $is_volatile, $dst_align, $src_align);
+}
+
+/**
+ * Copy memory from src to dst efficiently, assuming the memory ranges do not overlap, it
+ * will always be inlined and never call memcopy
+ *
+ * @param [&out] dst "The destination to copy to"
+ * @param [&in] src "The source to copy from"
+ * @param $len "The number of bytes to copy"
+ * @param $dst_align "the alignment of the destination if different from the default, 0 assumes the default"
+ * @param $src_align "the alignment of the destination if different from the default, 0 assumes the default"
+ * @param $is_volatile "True if this copy should be treated as volatile, i.e. it can't be optimized away."
+ *
+ * @require $len == 0 || dst + $len <= src || src + $len <= dst : "Ranges may not overlap"
+ **/
+macro void copy_inline(void* dst, void* src, usz $len, usz $dst_align = 0, usz $src_align = 0, bool $is_volatile = false)
+{
+	$$memcpy_inline(dst, src, $len, $is_volatile, $dst_align, $src_align);
 }

 /**
@@ -303,23 +349,33 @@ macro void move(void* dst, void* src, usz len, usz $dst_align = 0, usz $src_alig
 * @param len "The number of bytes to copy"
 * @param $dst_align "the alignment of the destination if different from the default, 0 assumes the default"
 * @param $is_volatile "True if this copy should be treated as volatile, i.e. it can't be optimized away."
- * @param $inlined "True if this copy should never call the OS memset."
 *
 * @ensure !len || (dst[0] == val && dst[len - 1] == val)
 **/
-macro void set(void* dst, char val, usz len, usz $dst_align = 0, bool $is_volatile = false, bool $inlined = false)
+macro void set(void* dst, char val, usz len, usz $dst_align = 0, bool $is_volatile = false)
 {
-	$if $inlined:
-		$$memset_inline(dst, val, len, $is_volatile, $dst_align);
-	$else
-		$$memset(dst, val, len, $is_volatile, $dst_align);
-	$endif
+	$$memset(dst, val, len, $is_volatile, $dst_align);
 }

 /**
- * @require values::@inner_kind(a) == TypeKind.SUBARRAY || values::@inner_kind(a) == TypeKind.POINTER
- * @require values::@inner_kind(b) == TypeKind.SUBARRAY || values::@inner_kind(b) == TypeKind.POINTER
- * @require values::@inner_kind(a) != TypeKind.SUBARRAY || len == -1
+ * Sets all memory in a region to that of the provided byte. Never calls OS memset.
+ *
+ * @param [&out] dst "The destination to copy to"
+ * @param val "The value to copy into memory"
+ * @param $len "The number of bytes to copy"
+ * @param $dst_align "the alignment of the destination if different from the default, 0 assumes the default"
+ * @param $is_volatile "True if this copy should be treated as volatile, i.e. it can't be optimized away."
+ *
+ * @ensure !$len || (dst[0] == val && dst[$len - 1] == val)
+ **/
+macro void set_inline(void* dst, char val, usz $len, usz $dst_align = 0, bool $is_volatile = false)
+{
+	$$memset_inline(dst, val, $len, $is_volatile, $dst_align);
+}
+/**
+ * @require values::@inner_kind(a) == TypeKind.SLICE || values::@inner_kind(a) == TypeKind.POINTER
+ * @require values::@inner_kind(b) == TypeKind.SLICE || values::@inner_kind(b) == TypeKind.POINTER
+ * @require values::@inner_kind(a) != TypeKind.SLICE || len == -1
 * @require values::@inner_kind(a) != TypeKind.POINTER || len > -1
 * @require values::@assign_to(a, b) && values::@assign_to(b, a)
 **/
@@ -330,7 +386,7 @@ macro bool equals(a, b, isz len = -1, usz $align = 0)
 	$endif
 	void* x @noinit;
 	void* y @noinit;
-	$if values::@inner_kind(a) == TypeKind.SUBARRAY:
+	$if values::@inner_kind(a) == TypeKind.SLICE:
 		len = a.len;
 		if (len != b.len) return false;
 		x = a.ptr;
@@ -377,34 +433,34 @@ macro type_alloc_must_be_aligned($Type)
 /**
 * Run with a specific allocator inside of the macro body.
 **/
-macro void @scoped(Allocator* allocator; @body())
+macro void @scoped(Allocator allocator; @body())
 {
-	Allocator* old_allocator = thread_allocator;
-	thread_allocator = allocator;
-	defer thread_allocator = old_allocator;
+	Allocator old_allocator = allocator::thread_allocator;
+	allocator::thread_allocator = allocator;
+	defer allocator::thread_allocator = old_allocator;
 	@body();
 }

 macro void @report_heap_allocs_in_scope(;@body())
 {
 	TrackingAllocator tracker;
-	tracker.init(thread_allocator);
-	Allocator* old_allocator = thread_allocator;
-	thread_allocator = &tracker;
+	tracker.init(allocator::thread_allocator);
+	Allocator old_allocator = allocator::thread_allocator;
+	allocator::thread_allocator = &tracker;
 	defer
 	{
-		thread_allocator = old_allocator;
+		allocator::thread_allocator = old_allocator;
 		tracker.print_report();
 		tracker.free();
 	}
 	@body();
 }

-macro void @stack_mem(usz $size; @body(Allocator* mem)) @builtin
+macro void @stack_mem(usz $size; @body(Allocator mem)) @builtin
 {
 	char[$size] buffer;
 	OnStackAllocator allocator;
-	allocator.init(&buffer, mem::heap());
+	allocator.init(&buffer, allocator::heap());
 	defer allocator.free();
 	@body(&allocator);
 }
@@ -413,7 +469,7 @@ macro void @stack_pool(usz $size; @body) @builtin
 {
 	char[$size] buffer;
 	OnStackAllocator allocator;
-	allocator.init(&buffer, mem::heap());
+	allocator.init(&buffer, allocator::heap());
 	defer allocator.free();
 	mem::@scoped(&allocator)
 	{
@@ -421,79 +477,62 @@ macro void @stack_pool(usz $size; @body) @builtin
 	};
 }

+struct TempState
+{
+	TempAllocator* old;
+	TempAllocator* current;
+	usz mark;
+}
+
+/**
+ * Push the current temp allocator. A push must always be balanced with a pop using the current state.
+ **/
+fn TempState temp_push(TempAllocator* other = null)
+{
+	TempAllocator* current = allocator::temp();
+	TempAllocator* old = current;
+	if (other == current)
+	{
+		current = allocator::temp_allocator_next();
+	}
+	return { old, current, current.used };
+}
+
+/**
+ * Pop the current temp allocator. A pop must always be balanced with a push.
+ **/
+fn void temp_pop(TempState old_state)
+{
+	assert(allocator::thread_temp_allocator == old_state.current, "Tried to pop temp allocators out of order.");
+	assert(old_state.current.used >= old_state.mark, "Tried to pop temp allocators out of order.");
+	old_state.current.reset(old_state.mark);
+	allocator::thread_temp_allocator = old_state.old;
+}
+
 macro void @pool(TempAllocator* #other_temp = null; @body) @builtin
 {
-	TempAllocator* current = temp();
+	TempAllocator* current = allocator::temp();
 	var $has_arg = !$is_const(#other_temp);
 	$if $has_arg:
 		TempAllocator* original = current;
-		if (current == (void*)#other_temp) current = temp_allocator_next();
+		if (current == (void*)#other_temp) current = allocator::temp_allocator_next();
 	$endif
 	usz mark = current.used;
 	defer
 	{
 		current.reset(mark);
 		$if $has_arg:
-			thread_temp_allocator = original;
+			allocator::thread_temp_allocator = original;
 		$endif;
 	}
 	@body();
 }

-tlocal Allocator* thread_allocator @private = &allocator::LIBC_ALLOCATOR;
-tlocal TempAllocator* thread_temp_allocator @private = null;
-tlocal TempAllocator*[2] temp_allocator_pair @private;
-Allocator* temp_base_allocator @private = &allocator::LIBC_ALLOCATOR;
-
-macro TempAllocator* create_default_sized_temp_allocator(Allocator* allocator) @local
-{
-	$switch (env::MEMORY_ENV)
-	$case NORMAL:
-		return allocator::new_temp(1024 * 256, allocator)!!;
-	$case SMALL:
-		return allocator::new_temp(1024 * 16, allocator)!!;
-	$case TINY:
-		return allocator::new_temp(1024 * 2, allocator)!!;
-	$case NONE:
-		unreachable("Temp allocator must explicitly created when memory-env is set to 'none'.");
-	$endswitch
-}
-
-fn TempAllocator *temp_allocator_next() @private
-{
-	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];
-}
-
 import libc;

-fn void init_default_temp_allocators() @private
-{
-	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];
-}
-
-macro TempAllocator* temp()
-{
-	if (!thread_temp_allocator)
-	{
-		init_default_temp_allocators();
-	}
-	return thread_temp_allocator;
-}
-
-macro Allocator* current_allocator() => thread_allocator;
-macro Allocator* heap() => thread_allocator;
-

 module std::core::mem @if(WASM_NOLIBC);
-
+import std::core::mem::allocator @public;
 SimpleHeapAllocator wasm_allocator @private;
 extern int __heap_base;

@@ -504,8 +543,8 @@ fn void initialize_wasm_mem() @init(1) @private
 	uptr start = (uptr)&__heap_base;
 	if (start > mem::DEFAULT_MEM_ALIGNMENT) allocator::wasm_memory.use = start;
 	wasm_allocator.init(fn (x) => allocator::wasm_memory.allocate_block(x));
-	temp_base_allocator = &wasm_allocator;
-	thread_allocator = &wasm_allocator;
+	allocator::thread_allocator = &wasm_allocator;
+	allocator::init_default_temp_allocators();
 }

 module std::core::mem;
@@ -520,88 +559,195 @@ macro TrackingEnv* get_tracking_env()
 	$endif
 }

-macro @clone(value) @builtin
+macro @clone(value) @builtin @nodiscard
 {
-	return mem::heap().clone(value);
+	return allocator::clone(allocator::heap(), value);
 }

-macro @tclone(value) @builtin
+macro @tclone(value) @builtin @nodiscard
 {
-	return mem::temp().clone(value);
+	return temp_new($typeof(value), value);
 }

-fn void* malloc(usz size) @builtin @inline
+fn void* malloc(usz size) @builtin @inline @nodiscard
 {
-	return mem::heap().alloc(size);
+	return allocator::malloc(allocator::heap(), size);
 }

-fn void* tmalloc(usz size, usz alignment = 0, usz offset = 0) @builtin @inline
+/**
+ * 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.
+ **/
+fn void* malloc_aligned(usz size, usz alignment) @builtin @inline @nodiscard
 {
-	return temp().acquire(size, false, alignment, offset)!!;
+	return allocator::malloc_aligned(allocator::heap(), size, alignment)!!;
 }

-macro new($Type)
+fn void* tmalloc(usz size, usz alignment = 0) @builtin @inline @nodiscard
 {
-	return heap().new($Type);
+	if (!size) return null;
+	return allocator::temp().acquire(size, NO_ZERO, alignment)!!;
 }

-macro new_clear($Type)
+/**
+ * @require $vacount < 2 : "Too many arguments."
+ * @require $vacount == 0 ||| $assignable($vaexpr[0], $Type) : "The second argument must be an initializer for the type"
+ * @require $Type.alignof <= DEFAULT_MEM_ALIGNMENT : "Types with alignment exceeding the default must use 'alloc_aligned' instead"
+ **/
+macro new($Type, ...) @nodiscard
 {
-	return heap().new_clear($Type);
+	$if $vacount == 0:
+		return ($Type*)calloc($Type.sizeof);
+	$else
+		$Type* val = malloc($Type.sizeof);
+		*val = $vaexpr[0];
+		return val;
+	$endif
 }

-macro new_temp($Type)
+/**
+ * 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"
+ **/
+macro new_aligned($Type, ...) @nodiscard
+{
+	$if $vacount == 0:
+		return ($Type*)calloc_aligned($Type.sizeof, $Type.alignof);
+	$else
+		$Type* val = malloc_aligned($Type.sizeof, $Type.alignof);
+		*val = $vaexpr[0];
+		return val;
+	$endif
+}
+
+/**
+ * @require $Type.alignof <= DEFAULT_MEM_ALIGNMENT : "Types with alignment exceeding the default must use 'alloc_aligned' instead"
+ **/
+macro alloc($Type) @nodiscard
+{
+	return ($Type*)malloc($Type.sizeof);
+}
+
+/**
+ * Allocate using an aligned allocation. This is necessary for types with a default memory alignment
+ * exceeding DEFAULT_MEM_ALIGNMENT. IMPORTANT! It must be freed using free_aligned.
+ **/
+macro alloc_aligned($Type) @nodiscard
+{
+	return ($Type*)malloc_aligned($Type.sizeof, $Type.alignof);
+}
+
+/**
+ * @require $vacount < 2 : "Too many arguments."
+ * @require $vacount == 0 ||| $assignable($vaexpr[0], $Type) : "The second argument must be an initializer for the type"
+ **/
+macro temp_new($Type, ...) @nodiscard
+{
+	$if $vacount == 0:
+		return ($Type*)tcalloc($Type.sizeof) @inline;
+	$else
+		$Type* val = tmalloc($Type.sizeof) @inline;
+		*val = $vaexpr[0];
+		return val;
+	$endif
+}
+
+macro temp_alloc($Type) @nodiscard
 {
 	return tmalloc($Type.sizeof);
 }

-macro new_temp_clear($Type)
+
+/**
+ * @require $Type.alignof <= DEFAULT_MEM_ALIGNMENT : "Types with alignment exceeding the default must use 'new_array_aligned' instead"
+ **/
+macro new_array($Type, usz elements) @nodiscard
 {
-	return tcalloc($Type.sizeof);
+	return allocator::new_array(allocator::heap(), $Type, elements);
 }

-macro new_array($Type, usz elements)
+/**
+ * Allocate using an aligned allocation. This is necessary for types with a default memory alignment
+ * exceeding DEFAULT_MEM_ALIGNMENT. IMPORTANT! It must be freed using free_aligned.
+ **/
+macro new_array_aligned($Type, usz elements) @nodiscard
 {
-	return heap().new_array($Type, elements);
+	return allocator::new_array_aligned(allocator::heap(), $Type, elements);
 }

-macro temp_array($Type, usz elements)
+/**
+ * @require $Type.alignof <= DEFAULT_MEM_ALIGNMENT : "Types with alignment exceeding the default must use 'alloc_array_aligned' instead"
+ **/
+macro alloc_array($Type, usz elements) @nodiscard
+{
+	return allocator::alloc_array(allocator::heap(), $Type, elements);
+}
+
+/**
+ * Allocate using an aligned allocation. This is necessary for types with a default memory alignment
+ * exceeding DEFAULT_MEM_ALIGNMENT. IMPORTANT! It must be freed using free_aligned.
+ **/
+macro alloc_array_aligned($Type, usz elements) @nodiscard
+{
+	return allocator::alloc_array_aligned(allocator::heap(), $Type, elements);
+}
+
+macro temp_alloc_array($Type, usz elements) @nodiscard
 {
 	return (($Type*)tmalloc($Type.sizeof * elements, $Type.alignof))[:elements];
 }

-macro new_zero_array($Type, usz elements)
-{
-	return heap().new_zero_array($Type, elements);
-}
-
-macro temp_zero_array($Type, usz elements)
+macro temp_new_array($Type, usz elements) @nodiscard
 {
 	return (($Type*)tcalloc($Type.sizeof * elements, $Type.alignof))[:elements];
 }

-fn void* calloc(usz size) @builtin @inline
+fn void* calloc(usz size) @builtin @inline @nodiscard
 {
-	return heap().calloc(size);
+	return allocator::calloc(allocator::heap(), size);
 }

-fn void* tcalloc(usz size, usz alignment = 0, usz offset = 0) @builtin @inline
+/**
+ * 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.
+ **/
+fn void* calloc_aligned(usz size, usz alignment) @builtin @inline @nodiscard
 {
-	return temp().acquire(size, false, alignment, offset)!!;
+	return allocator::calloc_aligned(allocator::heap(), size, alignment)!!;
 }

-fn void* realloc(void *ptr, usz new_size) @builtin @inline
+fn void* tcalloc(usz size, usz alignment = 0) @builtin @inline @nodiscard
 {
-	return heap().realloc(ptr, new_size);
+	if (!size) return null;
+	return allocator::temp().acquire(size, ZERO, alignment)!!;
+}
+
+fn void* realloc(void *ptr, usz new_size) @builtin @inline @nodiscard
+{
+	return allocator::realloc(allocator::heap(), ptr, new_size);
+}
+
+fn void* realloc_aligned(void *ptr, usz new_size, usz alignment) @builtin @inline @nodiscard
+{
+	return allocator::realloc_aligned(allocator::heap(), ptr, new_size, alignment)!!;
 }

 fn void free(void* ptr) @builtin @inline
 {
-	heap().free(ptr);
+	return allocator::free(allocator::heap(), ptr);
 }

-fn void* trealloc(void* ptr, usz size, usz alignment = mem::DEFAULT_MEM_ALIGNMENT) @builtin @inline
+fn void free_aligned(void* ptr) @builtin @inline
 {
-	return temp().resize(ptr, size, alignment, 0)!!;
+	return allocator::free_aligned(allocator::heap(), ptr);
+}
+
+fn void* trealloc(void* ptr, usz size, usz alignment = mem::DEFAULT_MEM_ALIGNMENT) @builtin @inline @nodiscard
+{
+	if (!size) return null;
+    if (!ptr) return tmalloc(size, alignment);
+	return allocator::temp().resize(ptr, size, alignment)!!;
 }

--- a/lib/std/core/mem_allocator.c3
+++ b/lib/std/core/mem_allocator.c3
@@ -10,88 +10,35 @@ struct TrackingEnv
 	uint line;
 }

+enum AllocInitType
+{
+	NO_ZERO,
+	ZERO
+}

 interface Allocator
 {
 	fn void reset(usz mark) @optional;
 	fn usz mark() @optional;
-	fn void*! acquire(usz size, bool clear, usz alignment, usz offset);
-	fn void*! resize(void* ptr, usz new_size, usz alignment, usz offset);
+	/**
+     * @require !alignment || math::is_power_of_2(alignment)
+     * @require alignment <= mem::MAX_MEMORY_ALIGNMENT `alignment too big`
+     * @require size > 0
+     **/
+	fn void*! acquire(usz size, AllocInitType init_type, usz alignment = 0);
+	/**
+     * @require !alignment || math::is_power_of_2(alignment)
+     * @require alignment <= mem::MAX_MEMORY_ALIGNMENT `alignment too big`
+     * @require ptr != null
+     * @require new_size > 0
+     **/
+	fn void*! resize(void* ptr, usz new_size, usz alignment = 0);
+	/**
+     * @require ptr != null
+     **/
 	fn void release(void* ptr, bool aligned);
 }

-struct AlignedBlock
-{
-	usz len;
-	void* start;
-}
-
-/**
- * @require bytes > 0
- * @require alignment > 0
- **/
-macro void*! @aligned_alloc(#alloc_fn, usz bytes, usz alignment, usz offset)
-{
-	usz header = mem::aligned_offset(AlignedBlock.sizeof + offset, alignment) - offset;
-	$if @typekind(#alloc_fn(bytes)) == OPTIONAL:
-		void* data = #alloc_fn(header + bytes)!;
-	$else
-		void* data = #alloc_fn(header + bytes);
-	$endif
-	void* mem = mem::aligned_pointer(data + header + offset, alignment) - offset;
-	assert(mem > data);
-	AlignedBlock* desc = (AlignedBlock*)mem - 1;
-	*desc = { bytes, data };
-	return mem;
-}
-
-/**
- * @require bytes > 0
- * @require alignment > 0
- **/
-macro void*! @aligned_calloc(#calloc_fn, usz bytes, usz alignment, usz offset)
-{
-	usz header = mem::aligned_offset(AlignedBlock.sizeof + offset, alignment) - offset;
-	$if @typekind(#calloc_fn(bytes)) == OPTIONAL:
-		void* data = #calloc_fn(header + bytes)!;
-	$else
-		void* data = #calloc_fn(header + bytes);
-	$endif
-	void* mem = mem::aligned_pointer(data + header + offset, alignment) - offset;
-	AlignedBlock* desc = (AlignedBlock*)mem - 1;
-	assert(mem > data);
-	*desc = { bytes, data };
-	return mem;
-}
-
-/**
- * @require bytes > 0
- * @require alignment > 0
- **/
-macro void*! @aligned_realloc(#calloc_fn, #free_fn, void* old_pointer, usz bytes, usz alignment, usz offset)
-{
-	AlignedBlock* desc = (AlignedBlock*)old_pointer - 1;
-	void* data_start = desc.start;
-	void* new_data = @aligned_calloc(#calloc_fn, bytes, alignment, offset)!;
-	mem::copy(new_data, old_pointer, desc.len < bytes ? desc.len : bytes, mem::DEFAULT_MEM_ALIGNMENT, mem::DEFAULT_MEM_ALIGNMENT);
-	$if @typekind(#free_fn(data_start)) == OPTIONAL:
-	#free_fn(data_start)!;
-	$else
-	#free_fn(data_start);
-	$endif
-	return new_data;
-}
-
-macro void! @aligned_free(#free_fn, void* old_pointer)
-{
-	AlignedBlock* desc = (AlignedBlock*)old_pointer - 1;
-	$if @typekind(#free_fn(desc.start)) == OPTIONAL:
-	#free_fn(desc.start)!;
-	$else
-	#free_fn(desc.start);
-	$endif
-}
-
 def MemoryAllocFn = fn char[]!(usz);

 fault AllocationFailure
@@ -102,123 +49,376 @@ fault AllocationFailure

 fn usz alignment_for_allocation(usz alignment) @inline @private
 {
-	return alignment < mem::DEFAULT_MEM_ALIGNMENT ? alignment = mem::DEFAULT_MEM_ALIGNMENT : alignment;
+	return alignment < mem::DEFAULT_MEM_ALIGNMENT ? mem::DEFAULT_MEM_ALIGNMENT : alignment;
 }

-// Allocator "functions"
-
-macro void*! Allocator.alloc_checked(&self, usz size)
+macro void* malloc(Allocator allocator, usz size) @nodiscard
 {
+	return malloc_try(allocator, size)!!;
+}
+
+macro void*! malloc_try(Allocator allocator, usz size) @nodiscard
+{
+	if (!size) return null;
 	$if env::TESTING:
-		char* data = self.acquire(size, false, 0, 0)!;
+		char* data = allocator.acquire(size, NO_ZERO)!;
 		mem::set(data, 0xAA, size, mem::DEFAULT_MEM_ALIGNMENT);
 		return data;
 	$else
-		return self.acquire(size, false, 0, 0);
+		return allocator.acquire(size, NO_ZERO);
 	$endif
 }

-macro void*! Allocator.calloc_checked(&self, usz size)
+macro void* calloc(Allocator allocator, usz size) @nodiscard
 {
-	return self.acquire(size, true, 0, 0);
-}
-macro void*! Allocator.realloc_checked(&self, void* ptr, usz new_size)
-{
-	return self.resize(ptr, new_size, 0, 0);
+	return calloc_try(allocator, size)!!;
 }

-macro Allocator.new_array(&self, $Type, usz size, usz end_padding = 0)
+macro void*! calloc_try(Allocator allocator, usz size) @nodiscard
 {
-	return (($Type*)self.alloc_checked($Type.sizeof * size + end_padding))[:size]!!;
+	if (!size) return null;
+	return allocator.acquire(size, ZERO);
 }

-macro Allocator.new_array_checked(&self, $Type, usz size, usz end_padding = 0)
+macro void* realloc(Allocator allocator, void* ptr, usz new_size) @nodiscard
 {
-	return (($Type*)self.alloc_checked($Type.sizeof * size + end_padding))[:size];
+	return realloc_try(allocator, ptr, new_size)!!;
 }

-macro Allocator.new_zero_array(&self, $Type, usz size, usz end_padding = 0)
+macro void*! realloc_try(Allocator allocator, void* ptr, usz new_size) @nodiscard
 {
-	return (($Type*)self.calloc_checked($Type.sizeof * size + end_padding))[:size]!!;
+	if (!new_size)
+	{
+		free(allocator, ptr);
+		return null;
+	}
+	if (!ptr) return allocator.acquire(new_size, NO_ZERO);
+	return allocator.resize(ptr, new_size);
 }

-macro Allocator.new_zero_array_checked(&self, $Type, usz size, usz end_padding = 0)
-{
-	return (($Type*)self.calloc_checked($Type.sizeof * size + end_padding))[:size];
-}
-
-macro Allocator.new(&self, $Type, usz end_padding = 0) @nodiscard
-{
-	return ($Type*)self.alloc_checked($Type.sizeof + end_padding)!!;
-}
-
-macro Allocator.new_checked(&self, $Type, usz end_padding = 0) @nodiscard
-{
-	return ($Type*)self.alloc_checked($Type.sizeof + end_padding);
-}
-
-macro Allocator.new_clear(&self, $Type, usz end_padding = 0) @nodiscard
-{
-	return ($Type*)self.calloc_checked($Type.sizeof + end_padding)!!;
-}
-
-macro Allocator.new_clear_checked(&self, $Type, usz end_padding = 0) @nodiscard
-{
-	return ($Type*)self.calloc_checked($Type.sizeof + end_padding);
-}
-
-macro Allocator.clone(&self, value)
-{
-	var x = self.alloc($typeof(value));
-	*x = value;
-	return x;
-}
-
-macro void* Allocator.alloc(&self, usz size) @nodiscard
-{
-	return self.alloc_checked(size)!!;
-}
-macro void* Allocator.calloc(&self, usz size) @nodiscard
-{
-	return self.acquire(size, true, 0, 0)!!;
-}
-macro void* Allocator.realloc(&self, void* ptr, usz new_size) @nodiscard
-{
-	return self.resize(ptr, new_size, 0, 0)!!;
-}
-
-macro void*! Allocator.alloc_aligned(&self, usz size, usz alignment, usz offset = 0)
+macro void free(Allocator allocator, void* ptr)
 {
+	if (!ptr) return;
 	$if env::TESTING:
-		char* data = self.acquire(size, false, alignment, offset)!;
+		((char*)ptr)[0] = 0xBA;
+	$endif
+	allocator.release(ptr, false);
+}
+
+macro void*! malloc_aligned(Allocator allocator, usz size, usz alignment) @nodiscard
+{
+	if (!size) return null;
+	$if env::TESTING:
+		char* data = allocator.acquire(size, NO_ZERO, alignment)!;
 		mem::set(data, 0xAA, size, mem::DEFAULT_MEM_ALIGNMENT);
 		return data;
 	$else
-		return self.acquire(size, false, alignment, offset);
+		return allocator.acquire(size, NO_ZERO, alignment);
 	$endif
 }
-macro void*! Allocator.calloc_aligned(&self, usz size, usz alignment, usz offset = 0)
+
+macro void*! calloc_aligned(Allocator allocator, usz size, usz alignment) @nodiscard
 {
-	return self.acquire(size, true, alignment, offset);
-}
-macro void*! Allocator.realloc_aligned(&self, void* ptr, usz new_size, usz alignment = 0, usz offset = 0)
-{
-	return self.resize(ptr, new_size, alignment, offset);
+	if (!size) return null;
+	return allocator.acquire(size, ZERO, alignment);
 }

-macro void Allocator.free(&self, void* ptr)
+macro void*! realloc_aligned(Allocator allocator, void* ptr, usz new_size, usz alignment) @nodiscard
 {
+	if (!new_size)
+	{
+		free_aligned(allocator, ptr);
+		return null;
+	}
+	if (!ptr)
+	{
+		return malloc_aligned(allocator, new_size, alignment);
+	}
+	return allocator.resize(ptr, new_size, alignment);
+}
+
+macro void free_aligned(Allocator allocator, void* ptr)
+{
+	if (!ptr) return;
 	$if env::TESTING:
-		if (ptr) ((char*)ptr)[0] = 0xBA;
+	((char*)ptr)[0] = 0xBA;
 	$endif
-	self.release(ptr, false);
+	allocator.release(ptr, .aligned = true);
 }
-macro void Allocator.free_aligned(&self, 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"
+ **/
+macro new(Allocator allocator, $Type, ...) @nodiscard
 {
-	$if env::TESTING:
-		if (ptr) ((char*)ptr)[0] = 0xBA;
+	$if $vacount == 0:
+		return ($Type*)calloc(allocator, $Type.sizeof);
+	$else
+		$Type* val = malloc(allocator, $Type.sizeof);
+		*val = $vaexpr[0];
+		return val;
 	$endif
-	self.release(ptr, true);
+}
+
+/**
+ * @require $Type.alignof <= mem::DEFAULT_MEM_ALIGNMENT : "Types with alignment exceeding the default must use 'new_aligned' instead"
+ * @require $vacount < 2 : "Too many arguments."
+ * @require $vacount == 0 ||| $assignable($vaexpr[0], $Type) : "The second argument must be an initializer for the type"
+ **/
+macro new_try(Allocator allocator, $Type, ...) @nodiscard
+{
+	$if $vacount == 0:
+		return ($Type*)calloc_try(allocator, $Type.sizeof);
+	$else
+		$Type* val = malloc_try(allocator, $Type.sizeof)!;
+		*val = $vaexpr[0];
+		return val;
+	$endif
+}
+
+/**
+ * Allocate using an aligned allocation. This is necessary for types with a default memory alignment
+ * exceeding DEFAULT_MEM_ALIGNMENT. IMPORTANT! It must be freed using free_aligned.
+ * @require $vacount < 2 : "Too many arguments."
+ * @require $vacount == 0 ||| $assignable($vaexpr[0], $Type) : "The second argument must be an initializer for the type"
+ **/
+macro new_aligned($Type, ...) @nodiscard
+{
+	$if $vacount == 0:
+		return ($Type*)calloc_aligned(allocator, $Type.sizeof, $Type.alignof);
+	$else
+		$Type* val = malloc_aligned(allocator, $Type.sizeof, $Type.alignof);
+		*val = $vaexpr[0];
+		return val;
+	$endif
+}
+
+/**
+ * @require $Type.alignof <= mem::DEFAULT_MEM_ALIGNMENT
+ **/
+macro new_with_padding(Allocator allocator, $Type, usz padding) @nodiscard
+{
+	return ($Type*)calloc_try(allocator, $Type.sizeof + padding);
+}
+
+/**
+ * @require $Type.alignof <= mem::DEFAULT_MEM_ALIGNMENT : "Types with alignment exceeding the default must use 'alloc_aligned' instead"
+ **/
+macro alloc(Allocator allocator, $Type) @nodiscard
+{
+	return ($Type*)malloc(allocator, $Type.sizeof);
+}
+
+/**
+ * @require $Type.alignof <= mem::DEFAULT_MEM_ALIGNMENT : "Types with alignment exceeding the default must use 'alloc_aligned' instead"
+ **/
+macro alloc_try(Allocator allocator, $Type) @nodiscard
+{
+	return ($Type*)malloc_try(allocator, $Type.sizeof);
+}
+
+/**
+ * Allocate using an aligned allocation. This is necessary for types with a default memory alignment
+ * exceeding DEFAULT_MEM_ALIGNMENT. IMPORTANT! It must be freed using free_aligned.
+ **/
+macro alloc_aligned(Allocator allocator, $Type) @nodiscard
+{
+	return ($Type*)malloc_aligned(allocator, $Type.sizeof, $Type.alignof);
+}
+
+/**
+ * @require $Type.alignof <= mem::DEFAULT_MEM_ALIGNMENT
+ **/
+macro alloc_with_padding(Allocator allocator, $Type, usz padding) @nodiscard
+{
+	return ($Type*)malloc_try(allocator, $Type.sizeof + padding);
+}
+
+/**
+ * @require $Type.alignof <= mem::DEFAULT_MEM_ALIGNMENT : "Types with alignment exceeding the default must use 'new_array_aligned' instead"
+ **/
+macro new_array(Allocator allocator, $Type, usz elements) @nodiscard
+{
+	return new_array_try(allocator, $Type, elements)!!;
+}
+
+/**
+ * @require $Type.alignof <= mem::DEFAULT_MEM_ALIGNMENT : "Types with alignment exceeding the default must use 'new_array_aligned' instead"
+ **/
+macro new_array_try(Allocator allocator, $Type, usz elements) @nodiscard
+{
+	return (($Type*)calloc_try(allocator, $Type.sizeof * elements))[:elements];
+}
+
+/**
+ * Allocate using an aligned allocation. This is necessary for types with a default memory alignment
+ * exceeding DEFAULT_MEM_ALIGNMENT. IMPORTANT! It must be freed using free_aligned.
+ **/
+macro new_array_aligned(Allocator allocator, $Type, usz elements) @nodiscard
+{
+	return (($Type*)calloc_aligned(allocator, $Type.sizeof * elements, $Type.alignof))[:elements]!!;
+}
+
+/**
+ * @require $Type.alignof <= mem::DEFAULT_MEM_ALIGNMENT : "Types with alignment exceeding the default must use 'alloc_array_aligned' instead"
+ **/
+macro alloc_array(Allocator allocator, $Type, usz elements) @nodiscard
+{
+	return alloc_array_try(allocator, $Type, elements)!!;
+}
+
+/**
+ * Allocate using an aligned allocation. This is necessary for types with a default memory alignment
+ * exceeding DEFAULT_MEM_ALIGNMENT. IMPORTANT! It must be freed using free_aligned.
+ **/
+macro alloc_array_aligned(Allocator allocator, $Type, usz elements) @nodiscard
+{
+	return (($Type*)malloc_aligned(allocator, $Type.sizeof * elements, $Type.alignof))[:elements]!!;
+}
+
+/**
+ * @require $Type.alignof <= mem::DEFAULT_MEM_ALIGNMENT : "Types with alignment exceeding the default must use 'alloc_array_aligned' instead"
+ **/
+macro alloc_array_try(Allocator allocator, $Type, usz elements) @nodiscard
+{
+	return (($Type*)malloc_try(allocator, $Type.sizeof * elements))[:elements];
+}
+
+macro clone(Allocator allocator, value) @nodiscard
+{
+	return new(allocator, $typeof(value), value);
+}
+
+fn any clone_any(Allocator allocator, any value) @nodiscard
+{
+	usz size = value.type.sizeof;
+	void* data = malloc(allocator, size);
+	mem::copy(data, value.ptr, size);
+	return any_make(data, value.type);
 }


+/**
+ * @require bytes > 0
+ * @require alignment > 0
+ * @require bytes <= isz.max
+ **/
+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:
+		void* data = #alloc_fn(alignsize)!;
+	$else
+		void* data = #alloc_fn(alignsize);
+	$endif
+	void* mem = mem::aligned_pointer(data + AlignedBlock.sizeof, alignment);
+	AlignedBlock* desc = (AlignedBlock*)mem - 1;
+	assert(mem > data);
+	*desc = { bytes, data };
+	return mem;
+}
+
+struct AlignedBlock
+{
+	usz len;
+	void* start;
+}
+
+macro void! @aligned_free(#free_fn, void* old_pointer)
+{
+	AlignedBlock* desc = (AlignedBlock*)old_pointer - 1;
+	$if @typekind(#free_fn(desc.start)) == OPTIONAL:
+	#free_fn(desc.start)!;
+	$else
+	#free_fn(desc.start);
+	$endif
+}
+
+/**
+ * @require bytes > 0
+ * @require alignment > 0
+ **/
+macro void*! @aligned_realloc(#calloc_fn, #free_fn, void* old_pointer, usz bytes, usz alignment)
+{
+	AlignedBlock* desc = (AlignedBlock*)old_pointer - 1;
+	void* data_start = desc.start;
+	void* new_data = @aligned_alloc(#calloc_fn, bytes, alignment)!;
+	mem::copy(new_data, old_pointer, desc.len < bytes ? desc.len : bytes, 1, 1);
+	$if @typekind(#free_fn(data_start)) == OPTIONAL:
+	#free_fn(data_start)!;
+	$else
+	#free_fn(data_start);
+	$endif
+	return new_data;
+}
+
+
+// All allocators
+tlocal Allocator thread_allocator @private = &allocator::LIBC_ALLOCATOR;
+tlocal TempAllocator* thread_temp_allocator @private = null;
+tlocal TempAllocator*[2] temp_allocator_pair @private;
+Allocator temp_base_allocator @private = &allocator::LIBC_ALLOCATOR;
+
+macro TempAllocator* create_default_sized_temp_allocator(Allocator allocator) @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'.");
+	$endswitch
+}
+
+macro Allocator heap() => thread_allocator;
+
+macro TempAllocator* temp()
+{
+	if (!thread_temp_allocator)
+	{
+		init_default_temp_allocators();
+	}
+	return thread_temp_allocator;
+}
+
+fn void init_default_temp_allocators() @private
+{
+	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];
+}
+
+fn void destroy_temp_allocators_after_exit() @finalizer(65535) @local @if(env::LIBC)
+{
+	destroy_temp_allocators();
+}
+
+/**
+ * Call this to destroy any memory used by the temp allocators. This will invalidate all temp memory.
+ **/
+fn void destroy_temp_allocators()
+{
+	if (!thread_temp_allocator) return;
+	temp_allocator_pair[0].destroy();
+	temp_allocator_pair[1].destroy();
+	temp_allocator_pair[..] = null;
+	thread_temp_allocator = null;
+}
+
+fn TempAllocator* temp_allocator_next() @private
+{
+	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];
+}
--- a/lib/std/core/private/cpu_detect.c3
+++ b/lib/std/core/private/cpu_detect.c3
@@ -0,0 +1,258 @@
+module std::core::cpudetect @if(env::X86 || env::X86_64);
+
+struct CpuId
+{
+	uint eax, ebx, ecx, edx;
+}
+fn CpuId x86_cpuid(uint eax, uint ecx = 0)
+{
+	int edx;
+	int ebx;
+	asm
+	{
+		movl $eax, eax;
+		movl $ecx, ecx;
+		cpuid;
+		movl eax, $eax;
+		movl ebx, $ebx;
+		movl ecx, $ecx;
+		movl edx, $edx;
+	}
+	return { eax, ebx, ecx, edx };
+}
+
+enum X86Feature
+{
+	ADX,
+	AES,
+	AMX_BF16,
+	AMX_COMPLEX,
+	AMX_FP16,
+	AMX_INT8,
+	AMX_TILE,
+	AVX,
+	AVX10_1_256,
+	AVX10_1_512,
+	AVX2,
+	AVX5124FMAPS,
+	AVX5124VNNIW,
+	AVX512BF16,
+	AVX512BITALG,
+	AVX512BW,
+	AVX512CD,
+	AVX512DQ,
+	AVX512ER,
+	AVX512F,
+	AVX512FP16,
+	AVX512IFMA,
+	AVX512PF,
+	AVX512VBMI,
+	AVX512VBMI2,
+	AVX512VL,
+	AVX512VNNI,
+	AVX512VP2INTERSECT,
+	AVX512VPOPCNTDQ,
+	AVXIFMA,
+	AVXNECONVERT,
+	AVXVNNI,
+	AVXVNNIINT16,
+	AVXVNNIINT8,
+	BMI,
+	BMI2,
+	CLDEMOTE,
+	CLFLUSHOPT,
+	CLWB,
+	CLZERO,
+	CMOV,
+	CMPCCXADD,
+	CMPXCHG16B,
+	CX8,
+	ENQCMD,
+	F16C,
+	FMA,
+	FMA4,
+	FSGSBASE,
+	FXSR,
+	GFNI,
+	HRESET,
+	INVPCID,
+	KL,
+	LWP,
+	LZCNT,
+	MMX,
+	MOVBE,
+	MOVDIR64B,
+	MOVDIRI,
+	MWAITX,
+	PCLMUL,
+	PCONFIG,
+	PKU,
+	POPCNT,
+	PREFETCHI,
+	PREFETCHWT1,
+	PRFCHW,
+	PTWRITE,
+	RAOINT,
+	RDPID,
+	RDPRU,
+	RDRND,
+	RDSEED,
+	RTM,
+	SAHF,
+	SERIALIZE,
+	SGX,
+	SHA,
+	SHA512,
+	SHSTK,
+	SM3,
+	SM4,
+	SSE,
+	SSE2,
+	SSE3,
+	SSE4_1,
+	SSE4_2,
+	SSE4_A,
+	SSSE3,
+	TBM,
+	TSXLDTRK,
+	UINTR,
+	USERMSR,
+	VAES,
+	VPCLMULQDQ,
+	WAITPKG,
+	WBNOINVD,
+	WIDEKL,
+	X87,
+	XOP,
+	XSAVE,
+	XSAVEC,
+	XSAVEOPT,
+	XSAVES,
+}
+
+uint128 x86_features;
+
+fn void add_feature_if_bit(X86Feature feature, uint register, int bit)
+{
+	if (register & 1U << bit) x86_features |= 1u128 << feature.ordinal;
+}
+
+fn void x86_initialize_cpu_features()
+{
+	uint max_level = x86_cpuid(0).eax;
+	CpuId feat = x86_cpuid(1);
+	CpuId leaf7 = max_level >= 8 ? x86_cpuid(7) : CpuId {};
+	CpuId leaf7s1 = leaf7.eax >= 1 ? x86_cpuid(7, 1) : CpuId {};
+	CpuId ext1 = x86_cpuid(0x80000000).eax >= 0x80000001 ? x86_cpuid(0x80000001) : CpuId {};
+	CpuId ext8 = x86_cpuid(0x80000000).eax >= 0x80000008 ? x86_cpuid(0x80000008) : CpuId {};
+	CpuId leaf_d = max_level >= 0xd ? x86_cpuid(0xd, 0x1) : CpuId {};
+	CpuId leaf_14 = max_level >= 0x14 ? x86_cpuid(0x14) : CpuId {};
+	CpuId leaf_19 = max_level >= 0x19 ? x86_cpuid(0x19) : CpuId {};
+	CpuId leaf_24 = max_level >= 0x24 ? x86_cpuid(0x24) : CpuId {};
+	add_feature_if_bit(ADX, leaf7.ebx, 19);
+	add_feature_if_bit(AES, feat.ecx, 25);
+	add_feature_if_bit(AMX_BF16, leaf7.edx, 22);
+	add_feature_if_bit(AMX_COMPLEX, leaf7s1.edx, 8);
+	add_feature_if_bit(AMX_FP16, leaf7s1.eax, 21);
+	add_feature_if_bit(AMX_INT8, leaf7.edx, 25);
+	add_feature_if_bit(AMX_TILE, leaf7.edx, 24);
+	add_feature_if_bit(AVX, feat.ecx, 28);
+	add_feature_if_bit(AVX10_1_256, leaf7s1.edx, 19);
+	add_feature_if_bit(AVX10_1_512, leaf_24.ebx, 18);
+	add_feature_if_bit(AVX2, leaf7.ebx, 5);
+	add_feature_if_bit(AVX5124FMAPS, leaf7.edx, 3);
+	add_feature_if_bit(AVX5124VNNIW, leaf7.edx, 2);
+	add_feature_if_bit(AVX512BF16, leaf7s1.eax, 5);
+	add_feature_if_bit(AVX512BITALG, leaf7.ecx, 12);
+	add_feature_if_bit(AVX512BW, leaf7.ebx, 30);
+	add_feature_if_bit(AVX512CD, leaf7.ebx, 28);
+	add_feature_if_bit(AVX512DQ, leaf7.ebx, 17);
+	add_feature_if_bit(AVX512ER, leaf7.ebx, 27);
+	add_feature_if_bit(AVX512F, leaf7.ebx, 16);
+	add_feature_if_bit(AVX512FP16, leaf7.edx, 23);
+	add_feature_if_bit(AVX512IFMA, leaf7.ebx, 21);
+	add_feature_if_bit(AVX512PF, leaf7.ebx, 26);
+	add_feature_if_bit(AVX512VBMI, leaf7.ecx, 1);
+	add_feature_if_bit(AVX512VBMI2, leaf7.ecx, 6);
+	add_feature_if_bit(AVX512VL, leaf7.ebx, 31);
+	add_feature_if_bit(AVX512VNNI, leaf7.ecx, 11);
+	add_feature_if_bit(AVX512VP2INTERSECT, leaf7.edx, 8);
+	add_feature_if_bit(AVX512VPOPCNTDQ, leaf7.ecx, 14);
+	add_feature_if_bit(AVXIFMA, leaf7s1.eax, 23);
+	add_feature_if_bit(AVXNECONVERT, leaf7s1.edx, 5);
+	add_feature_if_bit(AVXVNNI, leaf7s1.eax, 4);
+	add_feature_if_bit(AVXVNNIINT16, leaf7s1.edx, 10);
+	add_feature_if_bit(AVXVNNIINT8, leaf7s1.edx, 4);
+	add_feature_if_bit(BMI, leaf7.ebx, 3);
+	add_feature_if_bit(BMI2, leaf7.ebx, 8);
+	add_feature_if_bit(CLDEMOTE, leaf7.ecx, 25);
+	add_feature_if_bit(CLFLUSHOPT, leaf7.ebx, 23);
+	add_feature_if_bit(CLWB, leaf7.ebx, 24);
+	add_feature_if_bit(CLZERO, ext8.ecx, 0);
+	add_feature_if_bit(CMOV, feat.edx, 15);
+	add_feature_if_bit(CMPCCXADD, leaf7s1.eax, 7);
+	add_feature_if_bit(CMPXCHG16B, feat.ecx, 12);
+	add_feature_if_bit(CX8, feat.edx, 8);
+	add_feature_if_bit(ENQCMD, leaf7.ecx, 29);
+	add_feature_if_bit(F16C, feat.ecx, 29);
+	add_feature_if_bit(FMA, feat.ecx, 12);
+	add_feature_if_bit(FMA4, ext1.ecx, 16);
+	add_feature_if_bit(FSGSBASE, leaf7.ebx, 0);
+	add_feature_if_bit(FXSR, feat.edx, 24);
+	add_feature_if_bit(GFNI, leaf7.ecx, 8);
+	add_feature_if_bit(HRESET, leaf7s1.eax, 22);
+	add_feature_if_bit(INVPCID, leaf7.ebx, 10);
+	add_feature_if_bit(KL, leaf7.ecx, 23);
+	add_feature_if_bit(LWP, ext1.ecx, 15);
+	add_feature_if_bit(LZCNT, ext1.ecx, 5);
+	add_feature_if_bit(MMX, feat.edx, 23);
+	add_feature_if_bit(MOVBE, feat.ecx, 22);
+	add_feature_if_bit(MOVDIR64B, leaf7.ecx, 28);
+	add_feature_if_bit(MOVDIRI, leaf7.ecx, 27);
+	add_feature_if_bit(MWAITX, ext1.ecx, 29);
+	add_feature_if_bit(PCLMUL, feat.ecx, 1);
+	add_feature_if_bit(PCONFIG, leaf7.edx, 18);
+	add_feature_if_bit(PKU, leaf7.ecx, 4);
+	add_feature_if_bit(POPCNT, feat.ecx, 23);
+	add_feature_if_bit(PREFETCHI, leaf7s1.edx, 14);
+	add_feature_if_bit(PREFETCHWT1, leaf7.ecx, 0);
+	add_feature_if_bit(PRFCHW, ext1.ecx, 8);
+	add_feature_if_bit(PTWRITE, leaf_14.ebx, 4);
+	add_feature_if_bit(RAOINT, leaf7s1.eax, 3);
+	add_feature_if_bit(RDPID, leaf7.ecx, 22);
+	add_feature_if_bit(RDPRU, ext8.ecx, 4);
+	add_feature_if_bit(RDRND, feat.ecx, 30);
+	add_feature_if_bit(RDSEED, leaf7.ebx, 18);
+	add_feature_if_bit(RTM, leaf7.ebx, 11);
+	add_feature_if_bit(SAHF, ext1.ecx, 0);
+	add_feature_if_bit(SERIALIZE, leaf7.edx, 14);
+	add_feature_if_bit(SGX, leaf7.ebx, 2);
+	add_feature_if_bit(SHA, leaf7.ebx, 29);
+	add_feature_if_bit(SHA512, leaf7s1.eax, 0);
+	add_feature_if_bit(SHSTK, leaf7.ecx, 7);
+	add_feature_if_bit(SM3, leaf7s1.eax, 1);
+	add_feature_if_bit(SM4, leaf7s1.eax, 2);
+	add_feature_if_bit(SSE, feat.edx, 25);
+	add_feature_if_bit(SSE2, feat.edx, 26);
+	add_feature_if_bit(SSE3, feat.ecx, 0);
+	add_feature_if_bit(SSE4_1, feat.ecx, 19);
+	add_feature_if_bit(SSE4_2, feat.ecx, 20);
+	add_feature_if_bit(SSE4_A, ext1.ecx, 6);
+	add_feature_if_bit(SSSE3, feat.ecx, 9);
+	add_feature_if_bit(TBM, ext1.ecx, 21);
+	add_feature_if_bit(TSXLDTRK, leaf7.edx, 16);
+	add_feature_if_bit(UINTR, leaf7.edx, 5);
+	add_feature_if_bit(USERMSR, leaf7s1.edx, 15);
+	add_feature_if_bit(VAES, leaf7.ecx, 9);
+	add_feature_if_bit(VPCLMULQDQ, leaf7.ecx, 10);
+	add_feature_if_bit(WAITPKG, leaf7.ecx, 5);
+	add_feature_if_bit(WBNOINVD, ext8.ecx, 9);
+	add_feature_if_bit(WIDEKL, leaf_19.ebx, 2);
+	add_feature_if_bit(X87, feat.edx, 0);
+	add_feature_if_bit(XOP, ext1.ecx, 11);
+	add_feature_if_bit(XSAVE, feat.ecx, 26);
+	add_feature_if_bit(XSAVEC, leaf_d.eax, 1);
+	add_feature_if_bit(XSAVEOPT, leaf_d.eax, 0);
+	add_feature_if_bit(XSAVES, leaf_d.eax, 3);
+
+}
--- a/lib/std/core/private/macho_runtime.c3
+++ b/lib/std/core/private/macho_runtime.c3
@@ -0,0 +1,254 @@
+module std::core::machoruntime @if(env::DARWIN) @private;
+
+struct SegmentCommand64
+{
+	uint cmd;
+	uint cmdsize;
+	char[16] segname;
+	ulong vmaddr;
+	ulong vmsize;
+	ulong fileoff;
+	ulong filesize;
+	uint maxprot;
+	uint initprot;
+	uint nsects;
+	uint flags;
+}
+
+struct LoadCommand
+{
+	uint cmd;
+	uint cmdsize;
+}
+
+struct Section64
+{
+	char[16] sectname;
+	char[16] segname;
+	ulong addr;
+	ulong size;
+	uint offset;
+	uint align;
+	uint reloff;
+	uint nreloc;
+	uint flags;
+	uint reserved1;
+	uint reserved2;
+	uint reserved3;
+}
+
+struct MachHeader
+{
+	uint magic;
+	uint cputype;
+	uint cpusubtype;
+	uint filetype;
+	uint ncmds;
+	uint sizeofcmds;
+	uint flags;
+}
+
+struct MachHeader64
+{
+	inline MachHeader header;
+	uint reserved;
+}
+
+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++)
+	{
+		if (a[i] != (*b)[i]) return false;
+		if (a[i] == '\0') return true;
+	}
+	return false;
+}
+
+fn SegmentCommand64*! find_segment(MachHeader* header, char* segname)
+{
+	LoadCommand* command = (void*)header + MachHeader64.sizeof;
+	for (uint i = 0; i < header.ncmds; i++)
+	{
+		if (command.cmd == LC_SEGMENT_64)
+		{
+			SegmentCommand64* segment = (SegmentCommand64*)command;
+			if (name_cmp(segname, &segment.segname)) return segment;
+		}
+		command = (void*)command + command.cmdsize;
+	}
+	return MachoSearch.NOT_FOUND?;
+}
+fn Section64*! find_section(SegmentCommand64* command, char* sectname)
+{
+	Section64* section = (void*)command + SegmentCommand64.sizeof;
+	for (uint i = 0; i < command.nsects; i++)
+	{
+		if (name_cmp(sectname, &section.sectname)) return section;
+		section++;
+	}
+	return MachoSearch.NOT_FOUND?;
+}
+
+macro find_segment_section_body(MachHeader* header, char* segname, char* sectname, $Type)
+{
+
+	Section64*! section = find_section(find_segment(header, segname), sectname);
+	if (catch section)
+	{
+		return $Type[] {};
+	}
+	$Type* ptr = (void*)header + section.offset;
+	return ptr[:section.size / $Type.sizeof];
+}
+
+def DyldCallback = fn void (MachHeader* mh, isz vmaddr_slide);
+
+extern fn void _dyld_register_func_for_add_image(DyldCallback);
+
+
+struct DlInfo
+{
+	char* dli_fname;
+	void* dli_fbase;
+	char* dli_sname;
+	void* dli_saddr;
+}
+
+extern fn void printf(char*, ...);
+extern fn int dladdr(MachHeader* mh, DlInfo* dlinfo);
+extern fn void* realloc(void* ptr, usz size);
+extern fn void* malloc(usz size);
+extern fn void free(void* ptr);
+
+def CallbackFn = fn void();
+struct Callback
+{
+	uint priority;
+	CallbackFn xtor;
+	Callback* next;
+}
+struct DynamicMethod
+{
+	void* fn_ptr;
+	char* sel;
+	union
+	{
+		DynamicMethod* next;
+		TypeId* type;
+	}
+}
+
+enum StartupState
+{
+	NOT_STARTED,
+	INIT,
+	RUN_CTORS,
+	READ_DYLIB,
+	RUN_DYLIB_CTORS,
+	RUN_DTORS,
+	SHUTDOWN
+}
+
+StartupState runtime_state = NOT_STARTED;
+
+Callback* ctor_first;
+Callback* dtor_first;
+
+fn void runtime_startup() @public @export("__c3_runtime_startup")
+{
+	if (runtime_state != NOT_STARTED) return;
+	runtime_state = INIT;
+	_dyld_register_func_for_add_image(&dl_reg_callback);
+	assert(runtime_state == INIT);
+	runtime_state = RUN_CTORS;
+	Callback* ctor = ctor_first;
+	while (ctor)
+	{
+		ctor.xtor();
+		ctor = ctor.next;
+	}
+	assert(runtime_state == RUN_CTORS);
+	runtime_state = READ_DYLIB;
+	ctor_first = null;
+}
+
+fn void runtime_finalize() @public @export("__c3_runtime_finalize")
+{
+	if (runtime_state != READ_DYLIB) return;
+	runtime_state = RUN_DTORS;
+	Callback* dtor = dtor_first;
+	while (dtor)
+	{
+		dtor.xtor();
+		dtor = dtor.next;
+	}
+	assert(runtime_state == RUN_DTORS);
+	runtime_state = SHUTDOWN;
+}
+
+fn void append_xxlizer(Callback** ref, Callback* cb)
+{
+	while (Callback* current = *ref, current)
+	{
+		if (current.priority > cb.priority)
+		{
+			cb.next = current;
+			break;
+		}
+		ref = &current.next;
+	}
+	*ref = cb;
+}
+
+struct TypeId
+{
+	char type;
+	TypeId* parentof;
+	DynamicMethod* dtable;
+	usz sizeof;
+	TypeId* inner;
+	usz len;
+	typeid[*] additional;
+}
+
+fn void dl_reg_callback(MachHeader* mh, isz vmaddr_slide)
+{
+	usz size = 0;
+	assert(runtime_state == INIT || runtime_state == READ_DYLIB, "State was %s", runtime_state);
+	foreach (&dm : find_segment_section_body(mh, "__DATA", "__c3_dynamic", DynamicMethod))
+	{
+		TypeId* type = dm.type;
+		dm.next = type.dtable;
+		type.dtable = dm;
+		DynamicMethod* m = dm;
+		while (m)
+		{
+			m = m.next;
+		}
+	}
+	foreach (&cb : find_segment_section_body(mh, "__DATA", "__c3dtor", Callback))
+	{
+		append_xxlizer(&dtor_first, cb);
+	}
+	foreach (&cb : find_segment_section_body(mh, "__DATA", "__c3ctor", Callback))
+	{
+		append_xxlizer(&ctor_first, cb);
+	}
+	if (runtime_state != READ_DYLIB) return;
+	runtime_state = RUN_DYLIB_CTORS;
+	Callback* ctor = ctor_first;
+	ctor_first = null;
+	while (ctor)
+	{
+		ctor.xtor();
+		ctor = ctor.next;
+	}
+	assert(runtime_state == RUN_DYLIB_CTORS);
+	runtime_state = READ_DYLIB;
+}
--- a/lib/std/core/private/main_stub.c3
+++ b/lib/std/core/private/main_stub.c3
@@ -21,7 +21,7 @@ macro int @main_to_void_main(#m, int, char**)

 macro String[] args_to_strings(int argc, char** argv) @private
 {
-	String[] list = mem::new_array(String, argc);
+	String[] list = mem::alloc_array(String, argc);
 	for (int i = 0; i < argc; i++)
 	{
 		char* arg = argv[i];
@@ -68,7 +68,7 @@ macro String[] win_command_line_to_strings(ushort* cmd_line) @private

 macro String[] wargs_strings(int argc, Char16** argv) @private
 {
-	String[] list = mem::new_array(String, argc);
+	String[] list = mem::alloc_array(String, argc);
 	for (int i = 0; i < argc; i++)
 	{
 		Char16* arg = argv[i];
@@ -84,19 +84,19 @@ macro void release_wargs(String[] list) @private
 	free(list.ptr);
 }

-macro int @win_to_err_main_noargs(#m, void* handle, Char16* cmd_line, int show_cmd)
+macro int @win_to_err_main_noargs(#m, void* handle, void* prev_handle, Char16* cmd_line, int show_cmd)
 {
 	if (catch #m()) return 1;
 	return 0;
 }
-macro int @win_to_int_main_noargs(#m, void* handle, Char16* cmd_line, int show_cmd) => #m();
-macro int @win_to_void_main_noargs(#m, void* handle, Char16* cmd_line, int show_cmd)
+macro int @win_to_int_main_noargs(#m, void* handle, void* prev_handle, Char16* cmd_line, int show_cmd) => #m();
+macro int @win_to_void_main_noargs(#m, void* handle, void* prev_handle, Char16* cmd_line, int show_cmd)
 {
 	#m();
 	return 0;
 }

-macro int @win_to_err_main_args(#m, void* handle, Char16* cmd_line, int show_cmd)
+macro int @win_to_err_main_args(#m, void* handle, void* prev_handle, Char16* cmd_line, int show_cmd)
 {
 	String[] args = win_command_line_to_strings(cmd_line);
 	defer release_wargs(args);
@@ -104,14 +104,14 @@ macro int @win_to_err_main_args(#m, void* handle, Char16* cmd_line, int show_cmd
 	return 0;
 }

-macro int @win_to_int_main_args(#m, void* handle, Char16* cmd_line, int show_cmd)
+macro int @win_to_int_main_args(#m, void* handle, void* prev_handle, Char16* cmd_line, int show_cmd)
 {
 	String[] args = win_command_line_to_strings(cmd_line);
 	defer release_wargs(args);
 	return #m(args);
 }

-macro int @win_to_void_main_args(#m, void* handle, Char16* cmd_line, int show_cmd)
+macro int @win_to_void_main_args(#m, void* handle, void* prev_handle, Char16* cmd_line, int show_cmd)
 {
 	String[] args = win_command_line_to_strings(cmd_line);
 	defer release_wargs(args);
@@ -119,26 +119,26 @@ macro int @win_to_void_main_args(#m, void* handle, Char16* cmd_line, int show_cm
 	return 0;
 }

-macro int @win_to_err_main(#m, void* handle, Char16* cmd_line, int show_cmd)
+macro int @win_to_err_main(#m, void* handle, void* prev_handle, Char16* cmd_line, int show_cmd)
 {
 	String[] args = win_command_line_to_strings(cmd_line);
 	defer release_wargs(args);
-	if (catch #m(handle, args, show_cmd)) return 1;
+	if (catch #m(handle, prev_handle, args, show_cmd)) return 1;
 	return 0;
 }

-macro int @win_to_int_main(#m, void* handle, Char16* cmd_line, int show_cmd)
+macro int @win_to_int_main(#m, void* handle, void* prev_handle, Char16* cmd_line, int show_cmd)
 {
 	String[] args = win_command_line_to_strings(cmd_line);
 	defer release_wargs(args);
-	return #m(handle, args, show_cmd);
+	return #m(handle, prev_handle, args, show_cmd);
 }

-macro int @win_to_void_main(#m, void* handle, Char16* cmd_line, int show_cmd)
+macro int @win_to_void_main(#m, void* handle, void* prev_handle, Char16* cmd_line, int show_cmd)
 {
 	String[] args = win_command_line_to_strings(cmd_line);
 	defer release_wargs(args);
-	#m(handle, args, show_cmd);
+	#m(handle, prev_handle, args, show_cmd);
 	return 0;
 }

--- a/lib/std/core/runtime.c3
+++ b/lib/std/core/runtime.c3
@@ -2,15 +2,15 @@
 // 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::runtime;
-import libc;
+import libc, std::time, std::io, std::sort;

-struct AnyStruct
+struct AnyRaw
 {
 	void* ptr;
 	typeid type;
 }

-struct SubArrayStruct
+struct SliceRaw
 {
 	void* ptr;
 	usz len;
@@ -24,11 +24,11 @@ struct BenchmarkUnit
 	BenchmarkFn func;
 }

-fn BenchmarkUnit[] benchmark_collection_create(Allocator* allocator = mem::heap())
+fn BenchmarkUnit[] benchmark_collection_create(Allocator allocator = allocator::heap())
 {
 	BenchmarkFn[] fns = $$BENCHMARK_FNS;
 	String[] names = $$BENCHMARK_NAMES;
-	BenchmarkUnit[] benchmarks = allocator.new_array(BenchmarkUnit, names.len);
+	BenchmarkUnit[] benchmarks = allocator::alloc_array(allocator, BenchmarkUnit, names.len);
 	foreach (i, benchmark : fns)
 	{
 		benchmarks[i] = { names[i], fns[i] };
@@ -130,7 +130,7 @@ fn bool default_benchmark_runner()
 {
 	@pool()
 	{
-		return run_benchmarks(benchmark_collection_create(mem::temp()));
+		return run_benchmarks(benchmark_collection_create(allocator::temp()));
 	};
 }

@@ -142,11 +142,11 @@ struct TestUnit
 	TestFn func;
 }

-fn TestUnit[] test_collection_create(Allocator* allocator = mem::heap())
+fn TestUnit[] test_collection_create(Allocator allocator = allocator::heap())
 {
 	TestFn[] fns = $$TEST_FNS;
 	String[] names = $$TEST_NAMES;
-	TestUnit[] tests = allocator.new_array(TestUnit, names.len);
+	TestUnit[] tests = allocator::alloc_array(allocator, TestUnit, names.len);
 	foreach (i, test : fns)
 	{
 		tests[i] = { names[i], fns[i] };
@@ -236,7 +236,7 @@ fn bool default_test_runner()
 {
 	@pool()
 	{
-		return run_tests(test_collection_create(mem::temp()));
+		return run_tests(test_collection_create(allocator::temp()));
 	};
 }

--- a/lib/std/core/sanitizer/asan.c3
+++ b/lib/std/core/sanitizer/asan.c3
@@ -0,0 +1,127 @@
+// Add this to your code to suppress leak detection or set other default options
+// fn ZString __asan_default_options() @export("__asan_default_options") @if(env::ADDRESS_SANITIZER)
+// {
+//   return "detect_leaks=0";
+// }
+
+// Add this to break on error
+// asan::set_error_report_callback(fn (ZString err)
+// {
+//   breakpoint();
+// });
+
+module std::core::sanitizer::asan;
+
+def ErrorCallback = fn void (ZString);
+
+/**
+ * Marks a memory region ([addr, addr+size)) as unaddressable.
+ *
+ * This memory must be previously allocated by your program. Instrumented
+ * code is forbidden from accessing addresses in this region until it is
+ * unpoisoned. This function is not guaranteed to poison the entire region -
+ * it could poison only a subregion of [addr, addr+size) due to ASan
+ * alignment restrictions.
+ *
+ * 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."
+ **/
+macro poison_memory_region(void* addr, usz size)
+{
+	$if env::ADDRESS_SANITIZER: 
+		__asan_poison_memory_region(addr, size);
+	$endif 
+}
+
+/**
+ * Marks a memory region ([addr, addr+size)) as addressable.
+ *
+ * This memory must be previously allocated by your program. Accessing
+ * addresses in this region is allowed until this region is poisoned again.
+ * This function could unpoison a super-region of [addr, addr+size) due
+ * to ASan alignment restrictions.
+ *
+ * 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."
+ **/
+macro unpoison_memory_region(void* addr, usz size)
+{
+	$if env::ADDRESS_SANITIZER: 
+		__asan_unpoison_memory_region(addr, size);
+	$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."
+ **/
+macro bool address_is_poisoned(void* addr)
+{
+	$if env::ADDRESS_SANITIZER:
+		return (bool)__asan_address_is_poisoned(addr);
+	$else
+		return false;
+	$endif
+}
+
+/**
+ * Checks if a region is poisoned.
+ *
+ * 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."
+ * @return "Address of first poisoned byte."
+ **/
+macro void* region_is_poisoned(void* beg, usz size)
+{
+	$if env::ADDRESS_SANITIZER:
+		return __asan_region_is_poisoned(addr);
+	$else
+		return null;
+	$endif
+}
+
+/**
+ * Sets the callback function to be called during ASan error reporting.
+ **/
+fn void set_error_report_callback(ErrorCallback callback)
+{
+	$if env::ADDRESS_SANITIZER:
+		__asan_set_error_report_callback(callback);
+	$endif
+}
+
+module std::core::sanitizer::asan @if(env::ADDRESS_SANITIZER);
+
+extern fn void __asan_poison_memory_region(void* addr, usz size);
+extern fn void __asan_unpoison_memory_region(void* addr, usz size);
+extern fn CInt __asan_address_is_poisoned(void* addr);
+extern fn void* __asan_region_is_poisoned(void* beg, usz size);
+extern fn void __asan_describe_address(void* addr);
+extern fn CInt __asan_report_present();
+extern fn void* __asan_get_report_pc();
+extern fn void* __asan_get_report_bp();
+extern fn void* __asan_get_report_sp();
+extern fn void* __asan_get_report_address();
+extern fn CInt __asan_get_report_access_type();
+extern fn usz __asan_get_report_access_size();
+extern fn ZString __asan_get_report_description();
+extern fn ZString __asan_locate_address(void* addr, char* name, usz name_size, void** region_address, usz* region_size);
+extern fn usz __asan_get_alloc_stack(void* addr, void** trace, usz size, CInt* thread_id);
+extern fn usz __asan_get_free_stack(void* addr, void** trace, usz size, CInt* thread_id);
+extern fn void __asan_get_shadow_mapping(usz* shadow_scale, usz* shadow_offset);
+extern fn void __asan_set_error_report_callback(ErrorCallback callback);
+extern fn void __asan_print_accumulated_stats();
+extern fn void* __asan_get_current_fake_stack();
+extern fn void* __asan_addr_is_in_fake_stack(void* fake_stack, void* addr, void** beg, void** end);
+extern fn void __asan_handle_no_return();
+extern fn CInt __asan_update_allocation_context(void* addr);
--- a/lib/std/core/sanitizer/sanitizer.c3
+++ b/lib/std/core/sanitizer/sanitizer.c3
@@ -0,0 +1,80 @@
+module std::core::sanitizer;
+
+macro void annotate_contiguous_container(void* beg, void* end, void* old_mid, void* new_mid)
+{
+	$if env::ADDRESS_SANITIZER:
+		__sanitizer_annotate_contiguous_container(beg, end, old_mid, new_mid);
+	$endif
+}
+
+macro void annotate_double_ended_contiguous_container(void* storage_beg, void* storage_end, void* old_container_beg, void* old_container_end, void* new_container_beg, void* new_container_end)
+{
+	$if env::ADDRESS_SANITIZER:
+		__sanitizer_annotate_double_ended_contiguous_container(storage_beg, storage_end, old_container_beg, old_container_end, new_container_beg, new_container_end);
+	$endif
+}
+
+macro void print_stack_trace()
+{
+	$if env::ADDRESS_SANITIZER:
+		__sanitizer_print_stack_trace();
+	$endif
+}
+
+fn void set_death_callback(VoidFn callback)
+{
+	$if env::ANY_SANITIZER:
+		__sanitizer_set_death_callback(callback);
+	$endif
+}
+
+module std::core::sanitizer @if (env::ANY_SANITIZER);
+
+struct __Sanitizer_sandbox_arguments
+{
+	CInt coverage_sandboxed;
+	iptr coverage_fd;
+	CUInt coverage_max_block_size;
+}
+
+extern fn void __sanitizer_set_report_path(ZString path);
+extern fn void __sanitizer_set_report_fd(void* fd);
+extern fn ZString __sanitizer_get_report_path();
+extern fn void __sanitizer_sandbox_on_notify(__Sanitizer_sandbox_arguments* args);
+extern fn void __sanitizer_report_error_summary(ZString error_summary);
+extern fn ushort __sanitizer_unaligned_load16(void* p);
+extern fn uint __sanitizer_unaligned_load32(void* p);
+extern fn ulong __sanitizer_unaligned_load64(void* p);
+extern fn void __sanitizer_unaligned_store16(void* p, ushort x);
+extern fn void __sanitizer_unaligned_store32(void* p, uint x);
+extern fn void __sanitizer_unaligned_store64(void* p, ulong x);
+extern fn CInt __sanitizer_acquire_crash_state();
+extern fn void __sanitizer_annotate_contiguous_container(void* beg, void* end, void* old_mid, void* new_mid);
+extern fn void __sanitizer_annotate_double_ended_contiguous_container(void* storage_beg, void* storage_end,
+	void* old_container_beg, void* old_container_end,
+	void* new_container_beg, void* new_container_end);
+extern fn CInt __sanitizer_verify_contiguous_container(void* beg, void* mid, void* end);
+extern fn CInt __sanitizer_verify_double_ended_contiguous_container(
+	void* storage_beg, void* container_beg,
+	void* container_end, void* storage_end);
+extern fn void* __sanitizer_contiguous_container_find_bad_address(void* beg, void* mid, void* end);
+extern fn void* __sanitizer_double_ended_contiguous_container_find_bad_address(
+	void* storage_beg, void* container_beg,
+	void* container_end, void* storage_end);
+
+extern fn void __sanitizer_print_stack_trace();
+extern fn void __sanitizer_symbolize_pc(void* pc, ZString fmt, char* out_buf, usz out_buf_size);
+extern fn void __sanitizer_symbolize_global(void* data_ptr, ZString fmt, char* out_buf, usz out_buf_size);
+extern fn void __sanitizer_set_death_callback(VoidFn callback);
+extern fn void __sanitizer_weak_hook_memcmp(void* called_pc, void* s1, void* s2, usz n, CInt result);
+extern fn void __sanitizer_weak_hook_strncmp(void* called_pc, ZString s1, ZString s2, usz n, CInt result);
+extern fn void __sanitizer_weak_hook_strncasecmp(void* called_pc, ZString s1, ZString s2, usz n, CInt result);
+extern fn void __sanitizer_weak_hook_strcmp(void* called_pc, ZString s1, ZString s2, CInt result);
+extern fn void __sanitizer_weak_hook_strcasecmp(void* called_pc, ZString s1, ZString s2, CInt result);
+extern fn void __sanitizer_weak_hook_strstr(void* called_pc, ZString s1, ZString s2, char* result);
+extern fn void __sanitizer_weak_hook_strcasestr(void* called_pc, ZString s1, ZString s2, char* result);
+extern fn void __sanitizer_weak_hook_memmem(void* called_pc, void* s1, usz len1, void* s2, usz len2, void* result);
+extern fn void __sanitizer_print_memory_profile(usz top_percent, usz max_number_of_contexts);
+extern fn void __sanitizer_start_switch_fiber(void** fake_stack_save, void* bottom, usz size);
+extern fn void __sanitizer_finish_switch_fiber(void* fake_stack_save, void** bottom_old, usz* size_old);
+extern fn CInt __sanitizer_get_module_and_offset_for_pc(void* pc, char* module_path, usz module_path_len, void** pc_offset);
--- a/lib/std/core/sanitizer/tsan.c3
+++ b/lib/std/core/sanitizer/tsan.c3
@@ -0,0 +1,39 @@
+module std::core::sanitizer::tsan;
+
+distinct MutexFlags = inline CUInt;
+
+const MutexFlags MUTEX_LINKER_INIT      = 1 << 0;
+const MutexFlags MUTEX_WRITE_REENTRANT  = 1 << 1;
+const MutexFlags MUTEX_READ_REENTRANT   = 1 << 2;
+const MutexFlags MUTEX_NOT_STATIC       = 1 << 8;
+const MutexFlags MUTEX_READ_LOCK        = 1 << 3;
+const MutexFlags MUTEX_TRY_LOCK         = 1 << 4;
+const MutexFlags MUTEX_TRY_LOCK_FAILED  = 1 << 5;
+const MutexFlags MUTEX_RECURSIVE_LOCK   = 1 << 6;
+const MutexFlags MUTEX_RECURSIVE_UNLOCK = 1 << 7;
+const MutexFlags MUTEX_TRY_READ_LOCK = MUTEX_READ_LOCK | MUTEX_TRY_LOCK;
+const MutexFlags MUTEX_TRY_READ_LOCK_FAILED = MUTEX_TRY_READ_LOCK | MUTEX_TRY_LOCK_FAILED;
+
+macro void mutex_create(void* addr, MutexFlags flags) { $if env::THREAD_SANITIZER: __tsan_mutex_create(addr, flags); $endif }
+macro void mutex_destroy(void* addr, MutexFlags flags) { $if env::THREAD_SANITIZER: __tsan_mutex_destroy(addr, flags); $endif }
+macro void mutex_pre_lock(void* addr, MutexFlags flags) { $if env::THREAD_SANITIZER: __tsan_mutex_pre_lock(addr, flags); $endif }
+macro void mutex_post_lock(void* addr, MutexFlags flags, CInt recursion) { $if env::THREAD_SANITIZER: __tsan_mutex_post_lock(addr, flags, recursion); $endif }
+macro CInt mutex_pre_unlock(void* addr, MutexFlags flags) { $if env::THREAD_SANITIZER: return __tsan_mutex_pre_unlock(addr, flags); $else return 0; $endif }
+macro void mutex_post_unlock(void* addr, MutexFlags flags) { $if env::THREAD_SANITIZER: __tsan_mutex_post_unlock(addr, flags); $endif }
+macro void mutex_pre_signal(void* addr, MutexFlags flags) { $if env::THREAD_SANITIZER: __tsan_mutex_pre_signal(addr, flags); $endif }
+macro void mutex_post_signal(void* addr, MutexFlags flags) { $if env::THREAD_SANITIZER: __tsan_mutex_post_signal(addr, flags); $endif }
+macro void mutex_pre_divert(void* addr, MutexFlags flags) { $if env::THREAD_SANITIZER: __tsan_mutex_pre_divert(addr, flags); $endif }
+macro void mutex_post_divert(void* addr, MutexFlags flags) { $if env::THREAD_SANITIZER: __tsan_mutex_post_divert(addr, flags); $endif }
+
+module std::core::sanitizer::tsan @if(env::THREAD_SANITIZER) @private;
+
+extern fn void __tsan_mutex_create(void* addr, CUInt flags);
+extern fn void __tsan_mutex_destroy(void* addr, CUInt flags);
+extern fn void __tsan_mutex_pre_lock(void* addr, CUInt flags);
+extern fn void __tsan_mutex_post_lock(void* addr, CUInt flags, CInt recursion);
+extern fn CInt __tsan_mutex_pre_unlock(void* addr, CUInt flags);
+extern fn void __tsan_mutex_post_unlock(void* addr, CUInt flags);
+extern fn void __tsan_mutex_pre_signal(void* addr, CUInt flags);
+extern fn void __tsan_mutex_post_signal(void* addr, CUInt flags);
+extern fn void __tsan_mutex_pre_divert(void* addr, CUInt flags);
+extern fn void __tsan_mutex_post_divert(void* addr, CUInt flags);
--- a/lib/std/core/string.c3
+++ b/lib/std/core/string.c3
@@ -1,6 +1,7 @@
 module std::core::string;
 import std::ascii;

+distinct String @if(!$defined(String)) = inline char[];
 distinct ZString = inline char*;
 distinct WString = inline Char16*;
 def Char32 = uint;
@@ -31,35 +32,81 @@ fault NumberConversion
 	FLOAT_OUT_OF_RANGE,
 }

+/**
+ * Return a temporary String created using the formatting function.
+ *
+ * @param [in] fmt `The formatting string`
+ **/
 macro String tformat(String fmt, ...)
 {
 	DString str = dstring::temp_with_capacity(fmt.len + $vacount * 8);
-	str.appendf(fmt, $vasplat());
+	str.appendf(fmt, $vasplat);
 	return str.str_view();
 }

-macro String new_format(String fmt, ..., Allocator* allocator = mem::heap())
+/**
+ * Return a temporary ZString created using the formatting function.
+ *
+ * @param [in] fmt `The formatting string`
+ **/
+macro ZString tformat_zstr(String fmt, ...)
+{
+	DString str = dstring::temp_with_capacity(fmt.len + $vacount * 8);
+	str.appendf(fmt, $vasplat);
+	return str.zstr_view();
+}
+
+/**
+ * Return a new String created using the formatting function.
+ *
+ * @param [in] fmt `The formatting string`
+ * @param [inout] allocator `The allocator to use`
+ **/
+macro String new_format(String fmt, ..., Allocator allocator = allocator::heap())
 {
 	@pool(allocator)
 	{
 		DString str = dstring::temp_with_capacity(fmt.len + $vacount * 8);
-		str.appendf(fmt, $vasplat());
+		str.appendf(fmt, $vasplat);
 		return str.copy_str(allocator);
 	};
 }

+/**
+ * Return a new ZString created using the formatting function.
+ *
+ * @param [in] fmt `The formatting string`
+ * @param [inout] allocator `The allocator to use`
+ **/
+macro ZString new_format_zstr(String fmt, ..., Allocator allocator = allocator::heap())
+{
+	@pool(allocator)
+	{
+		DString str = dstring::temp_with_capacity(fmt.len + $vacount * 8);
+		str.appendf(fmt, $vasplat);
+		return str.copy_zstr(allocator);
+	};
+}

+/**
+ * Check if a character is in a set.
+ *
+ * @param c `the character to check`
+ * @param [in] set `The formatting string`
+ * @pure
+ * @return `True if a character is in the set`
+ **/
 macro bool char_in_set(char c, String set)
 {
 	foreach (ch : set) if (ch == c) return true;
 	return false;
 }

-fn String join_new(String[] s, String joiner, Allocator* allocator = mem::heap())
+fn String join_new(String[] s, String joiner, Allocator allocator = allocator::heap())
 {
 	if (!s)
 	{
-		return (String)allocator.new_zero_array(char, 2)[:0];
+		return (String)allocator::new_array(allocator, char, 2)[:0];
 	}

 	usz total_size = joiner.len * s.len;
@@ -81,8 +128,12 @@ fn String join_new(String[] s, String joiner, Allocator* allocator = mem::heap()
 }

 /**
- * @param [in] string
- * @param [in] to_trim
+ * Remove characters from the front and end of a string.
+ *
+ * @param [in] string `The string to trim`
+ * @param [in] to_trim `The set of characters to trim, defaults to whitespace`
+ * @pure
+ * @return `a substring of the string passed in`
 **/
 fn String String.trim(string, String to_trim = "\t\n\r ")
 {
@@ -96,8 +147,12 @@ fn String String.trim(string, String to_trim = "\t\n\r ")
 }

 /**
+ * Check if the String starts with the needle.
+ *
 * @param [in] string
 * @param [in] needle
+ * @pure
+ * @return `'true' if the string starts with the needle`
 **/
 fn bool String.starts_with(string, String needle)
 {
@@ -107,8 +162,12 @@ fn bool String.starts_with(string, String needle)
 }

 /**
+ * Check if the String ends with the needle.
+ *
 * @param [in] string
 * @param [in] needle
+ * @pure
+ * @return `'true' if the string ends with the needle`
 **/
 fn bool String.ends_with(string, String needle)
 {
@@ -122,6 +181,8 @@ fn bool String.ends_with(string, String needle)
 *
 * @param [in] string
 * @param [in] needle
+ * @pure
+ * @return `the substring with the prefix removed`
 **/
 fn String String.strip(string, String needle)
 {
@@ -134,6 +195,8 @@ fn String String.strip(string, String needle)
 *
 * @param [in] string
 * @param [in] needle
+ * @pure
+ * @return `the substring with the suffix removed`
 **/
 fn String String.strip_end(string, String needle)
 {
@@ -153,11 +216,11 @@ fn String String.strip_end(string, String needle)
 * @require needle.len > 0 "The needle must be at least 1 character long"
 * @ensure return.len > 0
 **/
-fn String[] String.split(s, String needle, usz max = 0, Allocator* allocator = mem::heap())
+fn String[] String.split(s, String needle, usz max = 0, Allocator allocator = allocator::heap())
 {
 	usz capacity = 16;
 	usz i = 0;
-	String* holder = allocator.new_array(String, capacity);
+	String* holder = allocator::alloc_array(allocator, String, capacity);
 	bool no_more = false;
 	while (!no_more)
 	{
@@ -176,7 +239,7 @@ fn String[] String.split(s, String needle, usz max = 0, Allocator* allocator = m
 		if (i == capacity)
 		{
 			capacity *= 2;
-			holder = allocator.realloc(holder, String.sizeof * capacity);
+			holder = allocator::realloc(allocator, holder, String.sizeof * capacity);
 		}
 		holder[i++] = res;
 	}
@@ -193,9 +256,17 @@ fn String[] String.split(s, String needle, usz max = 0, Allocator* allocator = m
 **/
 fn String[] String.tsplit(s, String needle, usz max = 0)
 {
-	return s.split(needle, max, mem::temp()) @inline;
+	return s.split(needle, max, allocator::temp()) @inline;
 }

+/**
+ * Check if a substring is found in the string.
+
+ * @param [in] s
+ * @param [in] needle "The string to look for."
+ * @pure
+ * @return "true if the string contains the substring, false otherwise"
+ **/
 fn bool String.contains(s, String needle)
 {
 	return @ok(s.index_of(needle));
@@ -205,6 +276,7 @@ fn bool String.contains(s, String needle)
 * Find the index of the first incidence of a string.
 *
 * @param [in] s
+ * @param needle "The character to look for"
 * @pure
 * @ensure return < s.len
 * @return "the index of the needle"
@@ -220,9 +292,32 @@ fn usz! String.index_of_char(s, char needle)
 }

 /**
- * Find the index of the first incidence of a string.
+ * Find the index of the first incidence of a character.
 *
 * @param [in] s
+ * @param needle "The character to look for"
+ * @param start_index "The index to start with, may exceed max index."
+ * @pure
+ * @ensure return < s.len
+ * @return "the index of the needle"
+ * @return! SearchResult.MISSING "if the needle cannot be found starting from the start_index"
+ **/
+fn usz! String.index_of_char_from(s, char needle, usz start_index)
+{
+	usz len = s.len;
+	if (len <= start_index) return SearchResult.MISSING?;
+	for (usz i = start_index; i < len; i++)
+	{
+		if (s[i] == needle) return i;
+	}
+	return SearchResult.MISSING?;
+}
+
+/**
+ * Find the index of the first incidence of a character starting from the end.
+ *
+ * @param [in] s
+ * @param needle "the character to find"
 * @pure
 * @ensure return < s.len
 * @return "the index of the needle"
@@ -312,19 +407,19 @@ fn usz ZString.len(str)
 }


-fn ZString String.zstr_copy(s, Allocator* allocator = mem::heap())
+fn ZString String.zstr_copy(s, Allocator allocator = allocator::heap())
 {
 	usz len = s.len;
-	char* str = allocator.alloc(len + 1);
+	char* str = allocator::malloc(allocator, len + 1);
 	mem::copy(str, s.ptr, len);
 	str[len] = 0;
 	return (ZString)str;
 }

-fn String String.concat(s1, String s2, Allocator* allocator = mem::heap())
+fn String String.concat(s1, String s2, Allocator allocator = allocator::heap())
 {
 	usz full_len = s1.len + s2.len;
-	char* str = allocator.alloc(full_len + 1);
+	char* str = allocator::malloc(allocator, full_len + 1);
 	usz s1_len = s1.len;
 	mem::copy(str, s1.ptr, s1_len);
 	mem::copy(str + s1_len, s2.ptr, s2.len);
@@ -332,37 +427,37 @@ fn String String.concat(s1, String s2, Allocator* allocator = mem::heap())
 	return (String)str[:full_len];
 }

-fn String String.tconcat(s1, String s2) => s1.concat(s2, mem::temp());
+fn String String.tconcat(s1, String s2) => s1.concat(s2, allocator::temp());


-fn ZString String.zstr_tcopy(s) => s.zstr_copy(mem::temp()) @inline;
+fn ZString String.zstr_tcopy(s) => s.zstr_copy(allocator::temp()) @inline;

-fn String String.copy(s, Allocator* allocator = mem::heap())
+fn String String.copy(s, Allocator allocator = allocator::heap())
 {
 	usz len = s.len;
-	char* str = allocator.alloc(len + 1);
+	char* str = allocator::malloc(allocator, len + 1);
 	mem::copy(str, s.ptr, len);
 	str[len] = 0;
 	return (String)str[:len];
 }

-fn void String.free(&s, Allocator* allocator = mem::heap())
+fn void String.free(&s, Allocator allocator = allocator::heap())
 {
 	if (!s.len) return;
-	allocator.free(s.ptr);
+	allocator::free(allocator, s.ptr);
 	*s = "";
 }

-fn String String.tcopy(s) => s.copy(mem::temp()) @inline;
+fn String String.tcopy(s) => s.copy(allocator::temp()) @inline;

-fn String ZString.copy(z, Allocator* allocator = mem::temp())
+fn String ZString.copy(z, Allocator allocator = allocator::temp())
 {
 	return z.str_view().copy(allocator) @inline;
 }

 fn String ZString.tcopy(z)
 {
-	return z.str_view().copy(mem::temp()) @inline;
+	return z.str_view().copy(allocator::temp()) @inline;
 }

 /**
@@ -371,10 +466,10 @@ fn String ZString.tcopy(z)
 * @return! UnicodeResult.INVALID_UTF8 "If the string contained an invalid UTF-8 sequence"
 * @return! AllocationFailure "If allocation of the string fails"
 **/
-fn Char16[]! String.to_new_utf16(s, Allocator* allocator = mem::heap())
+fn Char16[]! String.to_new_utf16(s, Allocator allocator = allocator::heap())
 {
 	usz len16 = conv::utf16len_for_utf8(s);
-	Char16* data = allocator.new_array_checked(Char16, len16 + 1)!;
+	Char16* data = allocator::alloc_array_try(allocator, Char16, len16 + 1)!;
 	conv::utf8to16_unsafe(s, data)!;
 	data[len16] = 0;
 	return data[:len16];
@@ -388,10 +483,10 @@ fn Char16[]! String.to_new_utf16(s, Allocator* allocator = mem::heap())
 **/
 fn Char16[]! String.to_temp_utf16(s)
 {
-	return s.to_new_utf16(mem::temp());
+	return s.to_new_utf16(allocator::temp());
 }

-fn WString! String.to_new_wstring(s, Allocator* allocator = mem::heap())
+fn WString! String.to_new_wstring(s, Allocator allocator = allocator::heap())
 {
 	return (WString)s.to_new_utf16(allocator).ptr;
 }
@@ -401,10 +496,10 @@ fn WString! String.to_temp_wstring(s)
 	return (WString)s.to_temp_utf16().ptr;
 }

-fn Char32[]! String.to_new_utf32(s, Allocator* allocator = mem::heap())
+fn Char32[]! String.to_new_utf32(s, Allocator allocator = allocator::heap())
 {
 	usz codepoints = conv::utf8_codepoints(s);
-	Char32* data = allocator.new_array(Char32, codepoints + 1);
+	Char32* data = allocator::alloc_array_try(allocator, Char32, codepoints + 1)!;
 	conv::utf8to32_unsafe(s, data)!;
 	data[codepoints] = 0;
 	return data[:codepoints];
@@ -412,32 +507,52 @@ fn Char32[]! String.to_new_utf32(s, Allocator* allocator = mem::heap())

 fn Char32[]! String.to_temp_utf32(s)
 {
-	return s.to_new_utf32(mem::temp());
+	return s.to_new_utf32(allocator::temp());
 }

+/**
+ * Convert a string to ASCII lower case.
+ *
+ * @param [inout] s
+ * @pure
+ **/
 fn void String.convert_ascii_to_lower(s)
 {
-	foreach (&c : s) if (c.is_upper()) *c += 'a' - 'A';
+	foreach (&c : s) if (c.is_upper() @pure) *c += 'a' - 'A';
 }

-fn String String.new_ascii_to_lower(s, Allocator* allocator = mem::heap())
+fn String String.new_ascii_to_lower(s, Allocator allocator = allocator::heap())
 {
 	String copy = s.copy(allocator);
 	copy.convert_ascii_to_lower();
 	return copy;
 }

-fn String String.temp_ascii_to_lower(s, Allocator* allocator = mem::heap())
+fn String String.temp_ascii_to_lower(s, Allocator allocator = allocator::heap())
 {
-	return s.new_ascii_to_lower(mem::temp());
+	return s.new_ascii_to_lower(allocator::temp());
 }

+/**
+ * Convert a string to ASCII upper case.
+ *
+ * @param [inout] s
+ * @pure
+ **/
 fn void String.convert_ascii_to_upper(s)
 {
-	foreach (&c : s) if (c.is_lower()) *c -= 'a' - 'A';
+	foreach (&c : s) if (c.is_lower() @pure) *c -= 'a' - 'A';
 }

-fn String String.new_ascii_to_upper(s, Allocator* allocator = mem::heap())
+/**
+ * Returns a string converted to ASCII upper case.
+ *
+ * @param [in] s
+ * @param [inout] allocator
+ *
+ * @return `a new String converted to ASCII upper case.`
+ **/
+fn String String.new_ascii_to_upper(s, Allocator allocator = allocator::heap())
 {
 	String copy = s.copy(allocator);
 	copy.convert_ascii_to_upper();
@@ -449,32 +564,36 @@ fn StringIterator String.iterator(s)
 	return { s, 0 };
 }

+/**
+ * @param [in] s
+ * @return `a temporary String converted to ASCII upper case.`
+ **/
 fn String String.temp_ascii_to_upper(s)
 {
-	return s.new_ascii_to_upper(mem::temp());
+	return s.new_ascii_to_upper(allocator::temp());
 }

-fn String! new_from_utf32(Char32[] utf32, Allocator* allocator = mem::heap())
+fn String! new_from_utf32(Char32[] utf32, Allocator allocator = allocator::heap())
 {
 	usz len = conv::utf8len_for_utf32(utf32);
-	char* data = allocator.alloc_checked(len + 1)!;
-	defer catch allocator.free(data);
+	char* data = allocator::malloc_try(allocator, len + 1)!;
+	defer catch allocator::free(allocator, data);
 	conv::utf32to8_unsafe(utf32, data);
 	data[len] = 0;
 	return (String)data[:len];
 }

-fn String! new_from_utf16(Char16[] utf16, Allocator* allocator = mem::heap())
+fn String! new_from_utf16(Char16[] utf16, Allocator allocator = allocator::heap())
 {
 	usz len = conv::utf8len_for_utf16(utf16);
-	char* data = allocator.alloc_checked(len + 1)!;
-	defer catch allocator.free(data);
+	char* data = allocator::malloc_try(allocator, len + 1)!;
+	defer catch allocator::free(allocator, data);
 	conv::utf16to8_unsafe(utf16, data)!;
 	data[len] = 0;
 	return (String)data[:len];
 }

-fn String! new_from_wstring(WString wstring, Allocator* allocator = mem::heap())
+fn String! new_from_wstring(WString wstring, Allocator allocator = allocator::heap())
 {
 	usz utf16_len;
 	while (wstring[utf16_len] != 0) utf16_len++;
@@ -482,8 +601,8 @@ fn String! new_from_wstring(WString wstring, Allocator* allocator = mem::heap())
 	return new_from_utf16(utf16, allocator);
 }

-fn String! temp_from_wstring(WString wstring) => new_from_wstring(wstring, mem::temp()) @inline;
-fn String! temp_from_utf16(Char16[] utf16) => new_from_utf16(utf16, mem::temp()) @inline;
+fn String! temp_from_wstring(WString wstring) => new_from_wstring(wstring, allocator::temp()) @inline;
+fn String! temp_from_utf16(Char16[] utf16) => new_from_utf16(utf16, allocator::temp()) @inline;

 fn usz String.utf8_codepoints(s)
 {
@@ -495,7 +614,11 @@ fn usz String.utf8_codepoints(s)
 	return len;
 }

-macro String.to_integer(string, $Type)
+
+/**
+ * @require (base <= 10 && base > 1) || base == 16 : "Unsupported base"
+ **/
+macro String.to_integer(string, $Type, int base = 10)
 {
 	usz len = string.len;
 	usz index = 0;
@@ -515,8 +638,8 @@ macro String.to_integer(string, $Type)
 			break;
 	}
 	if (len == index) return NumberConversion.MALFORMED_INTEGER?;
-	$Type base = 10;
-	if (string[index] == '0')
+	$Type base_used = ($Type)base;
+	if (string[index] == '0' && base == 10)
 	{
 		index++;
 		if (index == len) return ($Type)0;
@@ -524,15 +647,15 @@ macro String.to_integer(string, $Type)
 		{
 			case 'x':
 			case 'X':
-				base = 16;
+				base_used = 16;
 				index++;
 			case 'b':
 			case 'B':
-				base = 2;
+				base_used = 2;
 				index++;
 			case 'o':
 			case 'O':
-				base = 8;
+				base_used = 8;
 				index++;
 			default:
 				break;
@@ -544,21 +667,21 @@ macro String.to_integer(string, $Type)
 	{
 		char c = {|
 			char ch = string[index++];
-			if (base != 16 || ch < 'A') return (char)(ch - '0');
-			if (ch <= 'F') return (char)(ch - 'A');
+			if (base_used != 16 || ch < 'A') return (char)(ch - '0');
+			if (ch <= 'F') return (char)(ch - 'A' + 10);
 			if (ch < 'a') return NumberConversion.MALFORMED_INTEGER?;
 			if (ch > 'f') return NumberConversion.MALFORMED_INTEGER?;
-			return (char)(ch - 'a');
+			return (char)(ch - 'a' + 10);
 		|}!;
-		if (c >= base) return NumberConversion.MALFORMED_INTEGER?;
+		if (c >= base_used) return NumberConversion.MALFORMED_INTEGER?;
 		value = {|
 			if (is_negative)
 			{
-				$Type new_value = value * base - c;
+				$Type new_value = value * base_used - c;
 				if (new_value > value) return NumberConversion.INTEGER_OVERFLOW?;
 				return new_value;
 			}
-			$Type new_value = value * base + c;
+			$Type new_value = value * base_used + c;
 			if (new_value < value) return NumberConversion.INTEGER_OVERFLOW?;
 			return new_value;
 		|}!;
@@ -566,17 +689,17 @@ macro String.to_integer(string, $Type)
 	return value;
 }

-fn int128! String.to_int128(s) => s.to_integer(int128);
-fn long! String.to_long(s) => s.to_integer(long);
-fn int! String.to_int(s) => s.to_integer(int);
-fn short! String.to_short(s) => s.to_integer(short);
-fn ichar! String.to_ichar(s) => s.to_integer(ichar);
+fn int128! String.to_int128(s, int base = 10) => s.to_integer(int128, base);
+fn long! String.to_long(s, int base = 10) => s.to_integer(long, base);
+fn int! String.to_int(s, int base = 10) => s.to_integer(int, base);
+fn short! String.to_short(s, int base = 10) => s.to_integer(short, base);
+fn ichar! String.to_ichar(s, int base = 10) => s.to_integer(ichar, base);

-fn uint128! String.to_uint128(s) => s.to_integer(uint128);
-fn ulong! String.to_ulong(s) => s.to_integer(ulong);
-fn uint! String.to_uint(s) => s.to_integer(uint);
-fn ushort! String.to_ushort(s) => s.to_integer(ushort);
-fn char! String.to_uchar(s) => s.to_integer(char);
+fn uint128! String.to_uint128(s, int base = 10) => s.to_integer(uint128, base);
+fn ulong! String.to_ulong(s, int base = 10) => s.to_integer(ulong, base);
+fn uint! String.to_uint(s, int base = 10) => s.to_integer(uint, base);
+fn ushort! String.to_ushort(s, int base = 10) => s.to_integer(ushort, base);
+fn char! String.to_uchar(s, int base = 10) => s.to_integer(char, base);

 fn double! String.to_double(s) => s.to_real(double);
 fn float! String.to_float(s) => s.to_real(float);
--- a/lib/std/core/string_iterator.c3
+++ b/lib/std/core/string_iterator.c3
@@ -13,11 +13,37 @@ fn void StringIterator.reset(&self)

 fn Char32! StringIterator.next(&self)
 {
-	usz len = self.utf8.len;
-	usz current = self.current;
-	if (current >= len) return IteratorResult.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;
+    usz len = self.utf8.len;
+    usz current = self.current;
+    if (current >= len) return IteratorResult.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)
+{
+    usz len = self.utf8.len;
+    usz current = self.current;
+    if (current >= len) return IteratorResult.NO_MORE_ELEMENT?;
+    usz read = (len - current < 4 ? len - current : 4);
+    Char32 res = conv::utf8_to_char32(&self.utf8[current], &read)!;
+    return res;
+}
+
+fn bool StringIterator.has_next(&self)
+{
+    return self.current < self.utf8.len;
+}
+
+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?;
+    Char32 res = conv::utf8_to_char32(&self.utf8[index], &read)!;
+    return res;
 }
--- a/lib/std/core/types.c3
+++ b/lib/std/core/types.c3
@@ -11,7 +11,7 @@ fault ConversionResult
 /**
 * @require $Type.kindof.is_int() || $Type.kindof == TypeKind.ENUM "Argument was not an integer"
 **/
-macro any_to_int(any* v, $Type)
+macro any_to_int(any v, $Type)
 {
 	typeid any_type = v.type;
 	TypeKind kind = any_type.kindof;
@@ -108,10 +108,10 @@ fn bool TypeKind.is_int(kind) @inline
 	return kind == TypeKind.SIGNED_INT || kind == TypeKind.UNSIGNED_INT;
 }

-macro bool is_subarray_convertable($Type)
+macro bool is_slice_convertable($Type)
 {
 	$switch ($Type.kindof)
-		$case SUBARRAY:
+		$case SLICE:
 			return true;
 		$case POINTER:
 			return $Type.inner.kindof == TypeKind.ARRAY;
@@ -120,10 +120,20 @@ macro bool is_subarray_convertable($Type)
 	$endswitch
 }

-macro bool is_bool($Type) => $Type.kindof == TypeKind.BOOL;
-macro bool is_int($Type) => $Type.kindof == TypeKind.SIGNED_INT || $Type.kindof == TypeKind.UNSIGNED_INT;
+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;

-macro bool is_intlike($Type)
+macro bool is_indexable($Type) @const
+{
+	return $defined($Type{}[0]);
+}
+
+macro bool is_ref_indexable($Type) @const
+{
+	return $defined(&$Type{}[0]);
+}
+
+macro bool is_intlike($Type) @const
 {
 	$switch ($Type.kindof)
 		$case SIGNED_INT:
@@ -136,7 +146,7 @@ macro bool is_intlike($Type)
 	$endswitch
 }

-macro bool is_underlying_int($Type)
+macro bool is_underlying_int($Type) @const
 {
 	$switch ($Type.kindof)
 		$case SIGNED_INT:
@@ -149,9 +159,9 @@ macro bool is_underlying_int($Type)
 	$endswitch
 }

-macro bool is_float($Type) => $Type.kindof == TypeKind.FLOAT;
+macro bool is_float($Type) @const  => $Type.kindof == TypeKind.FLOAT;

-macro bool is_floatlike($Type)
+macro bool is_floatlike($Type) @const
 {
 	$switch ($Type.kindof)
 		$case FLOAT:
@@ -163,12 +173,12 @@ macro bool is_floatlike($Type)
 	$endswitch
 }

-macro bool is_vector($Type)
+macro bool is_vector($Type) @const
 {
 	return $Type.kindof == TypeKind.VECTOR;
 }

-macro TypeKind inner_kind($Type)
+macro TypeKind inner_kind($Type) @const
 {
 	$if $Type.kindof == TypeKind.DISTINCT:
 		return inner_kind($typefrom($Type.inner));
@@ -177,26 +187,26 @@ macro TypeKind inner_kind($Type)
 	$endif
 }

-macro bool is_same($TypeA, $TypeB)
+macro bool is_same($TypeA, $TypeB) @const
 {
 	return $TypeA.typeid == $TypeB.typeid;
 }

-macro bool @has_same(#a, #b, ...)
+macro bool @has_same(#a, #b, ...) @const
 {
 	var $type_a = @typeid(#a);
 	$if $type_a != @typeid(#b):
 		return false;
 	$endif
 	$for (var $i = 0; $i < $vacount; $i++)
-		$if @typeid($vaexpr($i)) != $type_a:
+		$if @typeid($vaexpr[$i]) != $type_a:
 			return false;
 		$endif
 	$endfor
 	return true;
 }

-macro bool may_load_atomic($Type)
+macro bool may_load_atomic($Type) @const
 {
 	$switch ($Type.kindof)
 	$case SIGNED_INT:
@@ -211,7 +221,7 @@ macro bool may_load_atomic($Type)
 	$endswitch
 }

-macro lower_to_atomic_compatible_type($Type) 
+macro lower_to_atomic_compatible_type($Type) @const
 {
 	$switch ($Type.kindof)
    $case SIGNED_INT:
@@ -237,10 +247,10 @@ macro lower_to_atomic_compatible_type($Type)
  $endswitch
 }

-macro bool is_promotable_to_floatlike($Type) => types::is_floatlike($Type) || types::is_int($Type);
-macro bool is_promotable_to_float($Type) => types::is_float($Type) || types::is_int($Type);
+macro bool is_promotable_to_floatlike($Type) @const  => types::is_floatlike($Type) || types::is_int($Type);
+macro bool is_promotable_to_float($Type) @const  => types::is_float($Type) || types::is_int($Type);

-macro bool is_same_vector_type($Type1, $Type2)
+macro bool is_same_vector_type($Type1, $Type2) @const
 {
 	$if $Type1.kindof != TypeKind.VECTOR:
 		return $Type2.kindof != TypeKind.VECTOR;
@@ -249,7 +259,7 @@ macro bool is_same_vector_type($Type1, $Type2)
 	$endif
 }

-macro bool is_equatable_type($Type)
+macro bool is_equatable_type($Type) @const
 {
 	$if $defined($Type.less) || $defined($Type.compare_to) || $defined($Type.equals):
 		return true;
@@ -261,17 +271,31 @@ macro bool is_equatable_type($Type)
 /**
 * Checks if a type implements the copy protocol.
 **/
-macro bool implements_copy($Type)
+macro bool implements_copy($Type) @const
 {
 	return $defined($Type.copy) && $defined($Type.free);
 }

-macro bool is_equatable_value(value)
+macro bool is_equatable_value(value) @deprecated
 {
 	return is_equatable_type($typeof(value));
 }

-macro bool is_comparable_value(value)
+macro bool @equatable_value(#value) @const
+{
+	return is_equatable_type($typeof(#value));
+}
+
+macro bool @comparable_value(#value) @const
+{
+	$if $defined(#value.less) || $defined(#value.compare_to):
+		return true;
+	$else
+		return $typeof(#value).is_ordered;
+	$endif
+}
+
+macro bool is_comparable_value(value) @deprecated
 {
 	$if $defined(value.less) || $defined(value.compare_to):
 		return true;
@@ -298,10 +322,11 @@ enum TypeKind : char
 	FUNC,
 	OPTIONAL,
 	ARRAY,
-	SUBARRAY,
+	SLICE,
 	VECTOR,
 	DISTINCT,
 	POINTER,
+	INTERFACE,
 }

 struct TypeEnum
--- a/lib/std/core/values.c3
+++ b/lib/std/core/values.c3
@@ -1,21 +1,21 @@
 module std::core::values;

-macro typeid @typeid(#value) @builtin => $typeof(#value).typeid;
-macro TypeKind @typekind(#value) @builtin => $typeof(#value).kindof;
-macro bool @typeis(#value, $Type) @builtin => $typeof(#value).typeid == $Type.typeid;
+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;
 /**
 * Return true if two values have the same type before any conversions.
 **/
-macro bool @is_same_type(#value1, #value2) => $typeof(#value1).typeid == $typeof(#value2).typeid;
-macro bool @is_bool(#value) => types::is_bool($typeof(#value));
-macro bool @is_int(#value) => types::is_int($typeof(#value));
-macro bool @is_floatlike(#value) => types::is_floatlike($typeof(#value));
-macro bool @is_float(#value) => types::is_float($typeof(#value));
-macro bool @is_promotable_to_floatlike(#value) => types::is_promotable_to_floatlike($typeof(#value));
-macro bool @is_promotable_to_float(#value) => types::is_promotable_to_float($typeof(#value));
-macro bool @is_vector(#value) => types::is_vector($typeof(#value));
-macro bool @is_same_vector_type(#value1, #value2) => types::is_same_vector_type($typeof(#value1), $typeof(#value2));
-macro bool @assign_to(#value1, #value2) => $assignable(#value1, $typeof(#value2));
+macro bool @is_same_type(#value1, #value2) @const => $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_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 promote_int(x)
 {
@@ -26,5 +26,21 @@ macro promote_int(x)
 	$endif
 }

-macro TypeKind @inner_kind(#value) => types::inner_kind($typeof(#value));
+macro promote_int_same(x, y)
+{
+	$if @is_int(x):
+		$switch
+		$case @is_vector(y) &&& $typeof(y).inner == float.typeid:
+			return (float)x;
+		$case $typeof(y).typeid == float.typeid:
+			return (float)x;
+		$default:
+			return (double)x;
+		$endswitch
+	$else
+		return x;
+	$endif
+}
+
+macro TypeKind @inner_kind(#value) @const => types::inner_kind($typeof(#value));

--- a/lib/std/crypto/rc4.c3
+++ b/lib/std/crypto/rc4.c3
@@ -28,6 +28,18 @@ fn void Rc4.init(&self, char[] key)
 	self.j = 0;
 }

+/**
+ * Run a single pass of en/decryption using a particular key.
+ * @param [in] key
+ * @param [inout] data
+ **/
+fn void crypt(char[] key, char[] data)
+{
+	Rc4 rc4;
+	rc4.init(key);
+	rc4.crypt(data, data);
+}
+
 /**
 * Encrypt or decrypt a sequence of bytes.
 *
--- a/lib/std/encoding/csv.c3
+++ b/lib/std/encoding/csv.c3
@@ -3,22 +3,22 @@ import std::io;

 struct CsvReader
 {
-	InStream* stream;
+	InStream stream;
 	String separator;
 }

-fn void CsvReader.init(&self, InStream* stream, String separator = ",")
+fn void CsvReader.init(&self, InStream stream, String separator = ",")
 {
 	self.stream = stream;
 	self.separator = separator;
 }

-fn String[]! CsvReader.read_new_row(self, Allocator* allocator = mem::heap())
+fn String[]! CsvReader.read_new_row(self, Allocator allocator = allocator::heap())
 {
-	return self.read_new_row_with_allocator(mem::temp()) @inline;
+	return self.read_new_row_with_allocator(allocator::temp()) @inline;
 }

-fn String[]! CsvReader.read_new_row_with_allocator(self, Allocator* allocator = mem::heap())
+fn String[]! CsvReader.read_new_row_with_allocator(self, Allocator allocator = allocator::heap())
 {
 	@pool(allocator)
 	{
@@ -28,7 +28,7 @@ fn String[]! CsvReader.read_new_row_with_allocator(self, Allocator* allocator =

 fn String[]! CsvReader.read_temp_row(self)
 {
-	return self.read_new_row_with_allocator(mem::temp()) @inline;
+	return self.read_new_row_with_allocator(allocator::temp()) @inline;
 }

 fn void! CsvReader.skip_row(self) @maydiscard
@@ -45,7 +45,7 @@ macro CsvReader.@each_row(self, int rows = int.max; @body(String[] row))
 	String sep = self.separator;
 	while (rows--)
 	{
-		@stack_mem(512; Allocator* mem)
+		@stack_mem(512; Allocator mem)
 		{
 			String[] parts;
 			@pool()
--- a/lib/std/encoding/json.c3
+++ b/lib/std/encoding/json.c3
@@ -15,11 +15,29 @@ fault JsonParsingError
 	INVALID_NUMBER,
 }

-fn Object*! parse(InStream* s, Allocator* allocator = mem::heap())
+fn Object*! parse_string(String s, Allocator allocator = allocator::heap())
+{
+	return parse(ByteReader{}.init(s), allocator);
+}
+
+fn Object*! temp_parse_string(String s)
+{
+	return parse(ByteReader{}.init(s), allocator::temp());
+}
+
+fn Object*! parse(InStream s, Allocator allocator = allocator::heap())
 {
 	JsonContext context = { .last_string = dstring::new_with_capacity(64, allocator), .stream = s, .allocator = allocator };
 	defer context.last_string.free();
-	return parse_any(&context);
+	@pool(allocator)
+	{
+		return parse_any(&context);
+	};
+}
+
+fn Object*! temp_parse(InStream s)
+{
+	return parse(s, allocator::temp());
 }

 // -- Implementation follows --
@@ -44,8 +62,8 @@ enum JsonTokenType @local
 struct JsonContext @local
 {
 	uint line;
-	InStream* stream;
-	Allocator* allocator;
+	InStream stream;
+	Allocator allocator;
 	JsonTokenType token;
 	DString last_string;
 	double last_number;
@@ -170,7 +188,7 @@ fn Object*! parse_array(JsonContext* context) @local
 	while (token != JsonTokenType.RBRACKET)
 	{
 		Object* element = parse_from_token(context, token)!;
-		list.append(element);
+		list.push(element);
 		token = advance(context)!;
 		if (token == JsonTokenType.COMMA)
 		{
--- a/lib/std/io/bits.c3
+++ b/lib/std/io/bits.c3
@@ -2,12 +2,12 @@ module std::io;

 struct BitReader
 {
-	InStream* reader;
+	InStream reader;
 	uint bits;
 	uint len;
 }

-fn void BitReader.init(&self, InStream* byte_reader)
+fn void BitReader.init(&self, InStream byte_reader)
 {
 	*self = { .reader = byte_reader };
 }
@@ -40,12 +40,12 @@ fn char! BitReader.read_bits(&self, uint nbits)

 struct BitWriter
 {
-	OutStream* writer;
+	OutStream writer;
 	uint bits;
 	uint len;
 }

-fn void BitWriter.init(&self, OutStream* byte_writer)
+fn void BitWriter.init(&self, OutStream byte_writer)
 {
 	*self = { .writer = byte_writer };
 }
--- a/lib/std/io/file.c3
+++ b/lib/std/io/file.c3
@@ -7,7 +7,7 @@ struct File (InStream, OutStream)
 }

 module std::io::file;
-import libc;
+import libc, std::io::path, std::io::os;

 fn File! open(String filename, String mode)
 {
@@ -161,14 +161,14 @@ fn char[]! load_buffer(String filename, char[] buffer)

 }

-fn char[]! load_new(String filename, Allocator* allocator = mem::heap())
+fn char[]! load_new(String filename, Allocator allocator = allocator::heap())
 {
 	File file = open(filename, "rb")!;
 	defer (void)file.close();
 	usz len = file.seek(0, END)!;
 	file.seek(0, SET)!;
-	char* data = allocator.alloc_checked(len)!;
-	defer catch allocator.free(data);
+	char* data = allocator::malloc_try(allocator, len)!;
+	defer catch allocator::free(allocator, data);
 	usz read = 0;
 	while (read < len)
 	{
@@ -179,7 +179,7 @@ fn char[]! load_new(String filename, Allocator* allocator = mem::heap())

 fn char[]! load_temp(String filename)
 {
-	return load_new(filename, mem::temp());
+	return load_new(filename, allocator::temp());
 }

 /**
--- a/lib/std/io/formatter.c3
+++ b/lib/std/io/formatter.c3
@@ -6,7 +6,7 @@ const int PRINTF_NTOA_BUFFER_SIZE = 256;

 interface Printable
 {
-	fn String to_new_string(Allocator *allocator) @optional;
+	fn String to_new_string(Allocator allocator) @optional;
 	fn usz! to_format(Formatter* formatter) @optional;
 }

@@ -72,7 +72,7 @@ fn usz! Formatter.out(&self, char c) @private
 	return 1;
 }

-fn usz! Formatter.print_with_function(&self, Printable* arg)
+fn usz! Formatter.print_with_function(&self, Printable arg)
 {
 	if (&arg.to_format)
 	{
@@ -85,6 +85,7 @@ fn usz! Formatter.print_with_function(&self, Printable* arg)
 			self.width = old_width;
 			self.prec = old_prec;
 		}
+		if (!arg) return self.out_substr("(null)");
 		return arg.to_format(self);
 	}
 	if (&arg.to_new_string)
@@ -98,16 +99,17 @@ fn usz! Formatter.print_with_function(&self, Printable* arg)
 			self.width = old_width;
 			self.prec = old_prec;
 		}
-		@pool()
+		if (!arg) return self.out_substr("(null)");
+		@stack_mem(1024; Allocator mem)
 		{
-			return self.out_substr(arg.to_new_string(mem::temp()));
+			return self.out_substr(arg.to_new_string(mem));
 		};
 	}
 	return SearchResult.MISSING?;
 }


-fn usz! Formatter.out_str(&self, any* arg) @private
+fn usz! Formatter.out_str(&self, any arg) @private
 {
 	switch (arg.type.kindof)
 	{
@@ -119,7 +121,7 @@ fn usz! Formatter.out_str(&self, any* arg) @private
 		case FAULT:
 			return self.out_substr((*(anyfault*)arg.ptr).nameof);
 		case ANY:
-			return self.out_str(*(any**)arg);
+			return self.out_str(*(any*)arg);
 		case OPTIONAL:
 			unreachable();
 		case SIGNED_INT:
@@ -149,18 +151,9 @@ fn usz! Formatter.out_str(&self, any* arg) @private
 			return self.out_substr(*(bool*)arg.ptr ? "true" : "false");
 		default:
 	}
-	usz! n = self.print_with_function((Printable*)arg);
-	if (catch err = n)
-	{
-		case SearchResult.MISSING:
-			break;
-		default:
-			return err?;
-	}
-	else
-	{
-		return n;
-	}
+	usz! n = self.print_with_function((Printable)arg);
+	if (try n) return n;
+	if (@catch(n) != SearchResult.MISSING) n!;
 	switch (arg.type.kindof)
 	{
 		case ENUM:
@@ -178,14 +171,23 @@ fn usz! Formatter.out_str(&self, any* arg) @private
 		case DISTINCT:
 			if (arg.type == ZString.typeid)
 			{
-				return self.out_substr(((ZString*)arg).str_view());
+				return self.out_substr(*(ZString*)arg ? ((ZString*)arg).str_view() : "(null)");
 			}
 			if (arg.type == DString.typeid)
 			{
-				return self.out_substr(((DString*)arg).str_view());
+				return self.out_substr(*(DString*)arg ? ((DString*)arg).str_view() : "(null)");
 			}
 			return self.out_str(arg.as_inner());
 		case POINTER:
+			typeid inner = arg.type.inner;
+			void** pointer = arg.ptr;
+			if (arg.type.inner != void.typeid)
+			{
+				any deref = any_make(*pointer, inner);
+				n = self.print_with_function((Printable)deref);
+				if (try n) return n;
+				if (@catch(n) != SearchResult.MISSING) n!;
+			}
 			PrintFlags flags = self.flags;
 			uint width = self.width;
 			defer
@@ -193,8 +195,8 @@ fn usz! Formatter.out_str(&self, any* arg) @private
 				self.flags = flags;
 				self.width = width;
 			}
-			self.flags = {};
 			self.width = 0;
+			self.out_substr("0x")!;
 			return self.ntoa_any(arg, 16);
 		case ARRAY:
 			// this is SomeType[*] so grab the "SomeType"
@@ -246,7 +248,7 @@ fn usz! Formatter.out_str(&self, any* arg) @private
 			}
 			len += self.out_substr(">]")!;
 			return len;
-		case SUBARRAY:
+		case SLICE:
 			// this is SomeType[] so grab the "SomeType"
 			typeid inner = arg.type.inner;
 			if (inner == char.typeid)
@@ -291,7 +293,7 @@ fn void! out_null_fn(void* data @unused, char c @unused) @private



-fn usz! Formatter.vprintf(&self, String format, any*[] anys)
+fn usz! Formatter.vprintf(&self, String format, any[] anys)
 {
 	if (!self.out_fn)
 	{
@@ -358,7 +360,7 @@ fn usz! Formatter.vprintf(&self, String format, any*[] anys)
 		// evaluate specifier
 		uint base = 0;
 		if (variant_index >= anys.len) return PrintFault.MISSING_ARG?;
-		any* current = anys[variant_index++];
+		any current = anys[variant_index++];
 		switch (c)
 		{
 			case 'd':
--- a/lib/std/io/formatter_private.c3
+++ b/lib/std/io/formatter_private.c3
@@ -1,4 +1,5 @@
 module std::io;
+import std::math;

 const char[16] XDIGITS_H = "0123456789ABCDEF";
 const char[16] XDIGITS_L = "0123456789abcdef";
@@ -9,7 +10,7 @@ fn usz! Formatter.adjust(&self, usz len) @local
 	return self.pad(' ', self.width, len);
 }

-fn uint128! int_from_any(any* arg, bool *is_neg) @private
+fn uint128! int_from_any(any arg, bool *is_neg) @private
 {
 	switch (arg.type.kindof)
 	{
@@ -62,14 +63,11 @@ fn uint128! int_from_any(any* arg, bool *is_neg) @private
 	}
 }

-fn FloatType! float_from_any(any* arg) @private
+fn FloatType! float_from_any(any arg) @private
 {
 	$if env::F128_SUPPORT:
 		if (arg.type == float128.typeid) return (FloatType)*((float128*)arg.ptr);
 	$endif
-	$if env::F16_SUPPORT:
-		if (arg.type == float16.typeid) return *((float16*)arg.ptr);
-	$endif
 	if (arg.type.kindof == TypeKind.DISTINCT)
 	{
 		return float_from_any(arg.as_inner());
@@ -587,14 +585,14 @@ fn usz! Formatter.ntoa_format(&self, String buf, usz len, bool negative, uint ba
 }


-fn usz! Formatter.ntoa_any(&self, any* arg, uint base) @private
+fn usz! Formatter.ntoa_any(&self, any arg, uint base) @private
 {
 	bool is_neg;
 	uint128 val = int_from_any(arg, &is_neg)!!;
 	return self.ntoa(val, is_neg, base) @inline;
 }

-fn usz! Formatter.out_char(&self, any* arg) @private
+fn usz! Formatter.out_char(&self, any arg) @private
 {
 	usz len = 1;
 	uint l = 1;
@@ -630,15 +628,15 @@ fn usz! Formatter.out_reverse(&self, char[] buf) @private
 	usz buffer_start_idx = self.idx;
 	usz len = buf.len;
 	// pad spaces up to given width
-	if (!self.flags.zeropad)
+	if (!self.flags.zeropad && !self.flags.left)
 	{
-		n += self.adjust(len)!;
+    	n += self.pad(' ', self.width, len)!;
 	}
 	// reverse string
 	while (len) n += self.out(buf[--len])!;

 	// append pad spaces up to given width
-	n += self.adjust(self.idx - buffer_start_idx)!;
+	n += self.adjust(n)!;
 	return n;
 }

@@ -648,21 +646,21 @@ fn void! printf_advance_format(usz format_len, usz *index_ptr) @inline @private
 	if (val >= format_len) return FormattingFault.UNTERMINATED_FORMAT?;
 }

-fn any*! next_any(any** args_ptr, usz args_len, usz* arg_index_ptr) @inline @private
+fn any! next_any(any* args_ptr, usz args_len, usz* arg_index_ptr) @inline @private
 {
 	if (*arg_index_ptr >= args_len) return FormattingFault.MISSING_ARG?;
 	return args_ptr[(*arg_index_ptr)++];
 }

 fn int! printf_parse_format_field(
-	any** args_ptr, usz args_len, usz* args_index_ptr,
+	any* args_ptr, usz args_len, usz* args_index_ptr,
 	char* format_ptr, usz format_len, usz* index_ptr) @inline @private
 {
 	char c = format_ptr[*index_ptr];
 	if (c.is_digit()) return simple_atoi(format_ptr, format_len, index_ptr);
 	if (c != '*') return 0;
 	printf_advance_format(format_len, index_ptr)!;
-	any* val = next_any(args_ptr, args_len, args_index_ptr)!;
+	any val = next_any(args_ptr, args_len, args_index_ptr)!;
 	if (!val.type.kindof.is_int()) return FormattingFault.INVALID_WIDTH_ARG?;
 	uint! intval = types::any_to_int(val, int);
 	return intval ?? FormattingFault.INVALID_WIDTH_ARG?;
--- a/lib/std/io/io.c3
+++ b/lib/std/io/io.c3
@@ -46,12 +46,18 @@ fault IoError


 /**
- * @param stream
- * @require @is_instream(stream)
+ * Read from a stream (default is stdin) to the next "\n"
+ * or to the end of the stream, whatever comes first.
+ * "\r" will be filtered from the String.
+ *
+ * @param stream `The stream to read from.`
+ * @require @is_instream(stream) `The stream must implement InStream.`
+ * @param [inout] allocator `the allocator to use.`
+ * @return `The string containing the data read.`
 **/
-macro String! readline(stream = io::stdin(), Allocator* allocator = mem::heap())
+macro String! readline(stream = io::stdin(), Allocator allocator = allocator::heap())
 {
-	bool $is_stream = @typeid(stream) == InStream*.typeid;
+	bool $is_stream = @typeis(stream, InStream);
 	$if $is_stream:
 		$typeof(&stream.read_byte) func = &stream.read_byte;
 		char val = func((void*)stream)!;
@@ -84,38 +90,67 @@ macro String! readline(stream = io::stdin(), Allocator* allocator = mem::heap())
    };
 }

-macro String! treadline(stream = io::stdin()) => readline(stream, mem::temp()) @inline;
+/**
+ * Reads a string, see `readline`, except the it is allocated
+ * on the temporary allocator and does not need to be freed.
+ *
+ * @param stream `The stream to read from.`
+ * @require @is_instream(stream) `The stream must implement InStream.`
+ * @return `The temporary string containing the data read.`
+ **/
+macro String! treadline(stream = io::stdin())
+{
+	return readline(stream, allocator::temp()) @inline;
+}

 /**
- * @require @is_outstream(out) "The output must implement OutStream"
+ * Print a value to a stream.
+ *
+ * @param out `the stream to print to`
+ * @param x `the value to print`
+ * @require @is_outstream(out) `The output must implement OutStream.`
+ * @return `the number of bytes printed.`
 */
 macro usz! fprint(out, x)
 {
 	var $Type = $typeof(x);
 	$switch ($Type)
-	$case String:
-		return out.write(x);
-	$case ZString:
-		return out.write(x.str_view());
-	$case DString:
-		return out.write(x.str_view());
-	$default:
-		$if $assignable(x, String):
-			return out.write((String)x);
-		$else
-			return fprintf(out, "%s", x);
-		$endif
+		$case String: return out.write(x);
+		$case ZString: return out.write(x.str_view());
+		$case DString: return out.write(x.str_view());
+		$default:
+			$if $assignable(x, String):
+				return out.write((String)x);
+			$else
+				return fprintf(out, "%s", x);
+			$endif
 	$endswitch
 }

-fn usz! fprintf(OutStream* out, String format, args...)
+/**
+ * Prints using a 'printf'-style formatting string.
+ * See `printf` for details on formatting.
+ *
+ * @param [inout] out `The OutStream to print to`
+ * @param [in] format `The printf-style format string`
+ * @return `the number of characters printed`
+ **/
+fn usz! fprintf(OutStream out, String format, args...)
 {
 	Formatter formatter;
 	formatter.init(&out_putstream_fn, &out);
 	return formatter.vprintf(format, args);
 }

-fn usz! fprintfn(OutStream* out, String format, args...) @maydiscard
+/**
+ * Prints using a 'printf'-style formatting string,
+ * appending '\n' at the end. See `printf`.
+ *
+ * @param [inout] out `The OutStream to print to`
+ * @param [in] format `The printf-style format string`
+ * @return `the number of characters printed`
+ **/
+fn usz! fprintfn(OutStream out, String format, args...) @maydiscard
 {
 	Formatter formatter;
 	formatter.init(&out_putstream_fn, &out);
@@ -133,7 +168,7 @@ macro usz! fprintn(out, x = "")
 	usz len = fprint(out, x)!;
 	out.write_byte('\n')!;
 	$switch
-		$case @typeid(out) == OutStream*.typeid:
+		$case @typeid(out) == OutStream.typeid:
 			if (&out.flush) out.flush()!;
 		$case $defined(out.flush):
 			out.flush()!;
@@ -141,21 +176,37 @@ macro usz! fprintn(out, x = "")
 	return len + 1;
 }

+/**
+ * Print any value to stdout.
+ **/
 macro void print(x)
 {
 	(void)fprint(io::stdout(), x);
 }

+/**
+ * Print any value to stdout, appending an '\n’ after.
+ *
+ * @param x "The value to print"
+ **/
 macro void printn(x = "")
 {
 	(void)fprintn(io::stdout(), x);
 }

+/**
+ * Print any value to stderr.
+ **/
 macro void eprint(x)
 {
 	(void)fprint(io::stderr(), x);
 }

+/**
+ * Print any value to stderr, appending an '\n’ after.
+ *
+ * @param x "The value to print"
+ **/
 macro void eprintn(x)
 {
 	(void)fprintn(io::stderr(), x);
@@ -164,7 +215,7 @@ macro void eprintn(x)

 fn void! out_putstream_fn(void* data, char c) @private
 {
-	OutStream** stream = data;
+	OutStream* stream = data;
 	return (*stream).write_byte(c);
 }

@@ -173,6 +224,20 @@ fn void! out_putchar_fn(void* data @unused, char c) @private
 	libc::putchar(c);
 }

+/**
+ * Prints using a 'printf'-style formatting string.
+ * To print integer numbers, use "%d" or "%x"/"%X,
+ * the latter gives the hexadecimal representation.
+ *
+ * All types can be printed using "%s" which gives
+ * the default representation of the value.
+ *
+ * To create a custom output for a type, implement
+ * the Printable interface.
+ *
+ * @param [in] format `The printf-style format string`
+ * @return `the number of characters printed`
+ **/
 fn usz! printf(String format, args...) @maydiscard
 {
 	Formatter formatter;
@@ -180,6 +245,13 @@ fn usz! printf(String format, args...) @maydiscard
 	return formatter.vprintf(format, args);
 }

+/**
+ * Prints using a 'printf'-style formatting string,
+ * appending '\n' at the end. See `printf`.
+ *
+ * @param [in] format `The printf-style format string`
+ * @return `the number of characters printed`
+ **/
 fn usz! printfn(String format, args...) @maydiscard
 {
 	Formatter formatter;
@@ -190,19 +262,33 @@ fn usz! printfn(String format, args...) @maydiscard
 	return len + 1;
 }

+/**
+ * Prints using a 'printf'-style formatting string
+ * to stderr.
+ *
+ * @param [in] format `The printf-style format string`
+ * @return `the number of characters printed`
+ **/
 fn usz! eprintf(String format, args...) @maydiscard
 {
 	Formatter formatter;
-	OutStream* stream = stderr();
+	OutStream stream = stderr();
 	formatter.init(&out_putstream_fn, &stream);
 	return formatter.vprintf(format, args);
 }


+/**
+ * Prints using a 'printf'-style formatting string,
+ * to stderr appending '\n' at the end. See `printf`.
+ *
+ * @param [in] format `The printf-style format string`
+ * @return `the number of characters printed`
+ **/
 fn usz! eprintfn(String format, args...) @maydiscard
 {
 	Formatter formatter;
-	OutStream* stream = stderr();
+	OutStream stream = stderr();
 	formatter.init(&out_putstream_fn, &stream);
 	usz len = formatter.vprintf(format, args)! + 1;
 	stderr().write_byte('\n')!;
@@ -210,6 +296,14 @@ fn usz! eprintfn(String format, args...) @maydiscard
 	return len;
 }

+/**
+ * Prints using a 'printf'-style formatting string,
+ * to a string buffer. See `printf`.
+ *
+ * @param [inout] buffer `The buffer to print to`
+ * @param [in] format `The printf-style format string`
+ * @return `a slice formed from the "buffer" with the resulting length.`
+ **/
 fn char[]! bprintf(char[] buffer, String format, args...) @maydiscard
 {
 	Formatter formatter;
@@ -219,6 +313,7 @@ fn char[]! bprintf(char[] buffer, String format, args...) @maydiscard
 	return buffer[:data.written];
 }

+// Used to print to a buffer.
 fn void! out_buffer_fn(void *data, char c) @private
 {
 	BufferData *buffer_data = data;
@@ -226,22 +321,30 @@ fn void! out_buffer_fn(void *data, char c) @private
 	buffer_data.buffer[buffer_data.written++] = c;
 }

-
+// Used for buffer printing
 struct BufferData @private
 {
 	char[] buffer;
 	usz written;
 }

-
+// Only available with LIBC
 module std::io @if (env::LIBC);
 import libc;

+/**
+ * Libc `putchar`, prints a single character to stdout.
+ **/
 fn void putchar(char c) @inline
 {
 	libc::putchar(c);
 }

+/**
+ * Get standard out.
+ *
+ * @return `stdout as a File`
+ **/
 fn File* stdout()
 {
 	static File file;
@@ -249,6 +352,11 @@ fn File* stdout()
 	return &file;
 }

+/**
+ * Get standard err.
+ *
+ * @return `stderr as a File`
+ **/
 fn File* stderr()
 {
 	static File file;
@@ -256,6 +364,11 @@ fn File* stderr()
 	return &file;
 }

+/**
+ * Get standard in.
+ *
+ * @return `stdin as a File`
+ **/
 fn File* stdin()
 {
 	static File file;
@@ -271,7 +384,7 @@ File stderr_file;

 fn void putchar(char c) @inline
 {
-	(void)stdout_file.putc(c);
+	(void)stdout_file.write_byte(c);
 }

 fn File* stdout()
--- a/lib/std/io/os/chdir.c3
+++ b/lib/std/io/os/chdir.c3
@@ -1,5 +1,5 @@
 module std::io::os;
-import libc;
+import std::io::path, libc, std::os;

 macro void! native_chdir(Path path)
 {
--- a/lib/std/io/os/fileinfo.c3
+++ b/lib/std/io/os/fileinfo.c3
@@ -1,5 +1,5 @@
 module std::io::os;
-import libc;
+import libc, std::os, std::io;

 fn void! native_stat(Stat* stat, String path) @if(env::DARWIN || env::LINUX)
 {
@@ -95,7 +95,7 @@ fn bool native_is_file(String path)
 		$case env::DARWIN:
 		$case env::LINUX:
 			Stat stat;
-			return @ok(native_stat(&stat, path)) && stat.st_mode & libc::S_IFREG;
+			return @ok(native_stat(&stat, path)) && libc_S_ISTYPE(stat.st_mode, libc::S_IFREG);
 		$default:
 			File! f = file::open(path, "r");
 			defer (void)f.close();
@@ -107,7 +107,7 @@ fn bool native_is_dir(String path)
 {
 	$if env::DARWIN || env::LINUX:
 		Stat stat;
-		return @ok(native_stat(&stat, path)) && stat.st_mode & libc::S_IFDIR;
+		return @ok(native_stat(&stat, path)) && libc_S_ISTYPE(stat.st_mode, libc::S_IFDIR);
 	$else
 		return native_file_or_dir_exists(path) && !native_is_file(path);
 	$endif
--- a/lib/std/io/os/getcwd.c3
+++ b/lib/std/io/os/getcwd.c3
@@ -1,7 +1,7 @@
 module std::io::os;
-import libc;
+import libc, std::os;

-macro String! getcwd(Allocator* allocator = mem::heap())
+macro String! getcwd(Allocator allocator = allocator::heap())
 {
 	$switch
 		$case env::WIN32:
--- a/lib/std/io/os/ls.c3
+++ b/lib/std/io/os/ls.c3
@@ -1,9 +1,10 @@
-module std::io::file::os @if(env::POSIX);
+module std::io::os @if(env::POSIX);
+import std::io, std::os;

-fn PathList! native_ls(Path dir, bool no_dirs, bool no_symlinks, String mask, Allocator* allocator)
+fn PathList! native_ls(Path dir, bool no_dirs, bool no_symlinks, String mask, Allocator allocator)
 {
 	PathList list;
-	list.init_new(.allocator = allocator);
+	list.new_init(.allocator = allocator);
 	DIRPtr directory = posix::opendir(dir.str_view() ? dir.as_zstr() : (ZString)".");
 	defer if (directory) posix::closedir(directory);
 	if (!directory) return (path::is_dir(dir) ? IoError.CANNOT_READ_DIR : IoError.FILE_NOT_DIR)?;
@@ -15,17 +16,18 @@ fn PathList! native_ls(Path dir, bool no_dirs, bool no_symlinks, String mask, Al
 		if (entry.d_type == posix::DT_LNK && no_symlinks) continue;
 		if (entry.d_type == posix::DT_DIR && no_dirs) continue;
 		Path path = path::new(name, allocator)!!;
-		list.append(path);
+		list.push(path);
 	}
 	return list;
 }

 module std::io::os @if(env::WIN32);
+import std::time, std::os, std::io;

-fn PathList! native_ls(Path dir, bool no_dirs, bool no_symlinks, String mask, Allocator* allocator)
+fn PathList! native_ls(Path dir, bool no_dirs, bool no_symlinks, String mask, Allocator allocator)
 {
 	PathList list;
-	list.init_new(.allocator = allocator);
+	list.new_init(.allocator = allocator);

 	@pool(allocator)
 	{
@@ -41,7 +43,7 @@ fn PathList! native_ls(Path dir, bool no_dirs, bool no_symlinks, String mask, Al
 			{
 				String filename = string::temp_from_wstring((WString)&find_data.cFileName)!;
 				if (filename == ".." || filename == ".") continue;
-				list.append(path::new(filename, allocator)!);
+				list.push(path::new(filename, allocator)!);
 			};
 		} while (win32::findNextFileW(find, &find_data));
 		return list;
--- a/lib/std/io/os/rmtree.c3
+++ b/lib/std/io/os/rmtree.c3
@@ -1,5 +1,5 @@
-module std::io::file::os @if(env::POSIX);
-import libc;
+module std::io::os @if(env::POSIX);
+import std::io, std::os, libc;

 /**
 * @require dir.str_view()
@@ -16,7 +16,7 @@ fn void! native_rmtree(Path dir)
 		{
 			String name = ((ZString)&entry.name).str_view();
 			if (!name || name == "." || name == "..") continue;
-			Path new_path = dir.tappend(name)!;
+			Path new_path = dir.temp_append(name)!;
 			if (entry.d_type == posix::DT_DIR)
 			{
 				native_rmtree(new_path)!;
@@ -33,6 +33,7 @@ fn void! native_rmtree(Path dir)
 }

 module std::io::os @if(env::WIN32);
+import std::io, std::time, std::os;

 fn void! native_rmtree(Path path)
 {
@@ -46,9 +47,9 @@ fn void! native_rmtree(Path path)
 	{
 		@pool()
 		{
-			String filename = string::new_from_wstring((WString)&find_data.cFileName, mem::temp())!;
+			String filename = string::new_from_wstring((WString)&find_data.cFileName, allocator::temp())!;
 			if (filename == "." || filename == "..") continue;
-			Path file_path = path.tappend(filename)!;
+			Path file_path = path.temp_append(filename)!;
 			if (find_data.dwFileAttributes & win32::FILE_ATTRIBUTE_DIRECTORY)
 			{
 				native_rmtree(file_path)!;
--- a/lib/std/io/os/temp_directory.c3
+++ b/lib/std/io/os/temp_directory.c3
@@ -1,6 +1,7 @@
 module std::io::os @if(env::LIBC);
+import std::io::path, std::os;

-fn Path! native_temp_directory(Allocator* allocator = mem::heap()) @if(!env::WIN32)
+fn Path! native_temp_directory(Allocator allocator = allocator::heap()) @if(!env::WIN32)
 {
 	foreach (String env : { "TMPDIR", "TMP", "TEMP", "TEMPDIR" })
 	{
@@ -10,21 +11,22 @@ fn Path! native_temp_directory(Allocator* allocator = mem::heap()) @if(!env::WIN
 	return path::new("/tmp", allocator);
 }

-fn Path! native_temp_directory(Allocator* allocator = mem::heap()) @if(env::WIN32)
+fn Path! native_temp_directory(Allocator allocator = allocator::heap()) @if(env::WIN32)
 {
 	@pool(allocator)
 	{
 		Win32_DWORD len = win32::getTempPathW(0, null);
 		if (!len) return IoError.GENERAL_ERROR?;
-		Char16[] buff = mem::temp_array(Char16, len + (usz)1);
+		Char16[] buff = mem::temp_alloc_array(Char16, len + (usz)1);
 		if (!win32::getTempPathW(len, buff)) return IoError.GENERAL_ERROR?;
 		return path::new(string::temp_from_utf16(buff[:len]), allocator);
 	};
 }

 module std::io::os @if(env::NO_LIBC);
+import std::io::path;

-macro Path! native_temp_directory(Allocator* allocator = mem::heap())
+macro Path! native_temp_directory(Allocator allocator = allocator::heap())
 {
 	return IoError.UNSUPPORTED_OPERATION?;
 }
--- a/lib/std/io/path.c3
+++ b/lib/std/io/path.c3
@@ -1,5 +1,6 @@
 module std::io::path;
-import std::collections::list;
+import std::collections::list, std::io::os;
+import std::os::win32;

 const PathEnv DEFAULT_PATH_ENV = env::WIN32 ? PathEnv.WIN32 : PathEnv.POSIX;
 const char PREFERRED_SEPARATOR_WIN32 = '\\';
@@ -14,7 +15,9 @@ fault PathResult
 	NO_PARENT,
 }

-struct Path (Printable)
+def Path = PathImp;
+
+struct PathImp (Printable)
 {
 	String path_string;
 	PathEnv env;
@@ -26,11 +29,19 @@ enum PathEnv
 	POSIX
 }

-fn Path! getcwd(Allocator* allocator = mem::heap())
+fn Path! new_cwd(Allocator allocator = allocator::heap())
 {
 	@pool(allocator)
 	{
-		return new(os::getcwd(mem::temp()), allocator);
+		return new(os::getcwd(allocator::temp()), allocator);
+	};
+}
+
+fn Path! getcwd(Allocator allocator = allocator::heap()) @deprecated("Use new_cwd()")
+{
+	@pool(allocator)
+	{
+		return new(os::getcwd(allocator::temp()), allocator);
 	};
 }

@@ -38,9 +49,10 @@ fn bool is_dir(Path path) => os::native_is_dir(path.str_view());
 fn bool is_file(Path path) => os::native_is_file(path.str_view());
 fn usz! file_size(Path path) => os::native_file_size(path.str_view());
 fn bool exists(Path path) => os::native_file_or_dir_exists(path.str_view());
-fn Path! tgetcwd() => getcwd(mem::temp()) @inline;
+fn Path! temp_cwd() => new_cwd(allocator::temp()) @inline;
+fn Path! tgetcwd() @deprecated("Use temp_cwd()") => new_cwd(allocator::temp()) @inline;
 fn void! chdir(Path path) => os::native_chdir(path) @inline;
-fn Path! temp_directory(Allocator* allocator = mem::heap()) => os::native_temp_directory(allocator);
+fn Path! temp_directory(Allocator allocator = allocator::heap()) => os::native_temp_directory(allocator);
 fn void! delete(Path path) => os::native_remove(path.str_view()) @inline;

 macro bool is_separator(char c, PathEnv path_env = DEFAULT_PATH_ENV)
@@ -58,7 +70,17 @@ macro bool is_win32_separator(char c)
 	return c == '/' || c == '\\';
 }

-fn PathList! ls(Path dir, bool no_dirs = false, bool no_symlinks = false, String mask = "", Allocator* allocator = mem::heap())
+fn PathList! ls(Path dir, bool no_dirs = false, bool no_symlinks = false, String mask = "", Allocator allocator = allocator::heap()) @deprecated("use new_ls")
+{
+	return new_ls(dir, no_dirs, no_symlinks, mask, allocator);
+
+}
+fn PathList! temp_ls(Path dir, bool no_dirs = false, bool no_symlinks = false, String mask = "")
+{
+	return new_ls(dir, no_dirs, no_symlinks, mask, allocator::temp()) @inline;
+}
+
+fn PathList! new_ls(Path dir, bool no_dirs = false, bool no_symlinks = false, String mask = "", Allocator allocator = allocator::heap())
 {
 	$if $defined(os::native_ls):
 		return os::native_ls(dir, no_dirs, no_symlinks, mask, allocator);
@@ -105,17 +127,17 @@ fn void! rmtree(Path path)
 	$endif
 }

-fn Path! new(String path, Allocator* allocator = mem::heap(), PathEnv path_env = DEFAULT_PATH_ENV)
+fn Path! new(String path, Allocator allocator = allocator::heap(), PathEnv path_env = DEFAULT_PATH_ENV)
 {
 	return { normalize(path.copy(allocator), path_env), path_env };
 }

 fn Path! temp_new(String path, PathEnv path_env = DEFAULT_PATH_ENV)
 {
-	return new(path, mem::temp(), path_env);
+	return new(path, allocator::temp(), path_env);
 }

-fn Path! new_win32_wstring(WString path, Allocator* allocator = mem::heap())
+fn Path! new_win32_wstring(WString path, Allocator allocator = allocator::heap())
 {
 	@pool(allocator)
 	{
@@ -123,12 +145,12 @@ fn Path! new_win32_wstring(WString path, Allocator* allocator = mem::heap())
 	};
 }

-fn Path! new_windows(String path, Allocator* allocator = mem::heap())
+fn Path! new_windows(String path, Allocator allocator = allocator::heap())
 {
 	return new(path, allocator, WIN32);
 }

-fn Path! new_posix(String path, Allocator* allocator = mem::heap())
+fn Path! new_posix(String path, Allocator allocator = allocator::heap())
 {
 	return new(path, allocator, POSIX);
 }
@@ -138,12 +160,17 @@ fn bool Path.equals(self, Path p2)
 	return self.env == p2.env && self.path_string == p2.path_string;
 }

+fn Path! Path.append(self, String filename, Allocator allocator = allocator::heap()) @deprecated("Use path.new_append(...)")
+{
+	return self.new_append(filename, allocator) @inline;
+}
+
 /**
 * Append the string to the current path.
 *
 * @param [in] filename
 **/
-fn Path! Path.append(self, String filename, Allocator* allocator = mem::heap())
+fn Path! Path.new_append(self, String filename, Allocator allocator = allocator::heap())
 {
 	if (!self.path_string.len) return new(filename, allocator, self.env)!;
 	assert(!is_separator(self.path_string[^1], self.env));
@@ -158,7 +185,9 @@ fn Path! Path.append(self, String filename, Allocator* allocator = mem::heap())
 	};
 }

-fn Path! Path.tappend(self, String filename) => self.append(filename, mem::temp());
+fn Path! Path.temp_append(self, String filename) => self.new_append(filename, allocator::temp());
+
+fn Path! Path.tappend(self, String filename) @deprecated("Use path.temp_append(...)") => self.new_append(filename, allocator::temp());

 fn usz Path.start_of_base_name(self) @local
 {
@@ -166,7 +195,19 @@ fn usz Path.start_of_base_name(self) @local
 	if (!path_str.len) return 0;
 	if (self.env == PathEnv.WIN32)
 	{
-		return path_str.rindex_of_char('\\') + 1 ?? volume_name_len(path_str, self.env)!!;
+		if (try index = path_str.rindex_of_char('\\'))
+		{
+			// c:\ style path, we're done!
+			if (path_str[0] != '\\') return index + 1;
+			// Handle \\server\foo
+			// Find the \ before "foo"
+			usz last_index = 2 + path_str[2..].index_of_char('\\')!!;
+			// If they don't match, we're done
+			assert(last_index <= index, "Invalid normalized, path %d vs %s in %s", last_index, index, path_str);
+			if (last_index != index) return index + 1;
+			// Otherwise just default to the volume length.
+		}
+		return volume_name_len(path_str, self.env)!!;
 	}
 	return path_str.rindex_of_char('/') + 1 ?? 0;
 }
@@ -176,28 +217,44 @@ fn bool! Path.is_absolute(self)
 	String path_str = self.str_view();
 	if (!path_str.len) return false;
 	usz path_start = volume_name_len(path_str, self.env)!;
+	if (path_start > 0 && path_str[0] == '\\') return true;
 	return path_start < path_str.len && is_separator(path_str[path_start], self.env);
 }

-fn Path! Path.absolute(self, Allocator* allocator = mem::heap())
+fn Path! Path.absolute(self, Allocator allocator = allocator::heap()) @deprecated("Use path.new_absolute()")
+{
+	return self.new_absolute(allocator) @inline;
+}
+
+/**
+ * @require self.env == DEFAULT_PATH_ENV : "This method is only available on native paths"
+ **/
+fn Path! Path.new_absolute(self, Allocator allocator = allocator::heap())
 {
 	String path_str = self.str_view();
-	if (!path_str.len) path_str = ".";
+	if (!path_str.len) return PathResult.INVALID_PATH?;
+	if (self.is_absolute()!) return new(path_str, allocator, self.env);
 	if (path_str == ".")
 	{
-		String cwd = os::getcwd(mem::temp())!;
-		return new(cwd, allocator, self.env);
+		@pool(allocator)
+		{
+			String cwd = os::getcwd(allocator::temp())!;
+			return new(cwd, allocator, self.env);
+		};
 	}
-	switch (self.env)
-	{
-		case WIN32:
-			usz path_start = volume_name_len(path_str, self.env)!;
-			if (path_start > 0) return self;
-		case POSIX:
-			if (path_str[0] == PREFERRED_SEPARATOR_POSIX) return self;
-	}
-	String cwd = os::getcwd(mem::temp())!;
-	return Path{ cwd, self.env }.append(path_str, allocator)!;
+	$if DEFAULT_PATH_ENV == WIN32:
+		@pool(allocator)
+		{
+			const usz BUFFER_LEN = 4096;
+			WString buffer = (WString)mem::temp_alloc_array(Char16, BUFFER_LEN);
+			buffer = win32::_wfullpath(buffer, path_str.to_temp_wstring()!, BUFFER_LEN);
+			if (!buffer) return PathResult.INVALID_PATH?;
+			return { string::new_from_wstring(buffer, allocator), WIN32 };
+		};
+	$else
+		String cwd = os::getcwd(allocator::temp())!;
+		return Path { cwd, self.env }.new_append(path_str, allocator)!;
+	$endif
 }

 fn String Path.basename(self)
@@ -208,16 +265,40 @@ fn String Path.basename(self)
 	return path_str[basename_start..];
 }

+
 fn String Path.dirname(self)
 {
 	usz basename_start = self.start_of_base_name();
 	String path_str = self.path_string;
-	if (basename_start == 0) return "";
+	if (basename_start == 0) return ".";
 	usz start = volume_name_len(path_str, self.env)!!;
-	if (basename_start <= start + 1) return path_str[:basename_start];
+	if (basename_start <= start + 1)
+	{
+		if (self.env == WIN32 && basename_start > start && path_str[0..1] == `\\`)
+		{
+			return path_str[:basename_start - 1];
+		}
+		return path_str[:basename_start];
+	}
 	return path_str[:basename_start - 1];
 }

+/**
+ * Test if the path has the given extension, so given the path /foo/bar.c3
+ * this would be true matching the extension "c3"
+ *
+ * @param [in] extension `The extension name (not including the leading '.')`
+ * @require extension.len > 0 : `The extension cannot be empty`
+ * @return `true if the extension matches`
+ **/
+fn bool Path.has_extension(self, String extension)
+{
+	String basename = self.basename();
+	if (basename.len <= extension.len) return false;
+	if (basename[^extension.len + 1] != '.') return false;
+	return basename[^extension.len..] == extension;
+}
+
 fn String! Path.extension(self)
 {
 	String basename = self.basename();
@@ -248,13 +329,20 @@ fn usz! volume_name_len(String path, PathEnv path_env) @local
 			while (count < len && path[count] == '\\') count++;
 			// Not 2 => folded paths
 			if (count != 2) return 0;
-			// Check that we have a name followed by '/'
+			// Check that we have a name followed by '\'
+			isz base_found = 0;
 			for (usz i = 2; i < len; i++)
 			{
 				char c = path[i];
-				if (is_win32_separator(c)) return i;
+				if (is_win32_separator(c))
+				{
+					if (base_found) return i;
+					base_found = i;
+					continue;
+				}
 				if (is_reserved_win32_path_char(c)) return PathResult.INVALID_PATH?;
 			}
+			if (base_found > 0 && base_found + 1 < len) return len;
 			return PathResult.INVALID_PATH?;
 		case 'A'..'Z':
 		case 'a'..'z':
@@ -281,6 +369,10 @@ fn String! normalize(String path_str, PathEnv path_env = DEFAULT_PATH_ENV)
 {
 	if (!path_str.len) return "";
 	usz path_start = volume_name_len(path_str, path_env)!;
+	if (path_start > 0 && path_env == PathEnv.WIN32)
+	{
+		for (usz i = 0; i < path_start; i++) if (path_str[i] == '/') path_str[i] = '\\';
+	}
 	usz path_len = path_str.len;
 	if (path_start == path_len) return path_str;
 	char path_separator = path_env == PathEnv.WIN32 ? PREFERRED_SEPARATOR_WIN32 : PREFERRED_SEPARATOR_POSIX;
@@ -384,7 +476,9 @@ fn String! normalize(String path_str, PathEnv path_env = DEFAULT_PATH_ENV)
 		len++;
 	}
 	if (len > path_start + 1 && is_separator(path_str[len - 1], path_env)) len--;
-	path_str.ptr[len] = 0;
+	if (path_str.len > len) path_str.ptr[len] = 0;
+	// Empty path after normalization -> "."
+	if (!len) return ".";
 	return path_str[:len];
 }

@@ -395,6 +489,7 @@ fn String Path.root_directory(self)
 	String path_str = self.str_view();
 	usz len = path_str.len;
 	if (!len) return "";
+	if (path_str == ".") return ".";
 	if (self.env == PathEnv.WIN32)
 	{
 		usz root_len = volume_name_len(path_str, self.env)!!;
@@ -417,18 +512,19 @@ def PathWalker = fn bool! (Path, bool is_dir, void*);
 /*
 * Walk the path recursively. PathWalker is run on every file and
 * directory found. Return true to abort the walk.
+ * @require self.env == DEFAULT_PATH_ENV : "This method is only available on native paths"
 */
 fn bool! Path.walk(self, PathWalker w, void* data)
 {
 	const PATH_MAX = 512;
-	@stack_mem(PATH_MAX; Allocator* allocator)
+	@stack_mem(PATH_MAX; Allocator allocator)
 	{
-		Path abs = self.absolute(allocator)!;
-		PathList files = ls(abs, .allocator = allocator)!;
+		Path abs = self.new_absolute(allocator)!;
+		PathList files = new_ls(abs, .allocator = allocator)!;
 		foreach (f : files)
 		{
 			if (f.str_view() == "." || f.str_view() == "..") continue;
-			f = abs.append(f.str_view(), allocator)!;
+			f = abs.new_append(f.str_view(), allocator)!;
 			bool is_directory = is_dir(f);
 			if (w(f, is_directory, data)!) return true;
 			if (is_directory && f.walk(w, data)!) return true;
@@ -448,6 +544,11 @@ fn bool Path.has_suffix(self, String str)
 	return self.str_view().ends_with(str);
 }

+fn void Path.free_with_allocator(self, Allocator allocator)
+{
+	allocator::free(allocator, self.path_string.ptr);
+}
+
 fn void Path.free(self)
 {
 	free(self.path_string.ptr);
@@ -459,7 +560,7 @@ fn usz! Path.to_format(&self, Formatter* formatter) @dynamic
 	return formatter.print(self.str_view());
 }

-fn String Path.to_new_string(&self, Allocator* allocator = mem::heap()) @dynamic
+fn String Path.to_new_string(&self, Allocator allocator = allocator::heap()) @dynamic
 {
 	return self.str_view().copy(allocator);
 }
--- a/lib/std/io/stream.c3
+++ b/lib/std/io/stream.c3
@@ -1,4 +1,5 @@
 module std::io;
+import std::math;

 interface InStream
 {
@@ -8,7 +9,7 @@ interface InStream
 	fn usz! available() @optional;
 	fn usz! read(char[] buffer);
 	fn char! read_byte();
-	fn usz! write_to(OutStream* out) @optional;
+	fn usz! write_to(OutStream out) @optional;
 	fn void! pushback_byte() @optional;
 }

@@ -20,10 +21,10 @@ interface OutStream
 	fn void! flush() @optional;
 	fn usz! write(char[] bytes);
 	fn void! write_byte(char c);
-	fn usz! read_to(InStream* in) @optional;
+	fn usz! read_to(InStream in) @optional;
 }

-fn usz! available(InStream* s)
+fn usz! available(InStream s)
 {
 	if (&s.available) return s.available();
 	if (&s.seek)
@@ -38,19 +39,19 @@ fn usz! available(InStream* s)

 macro bool @is_instream(#expr)
 {
-	return $assignable(#expr, InStream*);
+	return $assignable(#expr, InStream);
 }

 macro bool @is_outstream(#expr)
 {
-	return $assignable(#expr, OutStream*);
+	return $assignable(#expr, OutStream);
 }

 /**
 * @param [&out] ref
 * @require @is_instream(stream)
 **/
-macro usz! read_any(stream, any* ref)
+macro usz! read_any(stream, any ref)
 {
 	return read_all(stream, ((char*)ref)[:ref.type.sizeof]);
 }
@@ -60,7 +61,7 @@ macro usz! read_any(stream, any* ref)
 * @require @is_outstream(stream)
 * @ensure return == ref.type.sizeof
 */
-macro usz! write_any(stream, any* ref)
+macro usz! write_any(stream, any ref)
 {
 	return write_all(stream, ((char*)ref)[:ref.type.sizeof]);
 }
@@ -133,29 +134,23 @@ macro void! @pushback_using_seek(&s)
 	s.seek(-1, CURSOR)!;
 }

-fn usz! copy_to(InStream* in, OutStream* dst, char[] buffer = {})
+fn usz! copy_to(InStream in, OutStream dst, char[] buffer = {})
 {
 	if (buffer.len) return copy_through_buffer(in, dst, buffer);
 	if (&in.write_to) return in.write_to(dst);
 	if (&dst.read_to) return dst.read_to(in);
 	$switch (env::MEMORY_ENV)
 		$case NORMAL:
-			@pool()
-			{
-				return copy_through_buffer(in, dst, mem::temp_array(char, 4096));
-			};
+			return copy_through_buffer(in, dst, &&char[4096]{});
 		$case SMALL:
-			@pool()
-			{
-				return copy_through_buffer(in, dst, mem::temp_array(char, 1024));
-			};
+			return copy_through_buffer(in, dst, &&char[1024]{});
 		$case TINY:
 		$case NONE:
 			return copy_through_buffer(in, dst, &&(char[256]{}));
 	$endswitch
 }

-macro usz! copy_through_buffer(InStream *in, OutStream* dst, char[] buffer) @local
+macro usz! copy_through_buffer(InStream in, OutStream dst, char[] buffer) @local
 {
 	usz total_copied;
 	while (true)
--- a/lib/std/io/stream/buffer.c3
+++ b/lib/std/io/stream/buffer.c3
@@ -2,7 +2,7 @@ module std::io;

 struct ReadBuffer (InStream)
 {
-	InStream* wrapped_stream;
+	InStream wrapped_stream;
 	char[] bytes;
 	usz read_idx;
 	usz write_idx;
@@ -14,7 +14,7 @@ struct ReadBuffer (InStream)
 * @require bytes.len > 0
 * @require self.bytes.len == 0 "Init may not run on already initialized data"
 **/
-fn ReadBuffer* ReadBuffer.init(&self, InStream* wrapped_stream, char[] bytes)
+fn ReadBuffer* ReadBuffer.init(&self, InStream wrapped_stream, char[] bytes)
 {
 	*self = { .wrapped_stream = wrapped_stream, .bytes = bytes };
 	return self;
@@ -63,7 +63,7 @@ fn void! ReadBuffer.refill(&self) @local @inline

 struct WriteBuffer (OutStream)
 {
-	OutStream* wrapped_stream;
+	OutStream wrapped_stream;
 	char[] bytes;
 	usz index;
 }
@@ -74,7 +74,7 @@ struct WriteBuffer (OutStream)
 * @require bytes.len > 0 "Non-empty buffer required"
 * @require self.bytes.len == 0 "Init may not run on already initialized data"
 **/
-fn WriteBuffer* WriteBuffer.init(&self, OutStream* wrapped_stream, char[] bytes)
+fn WriteBuffer* WriteBuffer.init(&self, OutStream wrapped_stream, char[] bytes)
 {
 	*self = { .wrapped_stream = wrapped_stream, .bytes = bytes };
 	return self;
--- a/lib/std/io/stream/bytebuffer.c3
+++ b/lib/std/io/stream/bytebuffer.c3
@@ -3,7 +3,7 @@ import std::math;

 struct ByteBuffer (InStream, OutStream)
 {
-	Allocator* allocator;
+	Allocator allocator;
 	usz max_read;
 	char[] bytes;
 	usz read_idx;
@@ -16,7 +16,7 @@ struct ByteBuffer (InStream, OutStream)
 * max_read defines how many bytes might be kept before its internal buffer is shrinked.
 * @require self.bytes.len == 0 "Buffer already initialized."
 **/
-fn ByteBuffer*! ByteBuffer.init_new(&self, usz max_read, usz initial_capacity = 16, Allocator* allocator = mem::heap())
+fn ByteBuffer*! ByteBuffer.new_init(&self, usz max_read, usz initial_capacity = 16, Allocator allocator = allocator::heap())
 {
 	*self = { .allocator = allocator, .max_read = max_read };
 	initial_capacity = max(initial_capacity, 16);
@@ -24,9 +24,9 @@ fn ByteBuffer*! ByteBuffer.init_new(&self, usz max_read, usz initial_capacity =
 	return self;
 }

-fn ByteBuffer*! ByteBuffer.init_temp(&self, usz max_read, usz initial_capacity = 16)
+fn ByteBuffer*! ByteBuffer.temp_init(&self, usz max_read, usz initial_capacity = 16)
 {
-	return self.init_new(max_read, initial_capacity, mem::temp());
+	return self.new_init(max_read, initial_capacity, allocator::temp());
 }

 /**
@@ -41,7 +41,7 @@ fn ByteBuffer*! ByteBuffer.init_with_buffer(&self, char[] buf)

 fn void ByteBuffer.free(&self)
 {
-	if (self.allocator) self.allocator.free(self.bytes);
+	if (self.allocator) allocator::free(self.allocator, self.bytes);
 	*self = {};
 }

@@ -131,7 +131,7 @@ fn usz! ByteBuffer.available(&self) @inline @dynamic
 fn void! ByteBuffer.grow(&self, usz n)
 {
 	n = math::next_power_of_2(n);
-	char* p = self.allocator.realloc_aligned(self.bytes, n, .alignment = char.alignof)!;
+	char* p = allocator::realloc_aligned(self.allocator, self.bytes, n, .alignment = char.alignof)!;
 	self.bytes = p[:n];
 }

--- a/lib/std/io/stream/bytereader.c3
+++ b/lib/std/io/stream/bytereader.c3
@@ -53,7 +53,7 @@ fn usz! ByteReader.seek(&self, isz offset, Seek seek) @dynamic
 	return new_index;
 }

-fn usz! ByteReader.write_to(&self, OutStream* writer) @dynamic
+fn usz! ByteReader.write_to(&self, OutStream writer) @dynamic
 {
 	if (self.index >= self.bytes.len) return 0;
 	usz written = writer.write(self.bytes[self.index..])!;
--- a/lib/std/io/stream/bytewriter.c3
+++ b/lib/std/io/stream/bytewriter.c3
@@ -1,19 +1,20 @@
 module std::io;
+import std::math;

 struct ByteWriter (OutStream)
 {
 	char[] bytes;
 	usz index;
-	Allocator* allocator;
+	Allocator allocator;
 }

 /**
 * @param [&inout] self
 * @param [&inout] allocator
- * @require self.bytes.len == 0 "Init may not run on on already initialized data"
+ * @require self.bytes.len == 0 "Init may not run on already initialized data"
 * @ensure (bool)allocator, self.index == 0
 **/
-fn ByteWriter* ByteWriter.init_new(&self, Allocator* allocator = mem::heap())
+fn ByteWriter* ByteWriter.new_init(&self, Allocator allocator = allocator::heap())
 {
 	*self = { .bytes = {}, .allocator = allocator };
 	return self;
@@ -21,12 +22,12 @@ fn ByteWriter* ByteWriter.init_new(&self, Allocator* allocator = mem::heap())

 /**
 * @param [&inout] self
- * @require self.bytes.len == 0 "Init may not run on on already initialized data"
+ * @require self.bytes.len == 0 "Init may not run on already initialized data"
 * @ensure self.index == 0
 **/
-fn ByteWriter* ByteWriter.init_temp(&self)
+fn ByteWriter* ByteWriter.temp_init(&self)
 {
-	return self.init_new(mem::temp());
+	return self.new_init(allocator::temp()) @inline;
 }

 fn ByteWriter* ByteWriter.init_with_buffer(&self, char[] data)
@@ -38,7 +39,7 @@ fn ByteWriter* ByteWriter.init_with_buffer(&self, char[] data)
 fn void! ByteWriter.destroy(&self) @dynamic
 {
 	if (!self.allocator) return;
-	if (void* ptr = self.bytes.ptr) self.allocator.free(ptr);
+	if (void* ptr = self.bytes.ptr) allocator::free(self.allocator, ptr);
 	*self = { };
 }

@@ -53,7 +54,7 @@ fn void! ByteWriter.ensure_capacity(&self, usz len) @inline
 	if (!self.allocator) return IoError.OUT_OF_SPACE?;
 	if (len < 16) len = 16;
 	usz new_capacity = math::next_power_of_2(len);
-	char* new_ptr = self.allocator.realloc_checked(self.bytes.ptr, new_capacity)!;
+	char* new_ptr = allocator::realloc_try(self.allocator, self.bytes.ptr, new_capacity)!;
 	self.bytes = new_ptr[:new_capacity];
 }

@@ -75,7 +76,7 @@ fn void! ByteWriter.write_byte(&self, char c) @dynamic
 * @param [&inout] self
 * @param reader
 **/
-fn usz! ByteWriter.read_from(&self, InStream* reader) @dynamic
+fn usz! ByteWriter.read_from(&self, InStream reader) @dynamic
 {
 	usz start_index = self.index;
 	if (&reader.available)
--- a/lib/std/io/stream/limitreader.c3
+++ b/lib/std/io/stream/limitreader.c3
@@ -2,7 +2,7 @@ module std::io;

 struct LimitReader (InStream)
 {
-	InStream* wrapped_stream;
+	InStream wrapped_stream;
 	usz limit;
 }

@@ -10,7 +10,7 @@ struct LimitReader (InStream)
 * @param [&inout] wrapped_stream "The stream to read from"
 * @param limit "The max limit to read"
 **/
-fn LimitReader* LimitReader.init(&self, InStream* wrapped_stream, usz limit)
+fn LimitReader* LimitReader.init(&self, InStream wrapped_stream, usz limit)
 {
 	*self = { .wrapped_stream = wrapped_stream, .limit = limit };
 	return self;
--- a/lib/std/io/stream/scanner.c3
+++ b/lib/std/io/stream/scanner.c3
@@ -2,7 +2,7 @@ module std::io;

 struct Scanner (InStream)
 {
-	InStream* wrapped_stream;
+	InStream wrapped_stream;
 	char[] buf;
 	usz pattern_idx;
 	usz read_idx;
@@ -16,7 +16,7 @@ struct Scanner (InStream)
 * @param [&in] stream "The stream to read data from."
 * @require buffer.len > 0 "Non-empty buffer required."
 **/
-fn void Scanner.init(&self, InStream* stream, char[] buffer)
+fn void Scanner.init(&self, InStream stream, char[] buffer)
 {
 	*self = { .wrapped_stream = stream, .buf = buffer };
 }
--- a/lib/std/libc/libc.c3
+++ b/lib/std/libc/libc.c3
@@ -183,8 +183,8 @@ extern fn isz write(Fd fd, void* buffer, usz count) @if(!env::WIN32);

 extern fn CFile fmemopen(void* ptr, usz size, ZString mode);
 extern fn isz getline(char** linep, usz* linecapp, CFile stream);
-extern fn int timespec_get(TimeSpec* ts, int base);
-extern fn int nanosleep(TimeSpec* req, TimeSpec* remaining);
+extern fn CInt timespec_get(TimeSpec* ts, CInt base);
+extern fn CInt nanosleep(TimeSpec* req, TimeSpec* remaining);
 extern fn ZString ctime(Time_t *timer);
 extern fn Time_t time(Time_t *timer);

@@ -360,6 +360,7 @@ const int EOF = -1;
 const int FOPEN_MAX = 20;
 const int FILENAME_MAX = 1024;

+macro bool libc_S_ISTYPE(value, mask) @builtin => (value & S_IFMT) == mask;
 const S_IFMT   = 0o170000; // type of file mask
 const S_IFIFO  = 0o010000; // named pipe (fifo)
 const S_IFCHR  = 0o020000; // character special
--- a/lib/std/libc/os/posix.c3
+++ b/lib/std/libc/os/posix.c3
@@ -1,5 +1,7 @@
 module libc @if(env::POSIX);

+extern fn isz recv(Fd socket, void *buffer, usz length, CInt flags);
+extern fn isz send(Fd socket, void *buffer, usz length, CInt flags);

 extern fn void* dlopen(ZString path, int flags);
 extern fn CInt dlclose(void*);
@@ -53,3 +55,139 @@ struct Stack_t

 extern fn CInt sigaltstack(Stack_t* ss, Stack_t* old_ss);
 extern fn CInt sigaction(CInt signum, Sigaction *action, Sigaction *oldaction);
+
+module libc::termios @if(env::LIBC &&& env::POSIX);
+
+distinct Cc = char;
+distinct Speed = CUInt;
+distinct Tcflags = CUInt;
+
+const Tcflags TCOOFF = 0;
+const Tcflags TCOON = 1;
+const Tcflags TCIOFF = 2;
+const Tcflags TCION = 3;
+const Tcflags TCIFLUSH = 0;
+const Tcflags TCOFLUSH = 1;
+const Tcflags TCIOFLUSH = 2;
+const Tcflags TCSANOW = 0;
+const Tcflags TCSADRAIN = 1;
+const Tcflags TCSAFLUSH = 2;
+const Speed B0 = 0000000;
+const Speed B50 = 0000001;
+const Speed B75 = 0000002;
+const Speed B110 = 0000003;
+const Speed B134 = 0000004;
+const Speed B150 = 0000005;
+const Speed B200 = 0000006;
+const Speed B300 = 0000007;
+const Speed B600 = 0000010;
+const Speed B1200 = 0000011;
+const Speed B1800 = 0000012;
+const Speed B2400 = 0000013;
+const Speed B4800 = 0000014;
+const Speed B9600 = 0000015;
+const Speed B19200 = 0000016;
+const Speed B38400 = 0000017;
+const Speed B57600 = 0010001;
+const Speed B115200 = 0010002;
+const Speed B230400 = 0010003;
+const Speed B460800 = 0010004;
+const Speed B500000 = 0010005;
+const Speed B576000 = 0010006;
+const Speed B921600 = 0010007;
+const Speed B1000000 = 0010010;
+const Speed B1152000 = 0010011;
+const Speed B1500000 = 0010012;
+const Speed B2000000 = 0010013;
+const Speed B2500000 = 0010014;
+const Speed B3000000 = 0010015;
+const Speed B3500000 = 0010016;
+const Speed B4000000 = 0010017;
+const Speed MAX_BAUD = B4000000;
+const CInt VINTR = 0;
+const CInt VQUIT = 1;
+const CInt VERASE = 2;
+const CInt VKILL = 3;
+const CInt VEOF = 4;
+const CInt VTIME = 5;
+const CInt VMIN = 6;
+const CInt VSWTC = 7;
+const CInt VSTART = 8;
+const CInt VSTOP = 9;
+const CInt VSUSP = 10;
+const CInt VEOL = 11;
+const CInt VREPRINT = 12;
+const CInt VDISCARD = 13;
+const CInt VWERASE = 14;
+const CInt VLNEXT = 15;
+const CInt VEOL2 = 16;
+const CInt ISIG = 0000001;
+const CInt ICANON = 0000002;
+const CInt ECHO = 0000010;
+const CInt ECHOE = 0000020;
+const CInt ECHOK = 0000040;
+const CInt ECHONL = 0000100;
+const CInt NOFLSH = 0000200;
+const CInt TOSTOP = 0000400;
+const CInt IEXTEN = 0100000;
+const CInt CSIZE = 0000060;
+const CInt CS5 = 0000000;
+const CInt CS6 = 0000020;
+const CInt CS7 = 0000040;
+const CInt CS8 = 0000060;
+const CInt CSTOPB = 0000100;
+const CInt CREAD = 0000200;
+const CInt PARENB = 0000400;
+const CInt PARODD = 0001000;
+const CInt HUPCL = 0002000;
+const CInt CLOCAL = 0004000;
+const CInt OPOST = 0000001;
+const CInt OLCUC = 0000002;
+const CInt ONLCR = 0000004;
+const CInt OCRNL = 0000010;
+const CInt ONOCR = 0000020;
+const CInt ONLRET = 0000040;
+const CInt OFILL = 0000100;
+const CInt OFDEL = 0000200;
+const CInt VTDLY = 0040000;
+const CInt VT0 = 0000000;
+const CInt VT1 = 0040000;
+const CInt IGNBRK = 0000001;
+const CInt BRKINT = 0000002;
+const CInt IGNPAR = 0000004;
+const CInt PARMRK = 0000010;
+const CInt INPCK = 0000020;
+const CInt ISTRIP = 0000040;
+const CInt INLCR = 0000100;
+const CInt IGNCR = 0000200;
+const CInt ICRNL = 0000400;
+const CInt IUCLC = 0001000;
+const CInt IXON = 0002000;
+const CInt IXANY = 0004000;
+const CInt IXOFF = 0010000;
+const CInt IMAXBEL = 0020000;
+const CInt IUTF8 = 0040000;
+
+extern fn CInt tcgetattr(Fd fd, Termios* self);
+extern fn CInt tcsetattr(Fd fd, CInt optional_actions, Termios* self);
+extern fn CInt tcsendbreak(Fd fd, CInt duration);
+extern fn CInt tcdrain(Fd fd);
+extern fn CInt tcflush(Fd fd, CInt queue_selector);
+extern fn CInt tcflow(Fd fd, CInt action);
+extern fn Speed cfgetospeed(Termios* self);
+extern fn Speed cfgetispeed(Termios* self);
+extern fn CInt cfsetospeed(Termios* self, Speed speed);
+extern fn CInt cfsetispeed(Termios* self, Speed speed);
+
+const CInt NCCS = 32;
+struct Termios {
+        Tcflags c_iflag;
+        Tcflags c_oflag;
+        Tcflags c_cflag;
+        Tcflags c_lflag;
+        Cc c_line;
+        Cc[NCCS] c_cc;
+        Speed c_ispeed;
+        Speed c_ospeed;
+} 
+
--- a/lib/std/libc/os/win32.c3
+++ b/lib/std/libc/os/win32.c3
@@ -1,5 +1,5 @@
 module libc @if(env::WIN32);
-
+import std::os::win32;

 extern fn CFile __acrt_iob_func(CInt c);
 extern fn CInt _close(Fd fd); def close = _close;
@@ -15,11 +15,13 @@ extern fn Time_t _mkgmtime64(Tm* timeptr); def timegm = _mkgmtime64;
 extern fn Time_t _mktime64(Tm *timeptr); def mktime = _mktime64;
 extern fn usz _msize(void* ptr);
 extern fn CInt _read(Fd fd, void* buffer, CUInt buffer_size);
-extern fn CInt _setjmp(void* frameptr, JmpBuf* buffer) @if(env::WIN32);
+extern fn CInt _setjmp(JmpBuf* buffer, void* frameptr);
 extern fn CFile _wfopen(WString, WString);
 extern fn CFile _wfreopen(WString, WString, CFile);
 extern fn CInt _write(Fd fd, void* buffer, CUInt count);
 extern fn CInt _wremove(WString);
+extern fn int recv(Win32_SOCKET s, void* buf, int len, int flags);
+extern fn int send(Win32_SOCKET s, void* buf, int len, int flags);

 struct SystemInfo
 {
@@ -45,7 +47,7 @@ extern fn CInt get_system_info(SystemInfo*) @extern("GetSystemInfo");

 // Aliases to simplify libc use
 macro Tm* localtime_r(Time_t* timer, Tm* buf) => _localtime64_s(buf, timer);
-macro CInt setjmp(JmpBuf* buffer) => _setjmp($$frameaddress(0), buffer);
+macro CInt setjmp(JmpBuf* buffer) => _setjmp(buffer, null);
 macro Tm* gmtime_r(Time_t* timer, Tm* buf) => _gmtime64_s(buf, timer);
 macro isz read(Fd fd, void* buffer, usz buffer_size) => _read(fd, buffer, (CUInt)buffer_size);
 macro isz write(Fd fd, void* buffer, usz count) => _write(fd, buffer, (CUInt)count);
--- a/lib/std/libc/termios.c3
+++ b/lib/std/libc/termios.c3
@@ -0,0 +1,122 @@
+module libc::termios @if(env::LIBC &&& env::POSIX);
+
+fn int sendBreak(Fd fd, int duration) => tcsendbreak(fd, duration);
+fn int drain(Fd fd) => tcdrain(fd);
+fn int flush(Fd fd, int queue_selector) => tcflush(fd, queue_selector);
+fn int flow(Fd fd, int action) => tcflow(fd, action);
+fn Speed Termios.getOSpeed(Termios* self) => cfgetospeed(self);
+fn Speed Termios.getISpeed(Termios* self) => cfgetispeed(self);
+fn int Termios.setOSpeed(Termios* self, Speed speed) => cfsetospeed(self, speed);
+fn int Termios.setISpeed(Termios* self, Speed speed) => cfsetispeed(self, speed);
+fn int Termios.getAttr(Termios* self, Fd fd) => tcgetattr(fd, self);
+fn int Termios.setAttr(Termios* self, Fd fd, int optional_actions) => tcsetattr(fd, optional_actions, self);
+
+module libc::termios @if(!env::LIBC ||| !env::POSIX);
+
+distinct Cc = char;
+distinct Speed = CUInt;
+distinct Tcflags = CUInt;
+struct Termios {
+        void* dummy;
+}
+
+fn CInt tcgetattr(Fd fd, Termios* self)
+{
+        unreachable("tcgetattr unavailable");
+}
+
+fn CInt tcsetattr(Fd fd, CInt optional_actions, Termios* self)
+{
+        unreachable("tcsetattr unavailable");
+}
+
+fn CInt tcsendbreak(Fd fd, CInt duration)
+{
+        unreachable("tcsendbreak unavailable");
+}
+
+fn CInt tcdrain(Fd fd)
+{
+        unreachable("tcdrain unavailable");
+}
+
+fn CInt tcflush(Fd fd, CInt queue_selector)
+{
+        unreachable("tcflush unavailable");
+}
+
+fn CInt tcflow(Fd fd, CInt action)
+{
+        unreachable("tcflow unavailable");
+}
+
+fn Speed cfgetospeed(Termios* self)
+{
+        unreachable("cfgetospeed unavailable");
+}
+
+fn Speed cfgetispeed(Termios* self)
+{
+        unreachable("cfgetispeed unavailable");
+}
+
+fn CInt cfsetospeed(Termios* self, Speed speed)
+{
+        unreachable("cfsetospeed unavailable");
+}
+
+fn CInt cfsetispeed(Termios* self, Speed speed)
+{
+        unreachable("cfsetispeed unavailable");
+}
+
+fn int sendBreak(Fd fd, int duration)
+{
+        unreachable("sendBreak unavailable");
+}
+
+fn int drain(Fd fd)
+{
+        unreachable("drain unavailable");
+}
+
+fn int flush(Fd fd, int queue_selector)
+{
+        unreachable("flush unavailable");
+}
+
+fn int flow(Fd fd, int action)
+{
+        unreachable("flow unavailable");
+}
+
+fn Speed Termios.getOSpeed(Termios* self)
+{
+        unreachable("Termios.getOSpeed unavailable");
+}
+
+fn Speed Termios.getISpeed(Termios* self)
+{
+        unreachable("Termios.getISpeed unavailable");
+}
+
+fn int Termios.setOSpeed(Termios* self, Speed speed)
+{
+        unreachable("Termios.setOSpeed unavailable");
+}
+
+fn int Termios.setISpeed(Termios* self, Speed speed)
+{
+        unreachable("Termios.setISpeed unavailable");
+}
+
+fn int Termios.getAttr(Termios* self, Fd fd)
+{
+        unreachable("Termios.getAttr unavailable");
+}
+
+fn int Termios.setAttr(Termios* self, Fd fd, int optional_actions)
+{
+        unreachable("Termios.setAttr unavailable");
+}
+
--- a/lib/std/math/math.c3
+++ b/lib/std/math/math.c3
@@ -92,13 +92,13 @@ fault MatrixError

 def Complexf = Complex(<float>);
 def Complex = Complex(<double>);
-def complexf_identity = complex::identity(<float>);
-def complex_identity = complex::identity(<double>);
+def COMPLEX_IDENTITY = complex::IDENTITY(<double>);
+def COMPLEXF_IDENTITY = complex::IDENTITY(<float>);

 def Quaternionf = Quaternion(<float>);
 def Quaternion = Quaternion(<double>);
-def quaternionf_identity = quaternion::identity(<float>);
-def quaternion_identity = quaternion::identity(<double>);
+def QUATERNION_IDENTITY = quaternion::IDENTITY(<double>);
+def QUATERNIONF_IDENTITY = quaternion::IDENTITY(<float>);

 def Matrix2f = Matrix2x2(<float>);
 def Matrix2 = Matrix2x2(<double>);
@@ -118,6 +118,14 @@ def MATRIX3F_IDENTITY = matrix::IDENTITY3(<float>);
 def MATRIX4_IDENTITY = matrix::IDENTITY4(<double>);
 def MATRIX4F_IDENTITY = matrix::IDENTITY4(<float>);

+
+/**
+ * @require types::is_numerical($typeof(x)) `The input must be a numerical value or numerical vector`
+ **/
+macro deg_to_rad(x) {
+    return x * PI / 180;
+}
+
 /**
 * @require types::is_numerical($typeof(x)) `The input must be a numerical value or numerical vector`
 **/
@@ -151,7 +159,7 @@ macro atan2(x, y)

 /**
 * @require values::@is_int(x) || values::@is_float(x) "Expected an integer or floating point value"
- * @require $and(@typekind(y) == ARRAY || @typekind(y) == VECTOR, y.len == 2)
+ * @require (@typekind(y) == ARRAY || @typekind(y) == VECTOR) &&& y.len == 2
 * @require $assignable(x, $typeof(y[0]))
 **/
 macro sincos(x, y)
@@ -258,7 +266,7 @@ macro clamp(x, lower, upper) => $$max(($typeof(x))lower, $$min(x, ($typeof(x))up
 * @require values::@is_promotable_to_floatlike(mag) `The input must be a number value or float vector`
 * @require values::@assign_to(sgn, values::promote_int(mag))
 **/
-macro copysign(mag, sgn) => $$copysign(values::promote_int(mag), ($typeof(values::promote_int(mag)))sgn);
+macro copysign(mag, sgn) => $$copysign(values::promote_int_same(mag, sgn), ($typeof(values::promote_int_same(mag, sgn)))sgn);

 /**
 * @require values::@is_promotable_to_floatlike(x) `The input must be a number value or float vector`
@@ -331,7 +339,10 @@ macro ln(x) => $$log(values::promote_int(x));
 * @require values::@is_promotable_to_floatlike(x) `The input must be a number or a float vector`
 * @require values::@is_promotable_to_floatlike(base) `The base must be a number or a float vector`
 **/
-macro log(x, base) => $$log(values::promote_int(x)) / $$log(values::promote_int(base));
+macro log(x, base)
+{
+	return $$log(values::promote_int_same(x, base)) / $$log(values::promote_int_same(base, x));
+}

 /**
 * @require values::@is_promotable_to_floatlike(x) `The input must be a number or a float vector`
@@ -354,7 +365,7 @@ macro max(x, y, ...)
 	$else
 		var m = $$max(x, y);
 		$for (var $i = 0; $i < $vacount; $i++)
-			m = $$max(m, $vaarg($i));
+			m = $$max(m, $vaarg[$i]);
 		$endfor
 		return m;
 	$endif
@@ -371,7 +382,7 @@ macro min(x, y, ...)
 	$else
 		var m = $$min(x, y);
 		$for (var $i = 0; $i < $vacount; $i++)
-			m = $$min(m, $vaarg($i));
+			m = $$min(m, $vaarg[$i]);
 		$endfor
 		return m;
 	$endif
@@ -390,14 +401,14 @@ macro nearbyint(x) => $$nearbyint(x);

 /**
 * @require values::@is_promotable_to_floatlike(x) `The input must be a number or a float vector`
- * @require $assignable(exp, $typeof(x)) || values::@is_int(exp) `The input must be an integer, castable to the type of x`
+ * @require $assignable(exp, $typeof(values::promote_int(x))) || values::@is_int(exp) `The input must be an integer, castable to the type of x`
 **/
 macro pow(x, exp)
 {
 	$if types::is_floatlike($typeof(exp)):
-		return $$pow(x, ($typeof(x))exp);
+		return $$pow(values::promote_int_same(x, exp), ($typeof(values::promote_int_same(x, exp)))exp);
 	$else
-		return $$pow_int(x, exp);
+		return $$pow_int(values::promote_int(x), exp);
 	$endif
 }

@@ -439,6 +450,16 @@ macro rint(x) => $$rint(x);
 **/
 macro round(x) => $$round(x);

+
+/**
+ * @require values::@is_floatlike(x) `The input must be a floating point value or float vector`
+ **/
+macro round_to_decimals(x, int decimal_places)
+{
+  var div = $$pow_int(($typeof(x))10, decimal_places);
+  return round(div * x) / div;
+}
+
 /**
 * @require values::@is_floatlike(x) `The input must be a floating point value or float vector`
 **/
@@ -672,6 +693,7 @@ macro ichar ichar[<*>].or(ichar[<*>] x) => $$reduce_or(x);
 macro ichar ichar[<*>].xor(ichar[<*>] x) => $$reduce_xor(x);
 macro ichar ichar[<*>].max(ichar[<*>] x) => $$reduce_max(x);
 macro ichar ichar[<*>].min(ichar[<*>] x) => $$reduce_min(x);
+macro ichar ichar[<*>].dot(ichar[<*>] x, ichar[<*>] y) => (x * y).sum();

 macro bool[<*>] short[<*>].comp_lt(short[<*>] x, short[<*>] y) => $$veccomplt(x, y);
 macro bool[<*>] short[<*>].comp_le(short[<*>] x, short[<*>] y) => $$veccomple(x, y);
@@ -687,6 +709,7 @@ macro short short[<*>].or(short[<*>] x) => $$reduce_or(x);
 macro short short[<*>].xor(short[<*>] x) => $$reduce_xor(x);
 macro short short[<*>].max(short[<*>] x) => $$reduce_max(x);
 macro short short[<*>].min(short[<*>] x) => $$reduce_min(x);
+macro short short[<*>].dot(short[<*>] x, short[<*>] y) => (x * y).sum();

 macro bool[<*>] int[<*>].comp_lt(int[<*>] x, int[<*>] y) => $$veccomplt(x, y);
 macro bool[<*>] int[<*>].comp_le(int[<*>] x, int[<*>] y) => $$veccomple(x, y);
@@ -702,6 +725,7 @@ macro int int[<*>].or(int[<*>] x) => $$reduce_or(x);
 macro int int[<*>].xor(int[<*>] x) => $$reduce_xor(x);
 macro int int[<*>].max(int[<*>] x) => $$reduce_max(x);
 macro int int[<*>].min(int[<*>] x) => $$reduce_min(x);
+macro int int[<*>].dot(int[<*>] x, int[<*>] y) => (x * y).sum();

 macro bool[<*>] long[<*>].comp_lt(long[<*>] x, long[<*>] y) => $$veccomplt(x, y);
 macro bool[<*>] long[<*>].comp_le(long[<*>] x, long[<*>] y) => $$veccomple(x, y);
@@ -716,6 +740,7 @@ macro long long[<*>].or(long[<*>] x) => $$reduce_or(x);
 macro long long[<*>].xor(long[<*>] x) => $$reduce_xor(x);
 macro long long[<*>].max(long[<*>] x) => $$reduce_max(x);
 macro long long[<*>].min(long[<*>] x) => $$reduce_min(x);
+macro long long[<*>].dot(long[<*>] x, long[<*>] y) => (x * y).sum();

 macro bool[<*>] int128[<*>].comp_lt(int128[<*>] x, int128[<*>] y) => $$veccomplt(x, y);
 macro bool[<*>] int128[<*>].comp_le(int128[<*>] x, int128[<*>] y) => $$veccomple(x, y);
@@ -730,6 +755,7 @@ macro int128 int128[<*>].or(int128[<*>] x) => $$reduce_or(x);
 macro int128 int128[<*>].xor(int128[<*>] x) => $$reduce_xor(x);
 macro int128 int128[<*>].max(int128[<*>] x) => $$reduce_max(x);
 macro int128 int128[<*>].min(int128[<*>] x) => $$reduce_min(x);
+macro int128 int128[<*>].dot(int128[<*>] x, int128[<*>] y) => (x * y).sum();

 macro bool[<*>] bool[<*>].comp_lt(bool[<*>] x, bool[<*>] y) => $$veccomplt(x, y);
 macro bool[<*>] bool[<*>].comp_le(bool[<*>] x, bool[<*>] y) => $$veccomple(x, y);
@@ -760,6 +786,7 @@ macro char char[<*>].or(char[<*>] x) => $$reduce_or(x);
 macro char char[<*>].xor(char[<*>] x) => $$reduce_xor(x);
 macro char char[<*>].max(char[<*>] x) => $$reduce_max(x);
 macro char char[<*>].min(char[<*>] x) => $$reduce_min(x);
+macro char char[<*>].dot(char[<*>] x, char[<*>] y) => (x * y).sum();

 macro bool[<*>] ushort[<*>].comp_lt(ushort[<*>] x, ushort[<*>] y) => $$veccomplt(x, y);
 macro bool[<*>] ushort[<*>].comp_le(ushort[<*>] x, ushort[<*>] y) => $$veccomple(x, y);
@@ -775,6 +802,7 @@ macro ushort ushort[<*>].or(ushort[<*>] x) => $$reduce_or(x);
 macro ushort ushort[<*>].xor(ushort[<*>] x) => $$reduce_xor(x);
 macro ushort ushort[<*>].max(ushort[<*>] x) => $$reduce_max(x);
 macro ushort ushort[<*>].min(ushort[<*>] x) => $$reduce_min(x);
+macro ushort ushort[<*>].dot(ushort[<*>] x, ushort[<*>] y) => (x * y).sum();

 macro bool[<*>] uint[<*>].comp_lt(uint[<*>] x, uint[<*>] y) => $$veccomplt(x, y);
 macro bool[<*>] uint[<*>].comp_le(uint[<*>] x, uint[<*>] y) => $$veccomple(x, y);
@@ -790,6 +818,7 @@ macro uint uint[<*>].or(uint[<*>] x) => $$reduce_or(x);
 macro uint uint[<*>].xor(uint[<*>] x) => $$reduce_xor(x);
 macro uint uint[<*>].max(uint[<*>] x) => $$reduce_max(x);
 macro uint uint[<*>].min(uint[<*>] x) => $$reduce_min(x);
+macro uint uint[<*>].dot(uint[<*>] x, uint[<*>] y) => (x * y).sum();

 macro bool[<*>] ulong[<*>].comp_lt(ulong[<*>] x, ulong[<*>] y) => $$veccomplt(x, y);
 macro bool[<*>] ulong[<*>].comp_le(ulong[<*>] x, ulong[<*>] y) => $$veccomple(x, y);
@@ -805,6 +834,7 @@ macro ulong ulong[<*>].or(ulong[<*>] x) => $$reduce_or(x);
 macro ulong ulong[<*>].xor(ulong[<*>] x) => $$reduce_xor(x);
 macro ulong ulong[<*>].max(ulong[<*>] x) => $$reduce_max(x);
 macro ulong ulong[<*>].min(ulong[<*>] x) => $$reduce_min(x);
+macro ulong ulong[<*>].dot(ulong[<*>] x, ulong[<*>] y) => (x * y).sum();

 macro bool[<*>] uint128[<*>].comp_lt(uint128[<*>] x, uint128[<*>] y) => $$veccomplt(x, y);
 macro bool[<*>] uint128[<*>].comp_le(uint128[<*>] x, uint128[<*>] y) => $$veccomple(x, y);
@@ -820,6 +850,7 @@ macro uint128 uint128[<*>].or(uint128[<*>] x) => $$reduce_or(x);
 macro uint128 uint128[<*>].xor(uint128[<*>] x) => $$reduce_xor(x);
 macro uint128 uint128[<*>].max(uint128[<*>] x) => $$reduce_max(x);
 macro uint128 uint128[<*>].min(uint128[<*>] x) => $$reduce_min(x);
+macro uint128 uint128[<*>].dot(uint128[<*>] x, uint128[<*>] y) => (x * y).sum();

 macro char char.sat_add(char x, char y) => $$sat_add(x, y);
 macro char char.sat_sub(char x, char y) => $$sat_sub(x, y);
@@ -1065,3 +1096,70 @@ macro overflow_mul_helper(x, y) @local
 	if ($$overflow_mul(x, y, &res)) return MathError.OVERFLOW?;
 	return res;
 }
+
+macro mul_div_helper(val, mul, div) @private
+{
+	var $Type = $typeof(val);
+	return ($Type)(($Type)mul * (val / ($Type)div) + ($Type)mul * (val % ($Type)div) / ($Type)div);
+}
+macro char char.muldiv(self, char mul, char div) => mul_div_helper(self, mul, div);
+macro ichar ichar.muldiv(self, ichar mul, ichar div) => mul_div_helper(self, mul, div);
+macro short short.muldiv(self, short mul, short div) => mul_div_helper(self, mul, div);
+macro ushort ushort.muldiv(self, ushort mul, ushort div) => mul_div_helper(self, mul, div);
+macro int int.muldiv(self, int mul, int div) => mul_div_helper(self, mul, div);
+macro uint uint.muldiv(self, uint mul, uint div) => mul_div_helper(self, mul, div);
+macro long long.muldiv(self, long mul, long div) => mul_div_helper(self, mul, div);
+macro ulong ulong.muldiv(self, ulong mul, ulong div) => mul_div_helper(self, mul, div);
+
+macro bool @is_same_vector_or_scalar(#vector_value, #vector_or_scalar) @private
+{
+	return (values::@is_vector(#vector_or_scalar) &&& values::@is_same_vector_type(#vector_value, #vector_or_scalar)) ||| values::@is_int(#vector_or_scalar);
+}
+
+/**
+ * @require @is_same_vector_or_scalar(self, mul) `mul must be a vector of the same type as self, or be an integer scalar`
+ * @require @is_same_vector_or_scalar(self, div) `div must be a vector of the same type as self, or be an integer scalar`
+ */
+macro char[<*>] char[<*>].muldiv(self, mul, div)  => mul_div_helper(self, mul, div);
+
+/**
+ * @require @is_same_vector_or_scalar(self, mul) `mul must be a vector of the same type as self, or be an integer scalar`
+ * @require @is_same_vector_or_scalar(self, div) `div must be a vector of the same type as self, or be an integer scalar`
+ */
+macro ichar[<*>] ichar[<*>].muldiv(self, mul, div)  => mul_div_helper(self, mul, div);
+
+/**
+ * @require @is_same_vector_or_scalar(self, mul) `mul must be a vector of the same type as self, or be an integer scalar`
+ * @require @is_same_vector_or_scalar(self, div) `div must be a vector of the same type as self, or be an integer scalar`
+ */
+macro short[<*>] short[<*>].muldiv(self, mul, div) => mul_div_helper(self, mul, div);
+
+/**
+ * @require @is_same_vector_or_scalar(self, mul) `mul must be a vector of the same type as self, or be an integer scalar`
+ * @require @is_same_vector_or_scalar(self, div) `div must be a vector of the same type as self, or be an integer scalar`
+ */
+macro ushort[<*>] ushort[<*>].muldiv(self, mul, div) => mul_div_helper(self, mul, div);
+
+/**
+ * @require @is_same_vector_or_scalar(self, mul) `mul must be a vector of the same type as self, or be an integer scalar`
+ * @require @is_same_vector_or_scalar(self, div) `div must be a vector of the same type as self, or be an integer scalar`
+ */
+macro int[<*>] int[<*>].muldiv(self, mul, div) => mul_div_helper(self, mul, div);
+
+/**
+ * @require @is_same_vector_or_scalar(self, mul) `mul must be a vector of the same type as self, or be an integer scalar`
+ * @require @is_same_vector_or_scalar(self, div) `div must be a vector of the same type as self, or be an integer scalar`
+ */
+macro uint[<*>] uint[<*>].muldiv(self, mul, div) => mul_div_helper(self, mul, div);
+
+/**
+ * @require @is_same_vector_or_scalar(self, mul) `mul must be a vector of the same type as self, or be an integer scalar`
+ * @require @is_same_vector_or_scalar(self, div) `div must be a vector of the same type as self, or be an integer scalar`
+ */
+macro long[<*>] long[<*>].muldiv(self, mul, div) => mul_div_helper(self, mul, div);
+
+/**
+ * @require @is_same_vector_or_scalar(self, mul) `mul must be a vector of the same type as self, or be an integer scalar`
+ * @require @is_same_vector_or_scalar(self, div) `div must be a vector of the same type as self, or be an integer scalar`
+ */
+macro ulong[<*>] ulong[<*>].muldiv(self, mul, div) => mul_div_helper(self, mul, div);
--- a/lib/std/math/math_complex.c3
+++ b/lib/std/math/math_complex.c3
@@ -10,7 +10,7 @@ union Complex
 }


-macro Complex identity() => { 1, 0 };
+const Complex IDENTITY = { 1, 0 };
 macro Complex Complex.add(self, Complex b) => Complex { .v = self.v + b.v };
 macro Complex Complex.add_each(self, Real b) => Complex { .v = self.v + b };
 macro Complex Complex.sub(self, Complex b) => Complex { .v = self.v - b.v };
--- a/lib/std/math/math_matrix.c3
+++ b/lib/std/math/math_matrix.c3
@@ -401,13 +401,13 @@ fn Matrix4x4 ortho(Real left, Real right, Real top, Real bottom, Real near, Real
 fn Matrix4x4 perspective(Real fov, Real aspect_ratio, Real near, Real far)
 {
 	Real f = (Real)math::tan(math::PI * 0.5 - 0.5 * fov);
-	Real rangeInv = (Real)1.0 / (near - far);
-	
+	Real range_inv = (Real)1.0 / (near - far);
+
 	return {
 		f / aspect_ratio, 0, 0, 0,
 		0, f, 0, 0,
-		0, 0, (near + far) * rangeInv, -1,
-		0, 0, near * far * rangeInv * 2, 0,
+		0, 0, (near + far) * range_inv,  near * far * range_inv * 2,
+		0, 0, -1, 0,
 	};
 }

--- a/lib/std/math/math_nolibc/__tan.c3
+++ b/lib/std/math/math_nolibc/__tan.c3
@@ -60,7 +60,7 @@ fn double __tan(double x, double y, int odd) @extern("__tan") @weak @nostrip
 	w = x + r;
 	if (big)
 	{
-		s = 1 - 2 * odd;
+		s = (double)(1 - 2 * odd);
 		v = s - 2.0 * (x + (r - w*w/(w + s)));
 		return sign ? -v : v;
 	}
--- a/lib/std/math/math_nolibc/rempi.c3
+++ b/lib/std/math/math_nolibc/rempi.c3
@@ -63,7 +63,7 @@ fn int __rem_pio2f(float x, double *y)
 	if (ix >= 0x7f800000)
 	{
 		// x is inf or NaN */
-		*y = x-x;
+		*y = x - (double)x;
 		return 0;
 	}
 	/* scale x into [2^23, 2^24-1] */
--- a/lib/std/math/math_quaternion.c3
+++ b/lib/std/math/math_quaternion.c3
@@ -9,7 +9,8 @@ union Quaternion
 	Real[<4>] v;
 }

-macro Quaternion identity() => { 0, 0, 0, 1 };
+const Quaternion IDENTITY = { 0, 0, 0, 1 };
+
 macro Quaternion Quaternion.add(Quaternion a, Quaternion b) => Quaternion { .v = a.v + b.v };
 macro Quaternion Quaternion.add_each(Quaternion a, Real b) => Quaternion { .v = a.v + b };
 macro Quaternion Quaternion.sub(Quaternion a, Quaternion b) => Quaternion { .v = a.v - b.v };
@@ -69,30 +70,16 @@ fn Quaternion Quaternion.mul(a, Quaternion b)

 macro into_matrix(Quaternion* q, $Type) @private
 {
-	$Type result = { .m = { [0] = 1, [5] = 1, [10] = 1, [15] = 1 } };
-	Quaternion norm = q.normalize();
+    Quaternion rotation = q.normalize();
+    var x = rotation.i;
+    var y = rotation.j;
+    var z = rotation.k;
+    var w = rotation.l;

-	var ii = norm.i*norm.i;
-	var jj = norm.j*norm.j;
-	var kk = norm.k*norm.k;
-	var ik = norm.i*norm.k;
-	var ij = norm.i*q.j;
-	var jk = norm.j*norm.k;
-	var li = norm.l*norm.i;
-	var lj = norm.l*norm.j;
-	var lk = norm.l*norm.k;
-
-	result.m00 = 1 - 2*(jj + kk);
-	result.m01 = 2*(ik + lk);
-	result.m02 = 2*(ij - lj);
-
-	result.m10 = 2*(ij - lk);
-	result.m11 = 1 - 2*(ii + kk);
-	result.m12 = 2*(jk + li);
-
-	result.m20 = 2*(ik + lj);
-	result.m21 = 2*(jk - li);
-	result.m22 = 1 - 2*(ii + jj);
-
-	return result;
+    return $Type {
+        1 - 2*y*y - 2*z*z, 2*x*y - 2*z*w, 2*x*z + 2*y*w, 0,
+        2*x*y + 2*z*w, 1 - 2*x*x - 2*z*z, 2*y*z - 2*x*w, 0,
+        2*x*z - 2*y*w, 2*y*z + 2*x*w , 1 - 2*x*x - 2*y*y, 0,
+        0.0, 0.0, 0.0, 1.0,
+    };
 }
--- a/lib/std/math/math_random.c3
+++ b/lib/std/math/math_random.c3
@@ -1,18 +1,15 @@
+/**
+ * Randoms:
+ * General usage -
+ * 1. Create a Random (see std/math/random for various alternatives), or pick DefaultRandom
+ * 2. Define it `DefaultRandom my_random;`
+ * 3. Seed it: `random::seed(&my_random, some_seed);` or `rand::seed_entropy(&my_random);`
+ * 4. Use it with the functions in random: `float random_float = random::next_float(&my_random);`
+ *
+ * For just a simple integer between 0 and n (not including n), you can use `rand(n)`.
+ **/
 module std::math::random;

-interface Random
-{
-	fn void set_seed(char[] input);
-	fn char next_byte();
-	fn ushort next_short();
-	fn uint next_int();
-	fn ulong next_long();
-	fn uint128 next_int128();
-	fn void next_bytes(char[] buffer);
-}
-
-macro bool is_random(random) => $assignable(random, Random*);
-
 /**
 * @require is_random(random)
 **/
@@ -21,12 +18,19 @@ macro void seed(random, seed)
 	random.set_seed(@as_char_view(seed));
 }

+/**
+ * Seed the random with some best effort entropy.
+ *
+ * @require is_random(random)
+ **/
 macro void seed_entropy(random)
 {
 	random.set_seed(&&entropy());
 }

 /**
+ * Get the next value between 0 and max (not including max).
+ *
 * @require is_random(random)
 **/
 macro int next(random, int max)
@@ -34,6 +38,11 @@ macro int next(random, int max)
 	return (int)(next_double(random) * max);
 }

+def DefaultRandom = Sfc64Random;
+
+/**
+ * Get a default random value between 0 and max (not including max)
+ **/
 fn int rand(int max) @builtin
 {
 	tlocal Sfc64Random default_random;
@@ -45,15 +54,20 @@ fn int rand(int max) @builtin
 	}
 	return next(&default_random, max);
 }
+
 /**
+ * Get 'true' or 'false'
+ *
 * @require is_random(random)
 **/
-macro void next_bool(random)
+macro bool next_bool(random)
 {
-	return random.next_byte() & 1;
+	return (bool)(random.next_byte() & 1);
 }

 /**
+ * Get a float between 0 and 1.0, not including 1.0.
+ *
 * @require is_random(random)
 **/
 macro float next_float(random)
@@ -63,6 +77,8 @@ macro float next_float(random)
 }

 /**
+ * Get a double between 0 and 1.0, not including 1.0.
+ *
 * @require is_random(random)
 **/
 macro double next_double(random)
@@ -71,6 +87,9 @@ macro double next_double(random)
 	return val * 0x1.0p-53;
 }

+// True if the value is a Random.
+macro bool is_random(random) => $assignable(random, Random);
+
 macro uint128 @long_to_int128(#function) => (uint128)#function << 64 + #function;
 macro ulong @int_to_long(#function) => (ulong)#function << 32 + #function;
 macro uint @short_to_int(#function) => (uint)#function << 16 + #function;
@@ -94,4 +113,17 @@ macro @random_value_to_bytes(#function, char[] bytes)
 		bytes = bytes[$byte_size..];
 	}
 	unreachable();
-}
+}
+
+// This is the interface to implement for Random implementations, usually
+// it is not invoked directly.
+interface Random
+{
+	fn void set_seed(char[] input);
+	fn char next_byte();
+	fn ushort next_short();
+	fn uint next_int();
+	fn ulong next_long();
+	fn uint128 next_int128();
+	fn void next_bytes(char[] buffer);
+}
--- a/lib/std/math/math_vector.c3
+++ b/lib/std/math/math_vector.c3
@@ -25,11 +25,11 @@ macro Vec4.distance_sq(self, Vec4 v2) => (self - v2).length_sq();

 macro Vec2f.transform(self, Matrix4f mat) => transform2(self, mat);
 macro Vec2f.rotate(self, float angle) => rotate(self, angle);
-macro Vec2f.angle(self, Vec2f v2) => math::atan2(v2[1], v2[0]) - math::atan2(self[1], v2[0]);
+macro Vec2f.angle(self, Vec2f v2) => math::atan2(v2.y, v2.x) - math::atan2(self.y, self.x);

 macro Vec2.transform(self, Matrix4 mat) => transform2(self, mat);
 macro Vec2.rotate(self, double angle) => rotate(self, angle);
-macro Vec2.angle(self, Vec2 v2) => math::atan2(v2[1], v2[0]) - math::atan2(self[1], v2[0]);
+macro Vec2.angle(self, Vec2 v2) => math::atan2(v2.y, v2.x) - math::atan2(self.y, self.x);

 macro Vec2f.clamp_mag(self, float min, float max) => clamp_magnitude(self, min, max);
 macro Vec3f.clamp_mag(self, float min, float max) => clamp_magnitude(self, min, max);
@@ -190,7 +190,7 @@ macro rotate_axis_angle(v, axis, angle) @private
 	var w = axis * math::sin(angle);
 	var wv = w.cross(v);
 	var wwv = w.cross(wv);
-	wv *= math::cos(angle) * 2;
+	wv *= math::cos(($typeof(v))angle) * 2;
 	wwv *= 2;

 	return v + wv + wwv;
@@ -203,10 +203,10 @@ macro matrix_look_at($Type, eye, target, up) @private
 	var vy = vz.cross(vx);

 	return $Type {
-		vx[0], vy[0], vz[0], 0,
-		vx[1], vy[1], vz[1], 0,
-		vx[2], vy[2], vz[2], 0,
-		- vx.dot(eye), - vy.dot(eye), - vz.dot(eye), 1
+		vx[0], vx[1], vx[2], - vx.dot(eye),
+		vy[0], vy[1], vy[2], - vy.dot(eye),
+		vz[0], vz[1], vz[2], - vz.dot(eye),
+		0.0, 0.0, 0.0, 1
 	};
 }

--- a/lib/std/math/random/math.seeder.c3
+++ b/lib/std/math/random/math.seeder.c3
@@ -1,5 +1,5 @@
 module std::math::random;
-import std::hash::fnv32a;
+import std::hash::fnv32a, std::time;

 const ODD_PHI64 @local = 0x9e3779b97f4a7c15;
 const MUL_MCG64 @local = 0xf1357aea2e62a9c5;
@@ -26,7 +26,7 @@ fn void seeder(char[] input, char[] out_buffer)
 	usz out_chars = out_buffer.len;
 	@pool()
 	{
-		ulong[] words = mem::temp_array(ulong, (out_chars + 7) / 8);
+		ulong[] words = mem::temp_alloc_array(ulong, (out_chars + 7) / 8);
 		words[..] = ODD_PHI64;
 		usz words_len_2 = words.len * 2;

@@ -85,8 +85,8 @@ fn char[8 * 4] entropy()
 		hash(&entropy),
 		random_int,
 		hash(clock::now()),
-		hash(&DString.init_new),
-		hash(mem::heap())
+		hash(&DString.new_init),
+		hash(allocator::heap())
    };
    return bitcast(entropy_data, char[8 * 4]);
 }
--- a/lib/std/net/inetaddr.c3
+++ b/lib/std/net/inetaddr.c3
@@ -4,9 +4,9 @@ import std::ascii;

 enum IpProtocol : char (AIFamily ai_family)
 {
-	UNSPECIFIED (os::AF_UNSPEC),
-	IPV4        (os::AF_INET),
-	IPV6        (os::AF_INET6),
+	UNSPECIFIED = os::AF_UNSPEC,
+	IPV4        = os::AF_INET,
+	IPV6        = os::AF_INET6,
 }

 struct InetAddress (Printable)
@@ -56,7 +56,7 @@ fn usz! InetAddress.to_format(InetAddress* addr, Formatter* formatter) @dynamic
 	return formatter.printf("%d.%d.%d.%d", addr.ipv4.a, addr.ipv4.b, addr.ipv4.c, addr.ipv4.d)!;
 }

-fn String InetAddress.to_new_string(InetAddress* addr, Allocator* allocator = mem::heap()) @dynamic
+fn String InetAddress.to_new_string(InetAddress* addr, Allocator allocator = allocator::heap()) @dynamic
 {
 	if (addr.is_ipv6)
 	{
--- a/lib/std/net/net.c3
+++ b/lib/std/net/net.c3
@@ -1,4 +1,5 @@
 module std::net;
+import std::io;

 fault NetError
 {
@@ -26,6 +27,7 @@ fault NetError
 	ALREADY_CONNECTED,
 	NETWORK_UNREACHABLE,
 	OPERATION_NOT_SUPPORTED_ON_SOCKET,
+	CONNECTION_RESET,
 }

 fn uint! ipv4toint(String s)
@@ -56,7 +58,7 @@ fn uint! ipv4toint(String s)
 	return out;
 }

-fn String! int_to_new_ipv4(uint val, Allocator* allocator = mem::heap())
+fn String! int_to_new_ipv4(uint val, Allocator allocator = allocator::heap())
 {
 	char[3 * 4 + 3 + 1] buffer;
 	String res = (String)io::bprintf(&buffer, "%d.%d.%d.%d", val >> 24, (val >> 16) & 0xFF, (val >> 8) & 0xFF, val & 0xFF)!;
@@ -65,5 +67,5 @@ fn String! int_to_new_ipv4(uint val, Allocator* allocator = mem::heap())

 fn String! int_to_temp_ipv4(uint val)
 {
-	return int_to_new_ipv4(val, mem::temp());
+	return int_to_new_ipv4(val, allocator::temp());
 }
--- a/lib/std/net/os/posix.c3
+++ b/lib/std/net/os/posix.c3
@@ -1,5 +1,5 @@
 module std::net::os @if(env::POSIX && SUPPORTS_INET);
-import libc;
+import std::io, libc;

 const int F_GETFL = 3;
 const int F_SETFL = 4;
@@ -16,11 +16,11 @@ struct Posix_pollfd
 def Posix_nfds_t = CUInt;

 extern fn CInt connect(NativeSocket socket, SockAddrPtr address, Socklen_t address_len);
-extern fn NativeSocket socket(AIFamily af, AISockType type, AIProtocol ip_protocol) @extern("socket");
-extern fn int fcntl(NativeSocket socket, int cmd, ...) @extern("fcntl");
-extern fn CInt bind(NativeSocket socket, SockAddrPtr address, Socklen_t address_len) @extern("bind");
-extern fn CInt listen(NativeSocket socket, CInt backlog) @extern("listen");
-extern fn NativeSocket accept(NativeSocket socket, SockAddrPtr address, Socklen_t* address_len) @extern("accept");
+extern fn NativeSocket socket(AIFamily af, AISockType type, AIProtocol ip_protocol);
+extern fn int fcntl(NativeSocket socket, int cmd, ...);
+extern fn CInt bind(NativeSocket socket, SockAddrPtr address, Socklen_t address_len);
+extern fn CInt listen(NativeSocket socket, CInt backlog);
+extern fn NativeSocket accept(NativeSocket socket, SockAddrPtr address, Socklen_t* address_len);
 extern fn CInt poll(Posix_pollfd* fds, Posix_nfds_t nfds, CInt timeout);

 const CUShort POLLIN      = 0x0001;
@@ -39,6 +39,7 @@ fn anyfault convert_error(Errno error)
 		case errno::EALREADY: return NetError.CONNECTION_ALREADY_IN_PROGRESS;
 		case errno::EBADF: return NetError.BAD_SOCKET_DESCRIPTOR;
 		case errno::ECONNREFUSED: return NetError.CONNECTION_REFUSED;
+		case errno::ECONNRESET: return NetError.CONNECTION_RESET;
 		case errno::EISCONN: return NetError.ALREADY_CONNECTED;
 		case errno::ENETUNREACH: return NetError.NETWORK_UNREACHABLE;
 		case errno::ENOTSOCK: return NetError.NOT_A_SOCKET;
@@ -55,6 +56,11 @@ fn anyfault socket_error()
 	return convert_error(libc::errno());
 }

+macro bool NativeSocket.is_valid(self)
+{
+	return (iptr)self >= 0;
+}
+
 macro void! NativeSocket.close(self)
 {
 	if (libc::close(self))
--- a/lib/std/net/os/win32.c3
+++ b/lib/std/net/os/win32.c3
@@ -1,6 +1,5 @@
 module std::net::os @if(env::WIN32);
-import std::os::win32;
-import libc;
+import std::os, std::io, libc;

 const AIFamily PLATFORM_AF_IPX          = 6;
 const AIFamily PLATFORM_AF_APPLETALK    = 16;
@@ -13,7 +12,7 @@ const int FIONREAD = 1074030207;
 const int FIONBIO = -2147195266;
 const int FIOASYNC = -2147195267;

-distinct NativeSocket = uptr;
+distinct NativeSocket = inline Win32_SOCKET;

 extern fn CInt ioctlsocket(NativeSocket, CLong cmd, CULong *argp);
 extern fn WSAError closesocket(NativeSocket);
@@ -23,6 +22,11 @@ extern fn int bind(NativeSocket, SockAddrPtr address, Socklen_t address_len);
 extern fn int listen(NativeSocket, int backlog);
 extern fn NativeSocket accept(NativeSocket, SockAddrPtr address, Socklen_t* address_len);

+macro bool NativeSocket.is_valid(self)
+{
+	return self != (NativeSocket)(uptr)-1;
+}
+
 fn void! NativeSocket.set_non_blocking(self, bool non_blocking)
 {
 	if (ioctlsocket(self, win32::FIONBIO, &&(CULong)non_blocking))
@@ -77,6 +81,7 @@ fn anyfault convert_error(WSAError error)
        case wsa::ENOTSOCK: return NetError.NOT_A_SOCKET;
        case wsa::EOPNOTSUPP: return NetError.OPERATION_NOT_SUPPORTED_ON_SOCKET;
        case wsa::ETIMEDOUT: return NetError.CONNECTION_TIMED_OUT;
+        case wsa::ECONNRESET: return NetError.CONNECTION_RESET;
 		default: return IoError.GENERAL_ERROR;
 	}
 }
--- a/lib/std/net/socket.c3
+++ b/lib/std/net/socket.c3
@@ -1,6 +1,5 @@
 module std::net @if(os::SUPPORTS_INET);
-import std::io;
-import libc;
+import std::io, std::os, std::time, libc;

 struct Socket (InStream, OutStream)
 {
@@ -16,7 +15,7 @@ macro void @loop_over_ai(AddrInfo* ai; @body(NativeSocket fd, AddrInfo* ai))
 	while (ai)
 	{
 		NativeSocket sockfd = os::socket(ai.ai_family, ai.ai_socktype, ai.ai_protocol);
-		if (sockfd > 0)
+		if (sockfd.is_valid())
 		{
 			@body(sockfd, ai);
 		}
@@ -84,12 +83,12 @@ macro Socket new_socket(fd, ai)

 enum SocketOption : char (CInt value)
 {
-	REUSEADDR (os::SO_REUSEADDR),
-	REUSEPORT (os::SO_REUSEPORT) @if(!env::WIN32),
-	KEEPALIVE (os::SO_KEEPALIVE),
-	BROADCAST (os::SO_BROADCAST),
-	OOBINLINE (os::SO_OOBINLINE),
-	DONTROUTE (os::SO_DONTROUTE),
+	REUSEADDR                  = os::SO_REUSEADDR,
+	REUSEPORT @if(!env::WIN32) = os::SO_REUSEPORT,
+	KEEPALIVE                  = os::SO_KEEPALIVE,
+	BROADCAST                  = os::SO_BROADCAST,
+	OOBINLINE                  = os::SO_OOBINLINE,
+	DONTROUTE                  = os::SO_DONTROUTE,
 }

 fn bool! Socket.get_broadcast(&self) => self.get_option(BROADCAST);
@@ -121,8 +120,12 @@ fn bool! Socket.get_option(&self, SocketOption option)

 fn usz! Socket.read(&self, char[] bytes) @dynamic
 {
-	isz n = libc::read((Fd)self.sock, bytes.ptr, bytes.len);
-	if (n < 0) return NetError.READ_FAILED?;
+$if env::WIN32:
+	isz n = libc::recv(self.sock, bytes.ptr, (int)bytes.len, 0);
+$else
+	isz n = libc::recv(self.sock, bytes.ptr, bytes.len, 0);
+$endif
+	if (n < 0) return os::socket_error()?;
 	return (usz)n;
 }

@@ -130,8 +133,12 @@ fn char! Socket.read_byte(&self) @dynamic => io::@read_byte_using_read(self);

 fn usz! Socket.write(&self, char[] bytes) @dynamic
 {
-	isz n = libc::write((Fd)self.sock, bytes.ptr, bytes.len);
-	if (n < 0) return NetError.WRITE_FAILED?;
+$if env::WIN32:
+	isz n = libc::send(self.sock, bytes.ptr, (int)bytes.len, 0);
+$else
+	isz n = libc::send(self.sock, bytes.ptr, bytes.len, 0);
+$endif
+	if (n < 0) return os::socket_error()?;
 	return (usz)n;
 }

--- a/lib/std/net/socket_private.c3
+++ b/lib/std/net/socket_private.c3
@@ -1,5 +1,5 @@
 module std::net @if(os::SUPPORTS_INET);
-import libc;
+import std::time, libc, std::os;

 macro apply_sockoptions(sockfd, options) @private
 {
--- a/lib/std/net/tcp.c3
+++ b/lib/std/net/tcp.c3
@@ -1,6 +1,6 @@
 module std::net::tcp @if(os::SUPPORTS_INET);
 import std::net @public;
-import libc;
+import std::time, libc;

 distinct TcpSocket = inline Socket;
 distinct TcpServerSocket = inline Socket;
@@ -43,8 +43,9 @@ fn TcpServerSocket! listen(String host, uint port, uint backlog, SocketOption...
 fn TcpSocket! accept(TcpServerSocket* server_socket)
 {
 	TcpSocket socket;
+	socket.ai_addrlen = socket.ai_addr_storage.len;
 	socket.sock = os::accept(server_socket.sock, (SockAddrPtr)&socket.ai_addr_storage, &socket.ai_addrlen);
-	if (socket.sock < 0) return NetError.ACCEPT_FAILED?;
+	if (!socket.sock.is_valid()) return NetError.ACCEPT_FAILED?;
 	return socket;
 }

--- a/lib/std/os/backtrace.c3
+++ b/lib/std/os/backtrace.c3
@@ -1,5 +1,5 @@
 module std::os::backtrace;
-import std::collections::list;
+import std::collections::list, std::os, std::io;

 fault BacktraceFault
 {
@@ -10,7 +10,7 @@ fault BacktraceFault
 	RESOLUTION_FAILED,
 }

-const Backtrace BACKTRACE_UNKNOWN = { 0, "", "", "", 0, null };
+const Backtrace BACKTRACE_UNKNOWN = { 0, "", "", "", 0, null, false };

 struct Backtrace (Printable)
 {
@@ -19,7 +19,8 @@ struct Backtrace (Printable)
 	String object_file;
 	String file;
 	uint line;
-	Allocator* allocator;
+	Allocator allocator;
+	bool is_inline;
 }


@@ -35,25 +36,26 @@ fn bool Backtrace.is_unknown(&self)

 fn usz! Backtrace.to_format(&self, Formatter* formatter) @dynamic
 {
+	String inline_suffix = self.is_inline ? " [inline]" : "";
 	if (self.has_file())
 	{
-		return formatter.printf("%s (in %s) (%s:%d)", self.function, self.object_file, self.file, self.line);
+		return formatter.printf("%s (in %s) (%s:%d)%s", self.function, self.object_file, self.file, self.line, inline_suffix);
 	}
 	if (self.is_unknown())
 	{
-		return formatter.printf("??? (in unknown)");
+		return formatter.printf("??? (in unknown)%s", inline_suffix);
 	}
-	return formatter.printf("%s (in %s) (source unavailable)", self.function, self.object_file);
+	return formatter.printf("%s (in %s) (source unavailable)%s", self.function, self.object_file, inline_suffix);
 }
 fn void Backtrace.free(&self)
 {
 	if (!self.allocator) return;
-	self.allocator.free(self.function);
-	self.allocator.free(self.object_file);
-	self.allocator.free(self.file);
+	allocator::free(self.allocator, self.function);
+	allocator::free(self.allocator, self.object_file);
+	allocator::free(self.allocator, self.file);
 }

-fn Backtrace* Backtrace.init(&self, uptr offset, String function, String object_file, String file = "", uint line = 0, Allocator* allocator)
+fn Backtrace* Backtrace.init(&self, uptr offset, String function, String object_file, String file = "", uint line = 0, Allocator allocator)
 {
 	if (!allocator)
 	{
@@ -95,7 +97,7 @@ def symbolize_backtrace = linux::symbolize_backtrace @if(env::LINUX);
 def symbolize_backtrace = win32::symbolize_backtrace @if(env::WIN32);
 def symbolize_backtrace = darwin::symbolize_backtrace @if(env::DARWIN);

-fn BacktraceList! symbolize_backtrace(void*[] backtrace, Allocator* allocator) @if(!env::NATIVE_STACKTRACE)
+fn BacktraceList! symbolize_backtrace(void*[] backtrace, Allocator allocator) @if(!env::NATIVE_STACKTRACE)
 {
 	return {};
 }
--- a/lib/std/os/env.c3
+++ b/lib/std/os/env.c3
@@ -2,14 +2,14 @@
 // 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::os::env;
-import libc;
+import std::io::path, libc, std::os;

 /**
 * @param [in] name
 * @require name.len > 0
 * @return! SearchResult.MISSING
 **/
-fn String! get_var(String name, Allocator* allocator = mem::heap())
+fn String! get_var(String name, Allocator allocator = allocator::heap())
 {
 	@pool(allocator)
 	{
@@ -38,7 +38,7 @@ fn String! get_var(String name, Allocator* allocator = mem::heap())

 fn String! get_var_temp(String name)
 {
-	return get_var(name, mem::temp());
+	return get_var(name, allocator::temp());
 }

 /**
@@ -72,7 +72,7 @@ fn bool set_var(String name, String value, bool overwrite = true)
 /**
 * Returns the current user's home directory.
 **/
-fn String! get_home_dir(Allocator* using = mem::heap())
+fn String! get_home_dir(Allocator using = allocator::heap())
 {
 	String home;
 	$if !env::WIN32:
@@ -83,10 +83,15 @@ fn String! get_home_dir(Allocator* using = mem::heap())
 	return get_var(home, using);
 }

+fn Path! get_config_dir(Allocator allocator = allocator::heap()) @deprecated("use new_get_config_dir()")
+{
+	return new_get_config_dir(allocator) @inline;
+}
+
 /**
 * Returns the current user's config directory.
 **/
-fn Path! get_config_dir(Allocator* allocator = mem::heap())
+fn Path! new_get_config_dir(Allocator allocator = allocator::heap())
 {
 	@pool(allocator)
 	{
@@ -100,7 +105,7 @@ fn Path! get_config_dir(Allocator* allocator = mem::heap())
 			String s = get_var_temp("XDG_CONFIG_HOME") ?? get_var_temp("HOME")!;
 			const DIR = ".config";
 		$endif
-		return path::temp_new(s).append(DIR, .allocator = allocator);
+		return path::temp_new(s).new_append(DIR, .allocator = allocator);
 	$endif
 	};
 }
@@ -126,11 +131,16 @@ fn bool clear_var(String name)
 	};
 }

-fn String! executable_path(Allocator *allocator = mem::heap())
+fn String! executable_path(Allocator allocator = allocator::heap()) @deprecated("use new_executable_path()")
+{
+	return new_executable_path(allocator) @inline;
+}
+
+fn String! new_executable_path(Allocator allocator = allocator::heap())
 {
 	$if env::DARWIN:
 		return darwin::executable_path(allocator);
 	$else
-		return "<Unsupported>";
+		return SearchResult.MISSING?;
 	$endif
 }
--- a/lib/std/os/linux/heap.c3
+++ b/lib/std/os/linux/heap.c3
@@ -0,0 +1,2 @@
+module std::os::linux @if(env::LINUX);
+extern fn usz malloc_usable_size(void* ptr);
--- a/lib/std/os/linux/linux.c3
+++ b/lib/std/os/linux/linux.c3
@@ -1,8 +1,5 @@
 module std::os::linux @if(env::LINUX);
-import libc;
-import std::os::posix;
-import std::io;
-import std::collections::list;
+import libc, std::os, std::io, std::collections::list;

 extern fn isz readlink(ZString path, char* buf, usz bufsize);

@@ -131,48 +128,37 @@ fn ulong! elf_module_image_base(String path) @local
 	return 0;
 }

-fn Backtrace! backtrace_load_from_exec(void* addr, Allocator* allocator) @local
+fn void! backtrace_add_from_exec(BacktraceList* list, void* addr, Allocator allocator) @local
 {
-	char[] buf = mem::temp_array(char, 1024);
+	char[] buf = mem::temp_alloc_array(char, 1024);

 	String exec_path = process::execute_stdout_to_buffer(buf, {"realpath", "-e", string::tformat("/proc/%d/exe", posix::getpid())})!;
 	String obj_name = exec_path.copy(allocator);
 	String addr2line = process::execute_stdout_to_buffer(buf, {"addr2line", "-p", "-i", "-C", "-f", "-e", exec_path, string::tformat("0x%x", addr)})!;
-	return backtrace_from_addr2line(addr, addr2line, obj_name, "???", allocator);
+	return backtrace_add_addr2line(list, addr, addr2line, obj_name, "???", allocator);
 }

-fn Backtrace! backtrace_load_from_dlinfo(void* addr, Linux_Dl_info* info, Allocator* allocator) @local
+fn void! backtrace_add_from_dlinfo(BacktraceList* list, void* addr, Linux_Dl_info* info, Allocator allocator) @local
 {
-	char[] buf = mem::temp_array(char, 1024);
+	char[] buf = mem::temp_alloc_array(char, 1024);

 	void*   obj_addr  = addr - (uptr)info.dli_fbase + (uptr)elf_module_image_base(info.dli_fname.str_view())!;
 	ZString obj_path  = info.dli_fname;
 	String  sname     = info.dli_sname ? info.dli_sname.str_view() : "???";
 	String  addr2line = process::execute_stdout_to_buffer(buf, {"addr2line", "-p", "-i", "-C", "-f", "-e", obj_path.str_view(), string::tformat("0x%x", obj_addr - 1)})!;
-	return backtrace_from_addr2line(addr, addr2line, info.dli_fname.str_view(), sname, allocator);
+	return backtrace_add_addr2line(list, addr, addr2line, info.dli_fname.str_view(), sname, allocator);
 }

-fn Backtrace! backtrace_from_addr2line(void* addr, String addr2line, String obj_name, String func_name, Allocator* allocator) @local
+fn Backtrace! backtrace_line_parse(String string, String obj_name, String func_name, bool is_inlined, Allocator allocator)
 {
-	String[] parts = addr2line.tsplit(" at ");
-	if (parts.len != 2)
-	{
-		return {
-			.function    = func_name.copy(allocator),
-			.object_file = obj_name.copy(allocator),
-			.offset      = (uptr)addr,
-			.file        = "".copy(allocator),
-			.line        = 0,
-			.allocator   = allocator
-		};
-	}
+	String[] parts = string.trim().tsplit(" at ");
+	if (parts.len != 2) return SearchResult.MISSING?;

-	uint   line   = 0;
+	uint line   = 0;
 	String source = "";
 	if (!parts[1].contains("?") && parts[1].contains(":"))
 	{
 		usz index = parts[1].rindex_of_char(':')!;
-
 		source = parts[1][:index];
 		line   = parts[1][index + 1..].to_uint()!;
 	}
@@ -182,28 +168,56 @@ fn Backtrace! backtrace_from_addr2line(void* addr, String addr2line, String obj_
 		.file        = source.copy(allocator),
 		.line        = line,
 		.allocator   = allocator,
+		.is_inline   = is_inlined
 	};
 }
-
-fn Backtrace! backtrace_load_element(void* addr, Allocator* allocator = mem::heap()) @local
+fn void! backtrace_add_addr2line(BacktraceList* list, void* addr, String addr2line, String obj_name, String func_name, Allocator allocator) @local
 {
-	if (!addr) return backtrace::BACKTRACE_UNKNOWN;
+	String[] inline_parts = addr2line.tsplit("(inlined by)");
+	usz last = inline_parts.len - 1;
+	foreach (i, part : inline_parts)
+	{
+		bool is_inline = i != last;
+		Backtrace! trace = backtrace_line_parse(part, obj_name, func_name, is_inline, allocator);
+		if (catch trace)
+		{
+			list.push({
+				.function    = func_name.copy(allocator),
+				.object_file = obj_name.copy(allocator),
+				.offset      = (uptr)addr,
+				.file        = "".copy(allocator),
+				.line        = 0,
+				.allocator   = allocator,
+				.is_inline   = is_inline
+			});
+			continue;
+		}
+		list.push(trace);
+	}
+}
+
+fn void! backtrace_add_element(BacktraceList *list, void* addr, Allocator allocator = allocator::heap()) @local
+{
+	if (!addr)
+	{
+		list.push(backtrace::BACKTRACE_UNKNOWN);
+		return;
+	}

 	@pool(allocator) {
 		Linux_Dl_info info;
-
 		if (dladdr(addr, &info) == 0)
 		{
-			return backtrace_load_from_exec(addr, allocator);
+			return backtrace_add_from_exec(list, addr, allocator);
 		}
-		return backtrace_load_from_dlinfo(addr, &info, allocator);
+		return backtrace_add_from_dlinfo(list, addr, &info, allocator);
 	};
 }

-fn BacktraceList! symbolize_backtrace(void*[] backtrace, Allocator* allocator)
+fn BacktraceList! symbolize_backtrace(void*[] backtrace, Allocator allocator)
 {
 	BacktraceList list;
-	list.init_new(backtrace.len, allocator);
+	list.new_init(backtrace.len, allocator);
 	defer catch
 	{
 		foreach (trace : list)
@@ -216,8 +230,7 @@ fn BacktraceList! symbolize_backtrace(void*[] backtrace, Allocator* allocator)
 	{
 		foreach (addr : backtrace)
 		{
-			Backtrace trace = backtrace_load_element(addr, allocator)!;
-			list.append(trace);
+			backtrace_add_element(&list, addr, allocator)!;
 		}
 	};
 	return list;
--- a/lib/std/os/macos/cf_allocator.c3
+++ b/lib/std/os/macos/cf_allocator.c3
@@ -1,18 +1,18 @@
-module std::os::macos::cf @if(env::DARWIN);
+module std::os::macos::cf @if(env::DARWIN) @link(env::DARWIN, "CoreFoundation.framework");

 distinct CFAllocatorRef = void*;
 distinct CFAllocatorContextRef = void*;
 def CFOptionFlags = usz;

-macro CFAllocatorRef default_allocator() => _macos_CFAllocatorGetDefault();
-macro void CFAllocatorRef.dealloc(CFAllocatorRef allocator, void* ptr) => _macos_CFAllocatorDeallocate(allocator, ptr);
-macro void* CFAllocatorRef.alloc(CFAllocatorRef allocator, usz size) => _macos_CFAllocatorAllocate(allocator, size, 0);
-macro usz CFAllocatorRef.get_preferred_size(CFAllocatorRef allocator, usz req_size) => _macos_CFAllocatorGetPreferredSizeForSize(allocator, req_size, 0);
-macro void CFAllocatorRef.set_default(CFAllocatorRef allocator) => _macos_CFAllocatorSetDefault(allocator);
+macro CFAllocatorRef default_allocator() => macos_CFAllocatorGetDefault();
+macro void CFAllocatorRef.dealloc(CFAllocatorRef allocator, void* ptr) => macos_CFAllocatorDeallocate(allocator, ptr);
+macro void* CFAllocatorRef.alloc(CFAllocatorRef allocator, usz size) => macos_CFAllocatorAllocate(allocator, size, 0);
+macro usz CFAllocatorRef.get_preferred_size(CFAllocatorRef allocator, usz req_size) => macos_CFAllocatorGetPreferredSizeForSize(allocator, req_size, 0);
+macro void CFAllocatorRef.set_default(CFAllocatorRef allocator) => macos_CFAllocatorSetDefault(allocator);

-extern fn CFAllocatorRef _macos_CFAllocatorCreate(CFAllocatorRef allocator, CFAllocatorContextRef context) @extern("CFAllocatorCreate");
-extern fn void _macos_CFAllocatorDeallocate(CFAllocatorRef allocator, void* ptr) @extern("CFAllocatorDeallocate");
-extern fn CFAllocatorRef _macos_CFAllocatorGetDefault() @extern("CFAllocatorGetDefault");
-extern fn void _macos_CFAllocatorSetDefault(CFAllocatorRef allocator) @extern("CFAllocatorSetDefault");
-extern fn void* _macos_CFAllocatorAllocate(CFAllocatorRef allocator, CFIndex size, CFOptionFlags hint) @extern("CFAllocatorAllocate");
-extern fn CFIndex _macos_CFAllocatorGetPreferredSizeForSize(CFAllocatorRef allocator, CFIndex size, CFOptionFlags hint) @extern("CFAllocatorGetPreferredSizeForSize");
+extern fn CFAllocatorRef macos_CFAllocatorCreate(CFAllocatorRef allocator, CFAllocatorContextRef context) @extern("CFAllocatorCreate") @builtin;
+extern fn void macos_CFAllocatorDeallocate(CFAllocatorRef allocator, void* ptr) @extern("CFAllocatorDeallocate") @builtin;
+extern fn CFAllocatorRef macos_CFAllocatorGetDefault() @extern("CFAllocatorGetDefault") @builtin;
+extern fn void macos_CFAllocatorSetDefault(CFAllocatorRef allocator) @extern("CFAllocatorSetDefault") @builtin;
+extern fn void* macos_CFAllocatorAllocate(CFAllocatorRef allocator, CFIndex size, CFOptionFlags hint) @extern("CFAllocatorAllocate") @builtin;
+extern fn CFIndex macos_CFAllocatorGetPreferredSizeForSize(CFAllocatorRef allocator, CFIndex size, CFOptionFlags hint) @extern("CFAllocatorGetPreferredSizeForSize") @builtin;
--- a/lib/std/os/macos/cf_array.c3
+++ b/lib/std/os/macos/cf_array.c3
@@ -1,11 +1,11 @@
-module std::os::macos::cf @if(env::DARWIN);
+module std::os::macos::cf @if(env::DARWIN) @link(env::DARWIN, "CoreFoundation.framework");

 distinct CFArrayRef = void*;
 distinct CFArrayCallBacksRef = void*;
 distinct CFMutableArrayRef = void*;
-extern fn CFArrayRef _macos_CFArrayCreate(CFAllocatorRef allocator, void** values, CFIndex num_values, CFArrayCallBacksRef callBacks) @extern("CFArrayCreate");
-extern fn CFArrayRef _macos_CFArrayCopy(CFAllocatorRef allocator, CFArrayRef array) @extern("CFArrayCopy");
-extern fn CFIndex _macos_CFArrayGetCount(CFArrayRef array) @extern("CFArrayGetCount");
-extern fn void _macos_CFArrayAppendArray(CFMutableArrayRef theArray, CFArrayRef otherArray, CFRange otherRange) @extern("CFArrayAppendArray");
-extern fn CFMutableArrayRef _macos_CFArrayCreateMutable(CFAllocatorRef allocator, CFIndex capacity, CFArrayCallBacksRef callBacks) @extern("CFArrayCreateMutable");
-extern fn void _macos_CFArrayAppendValue(CFMutableArrayRef theArray, void *value) @extern("CFArrayAppendValue");
+extern fn CFArrayRef macos_CFArrayCreate(CFAllocatorRef allocator, void** values, CFIndex num_values, CFArrayCallBacksRef callBacks) @extern("CFArrayCreate") @builtin;
+extern fn CFArrayRef macos_CFArrayCopy(CFAllocatorRef allocator, CFArrayRef array) @extern("CFArrayCopy") @builtin;
+extern fn CFIndex macos_CFArrayGetCount(CFArrayRef array) @extern("CFArrayGetCount") @builtin;
+extern fn void macos_CFArrayAppendArray(CFMutableArrayRef theArray, CFArrayRef otherArray, CFRange otherRange) @extern("CFArrayAppendArray") @builtin;
+extern fn CFMutableArrayRef macos_CFArrayCreateMutable(CFAllocatorRef allocator, CFIndex capacity, CFArrayCallBacksRef callBacks) @extern("CFArrayCreateMutable") @builtin;
+extern fn void macos_CFArrayAppendValue(CFMutableArrayRef theArray, void *value) @extern("CFArrayAppendValue") @builtin;
--- a/Show More
+++ b/Show More