added missing 'auto'

removing <optional>, use concepts
Removing trailing whitespace.
2026-06-08 17:27:07 +00:00 · 2025-07-18 13:02:52 -04:00 · 2025-07-18 08:54:02 -04:00 · 2025-07-18 10:49:47 +00:00 · 2025-07-18 05:12:21 +00:00 · 2025-07-18 05:01:40 +00:00
431 changed files with 227994 additions and 28083 deletions
@@ -1,2 +1,47 @@
 CompileFlags:
    CompilationDatabase: build
+    Add:
+        - -Werror -Wall -Wextra -Weffc++ -Wsign-compare -Wshadow -Wwrite-strings -Wpointer-arith -Winit-self -Wconversion -Wno-sign-conversion
+        - -Wundefined-inline
+Diagnostics:
+    Suppress:
+        - misc-unused-alias-decls
+        - misc-unused-using-decls
+        - misc-definitions-in-headers # TODO fix and remove these violations
+---
+If:
+    PathMatch:
+        - include/.*
+        - src/.*
+    PathExclude:
+        - include/simdjson.h
+        - src/simdjson.cpp
+CompileFlags:
+    Add:
+        - -Wno-unneeded-internal-declaration
+        - -Wno-undefined-internal # TODO fix and remove these violations
+        - -Wno-unused-function
+        - -Wno-unused-const-variable
+Diagnostics:
+    Suppress:
+        - pp_including_mainfile_in_preamble
+        - unused-includes
+---
+# Amalgamated files that require or partly define an implementation
+If:
+    PathMatch:
+        - .*/(arm64|fallback|haswell|icelake|ppc64|westmere)/begin.h
+        - .*/generic/.*
+Diagnostics:
+    Suppress:
+        - pragma_attribute_no_pop_eof
+---
+# clang has a bad time detecting the push/pop together in src/ for some reason
+If:
+    PathMatch:
+        - include/simdjson/.*/end.h
+        - src/(arm64|fallback|haswell|icelake|ppc64|westmere).cpp
+Diagnostics:
+    Suppress:
+        - pragma_attribute_no_pop_eof
+        - pragma_attribute_stack_mismatch
@@ -45,11 +45,15 @@ It is fine to report bugs against our main branch, but if that is what you are d

 **Configuration (please complete the following information if relevant)**
 - OS: [e.g. Ubuntu 16.04.6 LTS]
- - Compiler [e.g. Apple clang version 11.0.3 (clang-1103.0.32.59) x86_64-apple-darwin19.4.0]
+ - Compiler* [e.g. Apple clang version 11.0.3 (clang-1103.0.32.59) x86_64-apple-darwin19.4.0]
 - Version [e.g. 22]
 - Optimization setting (e.g., -O3)

-We support up-to-date 64-bit ARM and x64 FreeBSD, macOS, Windows and Linux systems. Please ensure that your configuration is supported before labelling the issue as a bug. In particular, we do not support legacy 32-bit systems.
+We support up-to-date 64-bit ARM and x64 FreeBSD, macOS, Windows and Linux systems. Please ensure that your configuration is supported before labelling the issue as a bug.
+
+* We do not support unreleased or experimental compilers. If you encounter an issue with a
+pre-release version of a compiler, do not report it as a bug to simdjson. However, we always
+invite contributions either in the form an analysis or of a code contribution.

 **Indicate whether you are willing or able to provide a bug fix as a pull request**

@@ -0,0 +1 @@
+blank_issues_enabled: false
@@ -31,7 +31,7 @@ A clear and concise description of any alternative solutions or features you've
 **Additional context**
 Add any other context or screenshots about the feature request here.

-** Are you willing to contribute code or documentation toward this new feature? **
+**Are you willing to contribute code or documentation toward this new feature?**
 If you plan to contribute to simdjson, please read our
 * CONTRIBUTING guide: https://github.com/simdjson/simdjson/blob/master/CONTRIBUTING.md and our
 * HACKING guide: https://github.com/simdjson/simdjson/blob/master/HACKING.md
@@ -18,7 +18,7 @@ We do not make changes to simdjson without clearly identifiable benefits, which

 Is your issue:

-1. A bug report? If so, please point at a reproducible test. Indicate whether you are willing or able to provide a bug fix as a pull request.
+1. A bug report? If so, please point at a reproducible test. Indicate whether you are willing or able to provide a bug fix as a pull request. As a matter of policy, we do not consider a compiler warning to be a bug.

 2. A build issue? If so, provide all possible details regarding your system configuration. If we cannot reproduce your issue, we cannot fix it.

@@ -0,0 +1,29 @@
+name: Ubuntu ppc64le (GCC 11)
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: uraimo/run-on-arch-action@v3
+        name: Test
+        id: runcmd
+        with:
+          arch: aarch64
+          distro: ubuntu_latest
+          githubToken: ${{ github.token }}
+          install: |
+            apt-get update -q -y
+            apt-get install -y cmake make g++
+          run: |
+            cmake -DSIMDJSON_SANITIZE_UNDEFINED=ON -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF -B build
+            cmake --build build -j=2
+            ctest --output-on-failure --test-dir build
@@ -9,8 +9,8 @@ jobs:
      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/cache@v3
+      - uses: actions/checkout@v4
+      - uses: actions/cache@v4
        with:
          path: dependencies/.cache
          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
@@ -31,4 +31,4 @@ jobs:
          ./alpine.sh cmake --build build_for_alpine
      - name: test
        run: |
-          ./alpine.sh bash -c "cd build_for_alpine && ctest  -LE explicitonly"
+          ./alpine.sh bash -c "cd build_for_alpine && ctest  -LE explicitonly --output-on-failure"
@@ -17,7 +17,7 @@ jobs:
        fuzz-seconds: 600
        dry-run: false
    - name: Upload Crash
-      uses: actions/upload-artifact@v1
+      uses: actions/upload-artifact@v4
      if: failure() && steps.build.outcome == 'success'
      with:
        name: artifacts
@@ -16,7 +16,7 @@ jobs:
      image: debian:testing

    steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4

    - name: Install dependencies
      run: |
@@ -1,9 +1,8 @@
 name: Doxygen GitHub Pages

 on:
-  push:
-    branches:
-      - master
+  release:
+    types: [created]
  # Allows you to run this workflow manually from the Actions tab
  workflow_dispatch:

@@ -19,7 +18,7 @@ jobs:
      url: ${{ steps.deployment.outputs.page_url }}
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
      - name: Install Doxygen
        run: sudo apt-get install doxygen graphviz -y
      - run: mkdir docs
@@ -0,0 +1,17 @@
+on: [push, pull_request]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
+      - uses: mymindstorm/setup-emsdk@6ab9eb1bda2574c4ddb79809fc9247783eaf9021 # v14
+      - name: Verify
+        run: emcc -v
+      - name: Checkout
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v3.6.0
+      - name: Configure
+        run: emcmake cmake -B build
+      - name: Build # We build but do not test
+        run: cmake --build build
@@ -4,9 +4,9 @@ on: [push, pull_request]

 jobs:
  whitespace:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-24.04
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
      - name: Remove whitespace and check the diff
        run: |
          set -eu
@@ -24,7 +24,7 @@ jobs:
             echo "no trailing whitespace found, good!"
          fi
      - name: Archive whitespace patch
-        uses: actions/upload-artifact@v2
+        uses: actions/upload-artifact@v4
        if: always()
        with:
          name: whitespace-patch
@@ -24,7 +24,7 @@ jobs:
      implementations: haswell westmere fallback
      UBSAN_OPTIONS: halt_on_error=1
      MAXLEN: -max_len=4000
-      CLANGVERSION: 15
+      CLANGVERSION: 19
      # which optimization level to use for the sanitizer build (see build_fuzzer.variants.sh)
      OPTLEVEL: -O3

@@ -34,17 +34,18 @@ jobs:
        sudo apt update
        sudo apt-get install --quiet ninja-build valgrind zip unzip lsb-release wget software-properties-common gnupg
        wget https://apt.llvm.org/llvm.sh
+        sudo apt-get purge --auto-remove llvm python3-lldb-15 llvm-15
        chmod +x llvm.sh
        sudo ./llvm.sh $CLANGVERSION

-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4

-    - uses: actions/cache@v3
+    - uses: actions/cache@v4
      with:
        path: dependencies/.cache
        key: ${{ hashFiles('dependencies/CMakeLists.txt') }}

-    - uses: actions/cache@v3
+    - uses: actions/cache@v4
      id: cache-corpus
      with:
        path: out/
@@ -124,7 +125,7 @@ jobs:
        done

    - name: Save the corpus as a github artifact
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
      with:
        name: corpus
        path: corpus.tar
@@ -147,7 +148,7 @@ jobs:
      run: tar cf valgrind.tar valgrind-*.txt

    - name: Save valgrind output as a github artifact
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
      if: always()
      with:
        name: valgrindresults
@@ -155,7 +156,7 @@ jobs:
        if-no-files-found: ignore

    - name: Archive any crashes as an artifact
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
      if: always()
      with:
        name: crashes
@@ -0,0 +1,50 @@
+name: LoongArch64-CI
+
+on: [push, pull_request]
+
+jobs:
+  loongarch64:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        platform:
+          - { toolchain-version: 2023.08.08 }
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install build requirements
+        run: |
+          sudo apt-get update -y
+          sudo apt-get install -y --no-install-recommends cmake
+
+      - uses: actions/cache/restore@v4
+        id: restore-cache
+        with:
+          path: /opt/cross-tools
+          key: loongarch64-${{ matrix.platform.toolchain-version }}
+
+      - name: Download LoongArch64 gcc+glibc toolchain
+        if: ${{ !steps.restore-cache.outputs.cache-hit }}
+        run: |
+          url="https://github.com/loongson/build-tools/releases/download/${{ matrix.platform.toolchain-version }}/x86_64-cross-tools-loongarch64-gcc-libc.tar.xz"
+
+          wget "$url" -O /tmp/toolchain.tar.xz
+
+          mkdir -p /opt
+          tar -C /opt -x -f /tmp/toolchain.tar.xz
+
+      - uses: actions/cache/save@v3
+        if: ${{ !steps.restore-cache.outputs.cache-hit }}
+        with:
+          path: /opt/cross-tools
+          key: loongarch64-${{ matrix.platform.toolchain-version }}
+
+      - name: setup Loongarch64 build environment
+        run: |
+          echo "/opt/cross-tools/bin" >> $GITHUB_PATH
+          echo "CC=loongarch64-unknown-linux-gnu-gcc" >> $GITHUB_ENV
+          echo "CXX=loongarch64-unknown-linux-gnu-g++" >> $GITHUB_ENV
+      - name: configure
+        run: cmake -B build -DCMAKE_SYSTEM_PROCESSOR=loongarch64 -DARCH=lonngarch64 -DCMAKE_SYSTEM_NAME=Linux -DCMAKE_C_COMPILER=loongarch64-unknown-linux-gnu-gcc -DCMAKE_CXX_COMPILER=loongarch64-unknown-linux-gnu-g++
+      - name: build
+        run: cmake --build build
@@ -9,8 +9,8 @@ jobs:
      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
    runs-on: macos-latest
    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/cache@v3
+      - uses: actions/checkout@v4
+      - uses: actions/cache@v4
        with:
          path: dependencies/.cache
          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
@@ -20,14 +20,25 @@ jobs:
          cd builddebug &&
          cmake -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF ..  &&
          cmake --build .   &&
-          ctest -j --output-on-failure -LE explicitonly   &&
+          ctest --output-on-failure -LE explicitonly -j   &&
          cd .. &&
          mkdir build &&
          cd build &&
          cmake  -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
          cmake --build .   &&
-          ctest -j --output-on-failure -LE explicitonly   &&
+          ctest --output-on-failure -LE explicitonly -j   &&
          cmake --install . &&
          echo -e '#include <simdjson.h>\nint main(int argc,char**argv) {simdjson::dom::parser parser;simdjson::dom::element tweets = parser.load(argv[1]); }' > tmp.cpp && c++ -Idestination/include -Ldestination/lib -std=c++17 -Wl,-rpath,destination/lib -o linkandrun tmp.cpp -lsimdjson && ./linkandrun jsonexamples/twitter.json &&
          cd ../tests/installation_tests/find &&
          mkdir build && cd build && cmake -DCMAKE_INSTALL_PREFIX:PATH=../../../build/destination .. &&  cmake --build .
+      - name: Use cmake (shared)
+        run: |
+          mkdir buildshared &&
+          cd buildshared &&
+          cmake  -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=ON -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
+          cmake --build .   &&
+          ctest --output-on-failure -LE explicitonly -j   &&
+          cmake --install . &&
+          echo -e '#include <simdjson.h>\nint main(int argc,char**argv) {simdjson::dom::parser parser;simdjson::dom::element tweets = parser.load(argv[1]); }' > tmp.cpp && c++ -Idestination/include -Ldestination/lib -std=c++17 -Wl,-rpath,destination/lib -o linkandrun tmp.cpp -lsimdjson && ./linkandrun jsonexamples/twitter.json &&
+          cd ../tests/installation_tests/find &&
+          mkdir buildshared && cd buildshared && cmake -DCMAKE_INSTALL_PREFIX:PATH=../../../buildshared/destination .. &&  cmake --build .
@@ -20,12 +20,15 @@ jobs:
          - msystem: "MINGW64"
            install: mingw-w64-x86_64-libxml2 mingw-w64-x86_64-cmake mingw-w64-x86_64-ninja mingw-w64-x86_64-clang
            type: Debug
+          - msystem: "MINGW64"
+            install: mingw-w64-x86_64-libxml2 mingw-w64-x86_64-cmake mingw-w64-x86_64-ninja mingw-w64-x86_64-clang
+            type: RelWithDebInfo
    env:
      CMAKE_GENERATOR: Ninja

    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/cache@v3
+      - uses: actions/checkout@v4
+      - uses: actions/cache@v4
        with:
          path: dependencies/.cache
          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
@@ -22,12 +22,15 @@ jobs:
          - msystem: "MINGW64"
            install: mingw-w64-x86_64-cmake mingw-w64-x86_64-ninja mingw-w64-x86_64-gcc
            type: Debug
+          - msystem: "MINGW64"
+            install: mingw-w64-x86_64-cmake mingw-w64-x86_64-ninja mingw-w64-x86_64-gcc
+            type: RelWithDebInfo
    env:
      CMAKE_GENERATOR: Ninja

    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/cache@v3
+      - uses: actions/checkout@v4
+      - uses: actions/cache@v4
        with:
          path: dependencies/.cache
          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
@@ -1,71 +0,0 @@
-name: short fuzz on the power arch
-
-on:
-  push:
-    branches: [ master ]
-  pull_request:
-    branches: [ master ]
-
-jobs:
-  armv7_job:
-    if: >-
-      ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
-      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
-    # The host should always be Linux
-    runs-on: ubuntu-20.04
-    name: Build on ubuntu-20.04 ppc64le
-    steps:
-      - uses: actions/checkout@v3
-      - uses: uraimo/run-on-arch-action@v2.0.5
-        name: Run commands
-        id: runcmd
-        env:
-          DEBIAN_FRONTEND: noninteractive
-        with:
-          arch: ppc64le
-          distro: buster
-
-          # Not required, but speeds up builds by storing container images in
-          # a GitHub package registry.
-          githubToken: ${{ github.token }}
-
-          run: |
-            export CLANGSUFFIX="-7"
-            apt-get -qq update
-            apt-get install -q -y clang-7 libfuzzer-7-dev git wget zip ninja-build gnupg software-properties-common
-            wget -q -O - "https://raw.githubusercontent.com/simdjson/debian-ppa/master/key.gpg" | apt-key add -
-            apt-add-repository "deb https://raw.githubusercontent.com/simdjson/debian-ppa/master simdjson main"
-            apt-get -qq update
-            apt-get purge cmake cmake-data
-            apt-get -t simdjson -y install cmake
-            mkdir -p build ; cd build
-            cmake .. -GNinja \
-                  -DCMAKE_CXX_COMPILER=clang++$CLANGSUFFIX \
-                  -DCMAKE_C_COMPILER=clang$CLANGSUFFIX \
-                  -DBUILD_SHARED_LIBS=OFF \
-                  -DSIMDJSON_DEVELOPER_MODE=ON \
-                  -DSIMDJSON_ENABLE_FUZZING=On \
-                  -DSIMDJSON_COMPETITION=OFF \
-                  -DSIMDJSON_GOOGLE_BENCHMARKS=OFF \
-                  -DSIMDJSON_DISABLE_DEPRECATED_API=On \
-                  -DSIMDJSON_FUZZ_LDFLAGS=-lFuzzer \
-                  -DCMAKE_CXX_FLAGS="-fsanitize=fuzzer-no-link -DFUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION=" \
-                  -DCMAKE_C_FLAGS="-fsanitize=fuzzer-no-link" \
-                  -DCMAKE_BUILD_TYPE=Release \
-                  -DSIMDJSON_FUZZ_LINKMAIN=Off
-            cd ..
-            builddir=build
-            cmake --build $builddir
-            wget -O corpus.tar.gz https://readonly:readonly@www.pauldreik.se/fuzzdata/index.php?project=simdjson
-            tar xf corpus.tar.gz
-            fuzzernames=$(cmake --build $builddir --target print_all_fuzzernames |tail -n1)
-            for fuzzer in $fuzzernames ; do
-               exe=$builddir/fuzz/$fuzzer
-               shortname=$(echo $fuzzer |cut -f2- -d_)
-               echo found fuzzer $shortname with executable $exe
-               mkdir -p out/$shortname
-               others=$(find out -type d -not -name $shortname -not -name out -not -name cmin)
-               $exe -max_total_time=20  -max_len=4000 out/$shortname $others
-               echo "*************************************************************************"
-            done
-            echo "all is good, no errors found in any of these fuzzers: $fuzzernames"
@@ -12,8 +12,8 @@ jobs:
  build:
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v3
-      - uses: uraimo/run-on-arch-action@v2
+      - uses: actions/checkout@v4
+      - uses: uraimo/run-on-arch-action@v3
        name: Test
        id: runcmd
        with:
@@ -24,6 +24,6 @@ jobs:
            apt-get update -q -y
            apt-get install -y cmake make g++
          run: |
-            cmake -DCMAKE_BUILD_TYPE=Release -B build
+            cmake -DCMAKE_BUILD_TYPE=Release -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF  -B build
            cmake --build build -j=2
            ctest --output-on-failure --test-dir build
@@ -0,0 +1,29 @@
+name: Ubuntu riscv64 (GCC 11)
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: uraimo/run-on-arch-action@v3
+        name: Test
+        id: runcmd
+        with:
+          arch: riscv64
+          distro: ubuntu_latest
+          githubToken: ${{ github.token }}
+          install: |
+            apt-get update -q -y
+            apt-get install -y cmake make g++
+          run: |
+            cmake -DCMAKE_BUILD_TYPE=Release -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF  -B build
+            cmake --build build -j=2
+            ctest --output-on-failure --test-dir build
@@ -12,8 +12,8 @@ jobs:
  build:
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v3
-      - uses: uraimo/run-on-arch-action@v2
+      - uses: actions/checkout@v4
+      - uses: uraimo/run-on-arch-action@v3
        name: Test
        id: runcmd
        with:
@@ -24,6 +24,6 @@ jobs:
            apt-get update -q -y
            apt-get install -y cmake make g++
          run: |
-            cmake -DCMAKE_BUILD_TYPE=Release -B build
+            cmake -DCMAKE_BUILD_TYPE=Release  -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF -B build
            cmake --build build -j=2
            ctest --output-on-failure --test-dir build
@@ -1,38 +0,0 @@
-name: Ubuntu 20.04 CI (GCC 8)
-
-on: [push, pull_request]
-
-jobs:
-  ubuntu-build:
-    if: >-
-      ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
-      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
-    runs-on: ubuntu-20.04
-    env:
-      CXX: g++-8
-      CC: gcc-8
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/cache@v3
-        with:
-          path: dependencies/.cache
-          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
-      - name: Install GCC 8
-        run: sudo apt-get install -y g++-8
-      - name: Use cmake
-        run: |
-          mkdir builddebug &&
-          cd builddebug &&
-          cmake -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF ..  &&
-          cmake --build .   &&
-          ctest -j --output-on-failure -LE explicitonly   &&
-          cd .. &&
-          mkdir build &&
-          cd build &&
-          cmake  -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
-          cmake --build .   &&
-          ctest -j --output-on-failure -LE explicitonly   &&
-          cmake --install . &&
-          echo -e '#include <simdjson.h>\nint main(int argc,char**argv) {simdjson::dom::parser parser;simdjson::dom::element tweets = parser.load(argv[1]); }' > tmp.cpp && c++ -Idestination/include -Ldestination/lib -std=c++17 -Wl,-rpath,destination/lib -o linkandrun tmp.cpp -lsimdjson && ./linkandrun jsonexamples/twitter.json &&
-          cd ../tests/installation_tests/find &&
-          mkdir build && cd build && cmake -DCMAKE_INSTALL_PREFIX:PATH=../../../build/destination .. &&  cmake --build .
@@ -1,33 +0,0 @@
-name: Ubuntu 20.04 CI (GCC 9)
-
-on: [push, pull_request]
-
-jobs:
-  ubuntu-build:
-    if: >-
-      ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
-      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
-    runs-on: ubuntu-20.04
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/cache@v3
-        with:
-          path: dependencies/.cache
-          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
-      - name: Use cmake
-        run: |
-          mkdir builddebug &&
-          cd builddebug &&
-          cmake -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF ..  &&
-          cmake --build .   &&
-          ctest -j --output-on-failure -LE explicitonly   &&
-          cd .. &&
-          mkdir build &&
-          cd build &&
-          cmake  -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
-          cmake --build .   &&
-          ctest -j --output-on-failure -LE explicitonly   &&
-          cmake --install . &&
-          echo -e '#include <simdjson.h>\nint main(int argc,char**argv) {simdjson::dom::parser parser;simdjson::dom::element tweets = parser.load(argv[1]); }' > tmp.cpp && c++ -Idestination/include -Ldestination/lib -std=c++17 -Wl,-rpath,destination/lib -o linkandrun tmp.cpp -lsimdjson && ./linkandrun jsonexamples/twitter.json &&
-          cd ../tests/installation_tests/find &&
-          mkdir build && cd build && cmake -DCMAKE_INSTALL_PREFIX:PATH=../../../build/destination .. &&  cmake --build .
@@ -9,17 +9,15 @@ jobs:
      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
    runs-on: ubuntu-22.04
    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/cache@v3
+      - uses: actions/checkout@v4
+      - uses: actions/cache@v4
        with:
          path: dependencies/.cache
          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
-      - name: Install clang++-13
-        run: sudo apt-get install -y clang++-13
      - name: Use cmake
        run: |
          mkdir build &&
          cd build &&
          CXX=clang++-13 cmake -DSIMDJSON_DEVELOPER_MODE=ON ..  &&
          cmake --build .   &&
-          ctest -j --output-on-failure -LE explicitonly
+          ctest --output-on-failure -LE explicitonly -j
@@ -9,17 +9,15 @@ jobs:
      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
    runs-on: ubuntu-22.04
    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/cache@v3
+      - uses: actions/checkout@v4
+      - uses: actions/cache@v4
        with:
          path: dependencies/.cache
          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
-      - name: Install clang++-14
-        run: sudo apt-get install -y clang++-14
      - name: Use cmake
        run: |
          mkdir build &&
          cd build &&
          CXX=clang++-14 cmake -DSIMDJSON_DEVELOPER_MODE=ON ..  &&
          cmake --build .   &&
-          ctest -j --output-on-failure -LE explicitonly
+          ctest --output-on-failure -LE explicitonly -j
@@ -9,8 +9,8 @@ jobs:
      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
    runs-on: ubuntu-22.04
    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/cache@v3
+      - uses: actions/checkout@v4
+      - uses: actions/cache@v4
        with:
          path: dependencies/.cache
          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
@@ -20,13 +20,13 @@ jobs:
          cd builddebug &&
          CXX=g++-12 cmake -DSIMDJSON_CXX_STANDARD=20 -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF ..  &&
          cmake --build .   &&
-          ctest -j --output-on-failure -LE explicitonly   &&
+          ctest --output-on-failure -LE explicitonly -j   &&
          cd .. &&
          mkdir build &&
          cd build &&
          CXX=g++-12 cmake -DSIMDJSON_CXX_STANDARD=20  -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
          cmake --build .   &&
-          ctest -j --output-on-failure -LE explicitonly   &&
+          ctest --output-on-failure -LE explicitonly -j   &&
          cmake --install . &&
          echo -e '#include <simdjson.h>\nint main(int argc,char**argv) {simdjson::dom::parser parser;simdjson::dom::element tweets = parser.load(argv[1]); }' > tmp.cpp && c++ -Idestination/include -Ldestination/lib -std=c++17 -Wl,-rpath,destination/lib -o linkandrun tmp.cpp -lsimdjson && ./linkandrun jsonexamples/twitter.json &&
          cd ../tests/installation_tests/find &&
@@ -9,17 +9,15 @@ jobs:
      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
    runs-on: ubuntu-22.04
    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/cache@v3
+      - uses: actions/checkout@v4
+      - uses: actions/cache@v4
        with:
          path: dependencies/.cache
          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
-      - name: Install gcc12
-        run: sudo apt-get install -y g++-12
      - name: Use cmake
        run: |
          mkdir build &&
          cd build &&
          CXX=g++-12 cmake -DSIMDJSON_DEVELOPER_MODE=ON ..  &&
          cmake --build .   &&
-          ctest -j --output-on-failure -LE explicitonly
+          ctest --output-on-failure -LE explicitonly -j
@@ -8,8 +8,8 @@ jobs:
      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
    runs-on: ubuntu-22.04
    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/cache@v3
+      - uses: actions/checkout@v4
+      - uses: actions/cache@v4
        with:
          path: dependencies/.cache
          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
@@ -1,4 +1,4 @@
-name: Ubuntu 20.04 CI (GCC 9) with Thread Sanitizer
+name: Ubuntu 22.04 CI (GCC 12) with Thread Sanitizer

 on: [push, pull_request]

@@ -7,10 +7,10 @@ jobs:
    if: >-
      ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/cache@v3
+      - uses: actions/checkout@v4
+      - uses: actions/cache@v4
        with:
          path: dependencies/.cache
          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
@@ -18,7 +18,7 @@ jobs:
        run: |
          mkdir build &&
          cd build &&
-          cmake  -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_SANITIZE_THREADS=ON ..  &&
+          CXX=g++-12 cmake  -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_SANITIZE_THREADS=ON ..  &&
          cmake --build . --target document_stream_tests  --target ondemand_document_stream_tests --target parse_many_test  &&
          ctest --output-on-failure  -R parse_many_test  &&
          ctest --output-on-failure  -R document_stream_tests
@@ -9,24 +9,38 @@ jobs:
      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
    runs-on: ubuntu-22.04
    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/cache@v3
+      - uses: actions/checkout@v4
+      - uses: actions/cache@v4
        with:
          path: dependencies/.cache
          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
+      - name: Use cmake to build just the library
+        run: |
+          mkdir buildjustlib &&
+          cd buildjustlib &&
+          cmake -DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS=OFF -DSIMDJSON_DEVELOPER_MODE=OFF -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
+          cmake --build .   &&
+          cmake --install . &&
+          echo -e '#include <simdjson.h>\nint main(int argc,char**argv) {simdjson::dom::parser parser;simdjson::dom::element tweets = parser.load(argv[1]); }' > tmp.cpp &&
+          c++ -Idestination/include -Ldestination/lib -std=c++17 -Wl,-rpath,destination/lib -o linkandrun tmp.cpp -lsimdjson &&
+          cd ../tests/installation_tests/find &&
+          mkdir buildjustlib &&
+          cd buildjustlib &&
+          cmake -DCMAKE_INSTALL_PREFIX:PATH=../../../buildjustlib/destination .. &&
+          cmake --build .
      - name: Use cmake
        run: |
          mkdir builddebug &&
          cd builddebug &&
          cmake -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF ..  &&
          cmake --build .   &&
-          ctest -j --output-on-failure -LE explicitonly   &&
+          ctest --output-on-failure -LE explicitonly -j   &&
          cd .. &&
          mkdir build &&
          cd build &&
          cmake  -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
          cmake --build .   &&
-          ctest -j --output-on-failure -LE explicitonly   &&
+          ctest --output-on-failure -LE explicitonly -j   &&
          cmake --install . &&
          echo -e '#include <simdjson.h>\nint main(int argc,char**argv) {simdjson::dom::parser parser;simdjson::dom::element tweets = parser.load(argv[1]); }' > tmp.cpp && c++ -Idestination/include -Ldestination/lib -std=c++17 -Wl,-rpath,destination/lib -o linkandrun tmp.cpp -lsimdjson && ./linkandrun jsonexamples/twitter.json &&
          cd ../tests/installation_tests/find &&
@@ -13,10 +13,10 @@ jobs:
    if: >-
      ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-24.04
    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/cache@v3
+      - uses: actions/checkout@v4
+      - uses: actions/cache@v4
        with:
          path: dependencies/.cache
          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
@@ -0,0 +1,22 @@
+name: Ubuntu 24.04 CI (CXX 20)
+
+on: [push, pull_request]
+jobs:
+  ubuntu-build:
+    if: >-
+      ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
+      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
+    runs-on: ubuntu-24.04
+    strategy:
+      matrix:
+        cxx: [g++-13, clang++-16]
+    steps:
+      - uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 # v4.1.6
+      - name: Prepare
+        run: cmake -DSIMDJSON_CXX_STANDARD=20 -DSIMDJSON_DEVELOPER_MODE=ON  -B build
+        env:
+          CXX: ${{matrix.cxx}}
+      - name: Build
+        run: cmake --build build -j=2
+      - name: Test
+        run: ctest --output-on-failure --test-dir build
@@ -7,10 +7,10 @@ jobs:
    if: >-
      ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-24.04
    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/cache@v3
+      - uses: actions/checkout@v4
+      - uses: actions/cache@v4
        with:
          path: dependencies/.cache
          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
@@ -20,13 +20,13 @@ jobs:
          cd builddebug &&
          cmake -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_EXCEPTIONS=OFF -DBUILD_SHARED_LIBS=OFF ..  &&
          cmake --build .   &&
-          ctest -j --output-on-failure -LE explicitonly   &&
+          ctest --output-on-failure -LE explicitonly -j   &&
          cd .. &&
          mkdir build &&
          cd build &&
          cmake  -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_EXCEPTIONS=OFF -DBUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
          cmake --build .   &&
-          ctest -j --output-on-failure -LE explicitonly   &&
+          ctest --output-on-failure -LE explicitonly -j   &&
          make install  &&
          echo -e '#include <simdjson.h>\nint main(int argc,char**argv) {simdjson::dom::parser parser;simdjson::dom::element tweets = parser.load(argv[1]); }' > tmp.cpp && c++ -Idestination/include -Ldestination/lib -std=c++17 -Wl,-rpath,destination/lib -o linkandrun tmp.cpp -lsimdjson && ./linkandrun jsonexamples/twitter.json &&
          mkdir testfindpackage &&
@@ -7,10 +7,10 @@ jobs:
    if: >-
      ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-24.04
    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/cache@v3
+      - uses: actions/checkout@v4
+      - uses: actions/cache@v4
        with:
          path: dependencies/.cache
          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
@@ -20,13 +20,13 @@ jobs:
          cd builddebug &&
          cmake -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF  -DSIMDJSON_ENABLE_THREADS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF ..  &&
          cmake --build .   &&
-          ctest -j --output-on-failure -LE explicitonly   &&
+          ctest --output-on-failure -LE explicitonly -j   &&
          cd .. &&
          mkdir build &&
          cd build &&
          cmake  -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_ENABLE_THREADS=OFF -DBUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
          cmake --build .   &&
-          ctest -j --output-on-failure -LE explicitonly   &&
+          ctest --output-on-failure -LE explicitonly -j   &&
          make install  &&
          echo -e '#include <simdjson.h>\nint main(int argc,char**argv) {simdjson::dom::parser parser;simdjson::dom::element tweets = parser.load(argv[1]); }' > tmp.cpp && c++ -Idestination/include -Ldestination/lib -std=c++17 -Wl,-rpath,destination/lib -o linkandrun tmp.cpp -lsimdjson && ./linkandrun jsonexamples/twitter.json &&
          mkdir testfindpackage &&
@@ -3,14 +3,14 @@ name: Ubuntu 20.04 CI (GCC 9) With Memory Sanitizer
 on: [push, pull_request]

 jobs:
-  ubuntu-build:
+  ubuntu-build-address-sanitizier:
    if: >-
      ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-24.04
    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/cache@v3
+      - uses: actions/checkout@v4
+      - uses: actions/cache@v4
        with:
          path: dependencies/.cache
          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
@@ -20,11 +20,22 @@ jobs:
          cd builddebug &&
          cmake -DSIMDJSON_SANITIZE=ON -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF ..  &&
          cmake --build .   &&
-          ctest -j --output-on-failure -LE explicitonly
+          ctest --output-on-failure -LE explicitonly -j
+  ubuntu-build-undefined-sanitizer:
+    if: >-
+      ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
+      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/cache@v4
+        with:
+          path: dependencies/.cache
+          key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
      - name: Use cmake with undefined sanitizer
        run: |
          mkdir builddebugundefsani &&
          cd builddebugundefsani &&
          cmake -DSIMDJSON_SANITIZE_UNDEFINED=ON -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF ..  &&
          cmake --build .   &&
-          ctest -j --output-on-failure -LE explicitonly
+          ctest --output-on-failure -LE explicitonly -j
@@ -0,0 +1,25 @@
+name: Ubuntu 24.04 CI
+
+on: [push, pull_request]
+jobs:
+  ubuntu-build:
+    if: >-
+      ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
+      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
+    runs-on: ubuntu-24.04
+    strategy:
+      matrix:
+        shared: [ON, OFF]
+        cxx: [g++-13, clang++-16]
+        sanitizer: [ON, OFF]
+        build_type: [RelWithDebInfo, Debug, Release]
+    steps:
+      - uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 # v4.1.6
+      - name: Prepare
+        run: cmake -DCMAKE_BUILD_TYPE=${{matrix.build_type}} -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_SANITIZE=${{matrix.sanitizer}} -DBUILD_SHARED_LIBS=${{matrix.shared}}  -B build
+        env:
+          CXX: ${{matrix.cxx}}
+      - name: Build
+        run: cmake --build build -j=2
+      - name: Test
+        run: ctest --output-on-failure --test-dir build
@@ -10,12 +10,12 @@ jobs:
       fail-fast: false
       matrix:
         include:
-           - {arch: ARM}
           - {arch: ARM64}
+           - {arch: ARM64EC}
     steps:
       - name: checkout
-         uses: actions/checkout@v3
+         uses: actions/checkout@v4
       - name: Use cmake
         run: |
-           cmake -A ${{ matrix.arch }} -DCMAKE_CROSSCOMPILING=1 -DSIMDJSON_DEVELOPER_MODE=ON -D SIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_EXCEPTIONS=OFF -B build  &&
+           cmake -A ${{ matrix.arch }} -DCMAKE_SYSTEM_VERSION="10.0.22621.0" -DCMAKE_CROSSCOMPILING=1 -DSIMDJSON_DEVELOPER_MODE=ON -D SIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_EXCEPTIONS=OFF -B build  &&
           cmake --build build --verbose
@@ -19,7 +19,7 @@ jobs:
          - {gen: Visual Studio 17 2022, arch: x64, shared: OFF}
    steps:
    - name: checkout
-      uses: actions/checkout@v3
+      uses: actions/checkout@v4
    - name: Configure
      run: |
        cmake -DSIMDJSON_CXX_STANDARD=20 -G "${{matrix.gen}}" -A ${{matrix.arch}} -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF -DBUILD_SHARED_LIBS=${{matrix.shared}} -B build
@@ -13,32 +13,28 @@ jobs:
      fail-fast: false
      matrix:
        include:
-          - {gen: Visual Studio 17 2022, arch: Win32, shared: ON}
-          - {gen: Visual Studio 17 2022, arch: Win32, shared: OFF}
-          - {gen: Visual Studio 17 2022, arch: x64, shared: ON}
-          - {gen: Visual Studio 17 2022, arch: x64, shared: OFF}
+          - {gen: Visual Studio 17 2022, arch: Win32, shared: ON, build_type: Release}
+          - {gen: Visual Studio 17 2022, arch: Win32, shared: OFF, build_type: Release}
+          - {gen: Visual Studio 17 2022, arch: x64, shared: ON, build_type: Release}
+          - {gen: Visual Studio 17 2022, arch: x64, shared: OFF, build_type: Debug}
+          - {gen: Visual Studio 17 2022, arch: x64, shared: OFF, build_type: Release}
+          - {gen: Visual Studio 17 2022, arch: x64, shared: OFF, build_type: RelWithDebInfo}
    steps:
    - name: checkout
-      uses: actions/checkout@v3
+      uses: actions/checkout@v4
    - name: Configure
      run: |
        cmake -G "${{matrix.gen}}" -A ${{matrix.arch}} -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF -DBUILD_SHARED_LIBS=${{matrix.shared}} -B build
    - name: Build Debug
-      run: cmake --build build --config Debug --verbose
-    - name: Build Release
-      run: cmake --build build --config Release --verbose
-    - name: Run Release tests
+      run: cmake --build build --config ${{matrix.build_type}} --verbose
+    - name: Run tests
      run: |
        cd build
-        ctest -C Release  -LE explicitonly  --output-on-failure
-    - name: Run Debug tests
-      run: |
-        cd build
-        ctest -C Debug  -LE explicitonly  --output-on-failure
+        ctest -C ${{matrix.build_type}}  -LE explicitonly  --output-on-failure
    - name: Install
      run: |
-        cmake --install build --config Release
+        cmake --install build --config ${{matrix.build_type}}
    - name: Test Installation
      run: |
        cmake -G "${{matrix.gen}}" -A ${{matrix.arch}}  -B build_install_test tests/installation_tests/find
-        cmake --build build_install_test --config Release
+        cmake --build build_install_test --config ${{matrix.build_type}}
@@ -0,0 +1,37 @@
+name: VS17-CLANG-CI
+
+on: [push, pull_request]
+
+jobs:
+  ci:
+    if: >-
+      ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
+      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
+    name: windows-vs17
+    runs-on: windows-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - {gen: Visual Studio 17 2022, arch: x64, build_type: Debug}
+          - {gen: Visual Studio 17 2022, arch: x64, build_type: Release}
+          - {gen: Visual Studio 17 2022, arch: x64, build_type: RelWithDebInfo}
+    steps:
+    - name: checkout
+      uses: actions/checkout@v4
+    - name: Configure
+      run: |
+        cmake -G "${{matrix.gen}}" -A ${{matrix.arch}}  -T ClangCL -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF -B build
+    - name: Build
+      run: cmake --build build --config ${{matrix.build_type}} --verbose
+    - name: Run tests
+      run: |
+        cd build
+        ctest -C ${{matrix.build_type}}  -LE explicitonly  --output-on-failure
+    - name: Install
+      run: |
+        cmake --install build --config ${{matrix.build_type}}
+    - name: Test Installation
+      run: |
+        cmake -G "${{matrix.gen}}" -A ${{matrix.arch}}  -B build_install_test tests/installation_tests/find
+        cmake --build build_install_test --config ${{matrix.build_type}}
@@ -13,29 +13,25 @@ jobs:
      fail-fast: false
      matrix:
        include:
-          - {gen: Visual Studio 17 2022, arch: x64}
+          - {gen: Visual Studio 17 2022, arch: x64, build_type: Debug}
+          - {gen: Visual Studio 17 2022, arch: x64, build_type: Release}
+          - {gen: Visual Studio 17 2022, arch: x64, build_type: RelWithDebInfo}
    steps:
    - name: checkout
-      uses: actions/checkout@v3
+      uses: actions/checkout@v4
    - name: Configure
      run: |
        cmake -G "${{matrix.gen}}" -A ${{matrix.arch}}  -T ClangCL -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF -B build
-    - name: Build Debug
-      run: cmake --build build --config Debug --verbose
-    - name: Build Release
-      run: cmake --build build --config Release --verbose
-    - name: Run Release tests
+    - name: Build
+      run: cmake --build build --config ${{matrix.build_type}} --verbose
+    - name: Run tests
      run: |
        cd build
-        ctest -C Release  -LE explicitonly  --output-on-failure
-    - name: Run Debug tests
-      run: |
-        cd build
-        ctest -C Debug  -LE explicitonly  --output-on-failure
+        ctest -C ${{matrix.build_type}}  -LE explicitonly  --output-on-failure
    - name: Install
      run: |
-        cmake --install build --config Release
+        cmake --install build --config ${{matrix.build_type}}
    - name: Test Installation
      run: |
        cmake -G "${{matrix.gen}}" -A ${{matrix.arch}}  -B build_install_test tests/installation_tests/find
-        cmake --build build_install_test --config Release
+        cmake --build build_install_test --config ${{matrix.build_type}}
@@ -7,8 +7,8 @@ jobs:
    name: windows-vs17
    runs-on: windows-latest
    steps:
-    - uses: actions/checkout@v3
-    - uses: actions/cache@v3
+    - uses: actions/checkout@v4
+    - uses: actions/cache@v4
      with:
        path: dependencies/.cache
        key: ${{ hashFiles('dependencies/CMakeLists.txt') }}
@@ -104,3 +104,6 @@ objs
 !.vscode/tasks.json
 !.vscode/launch.json
 !.vscode/extensions.json
+
+# clangd
+.cache
@@ -4,10 +4,15 @@

 	// List of extensions which should be recommended for users of this workspace.
 	"recommendations": [
-		// Syntax
-		"ms-vscode.cpptools",
-		"ms-vscode.cmake-tools",
+		// C++
+		"llvm-vs-code-extensions.vscode-clangd",
+		"xaver.clang-format",
+		// Python
 		"ms-python.python",
+		// .github/*
+		"github.vscode-github-actions",
+		// cmake
+		"ms-vscode.cmake-tools",
 		"twxs.cmake"
 	],
 	// List of extensions recommended by VS Code that should not be recommended for users of this workspace.
@@ -5,6 +5,7 @@
    ],
    "files.trimTrailingWhitespace": true,
    "files.associations": {
+        ".clangd": "yaml",
        "array": "cpp",
        "iterator": "cpp",
        "chrono": "cpp",
@@ -97,6 +98,34 @@
        "queue": "cpp",
        "shared_mutex": "cpp",
        "ranges": "cpp",
-        "span": "cpp"
+        "span": "cpp",
+        "__verbose_abort": "cpp",
+        "charconv": "cpp",
+        "source_location": "cpp",
+        "strstream": "cpp",
+        "typeindex": "cpp",
+        "*.tcc": "cpp",
+        "memory_resource": "cpp",
+        "numbers": "cpp",
+        "semaphore": "cpp",
+        "stop_token": "cpp",
+        "cfenv": "cpp",
+        "format": "cpp",
+        "xlocmes": "cpp",
+        "xlocmon": "cpp",
+        "xlocnum": "cpp",
+        "xloctime": "cpp",
+        "xutility": "cpp",
+        "coroutine": "cpp",
+        "xfacet": "cpp",
+        "xhash": "cpp",
+        "xiosbase": "cpp",
+        "xlocale": "cpp",
+        "xlocbuf": "cpp",
+        "xlocinfo": "cpp",
+        "xmemory": "cpp",
+        "xstring": "cpp",
+        "xtr1common": "cpp",
+        "xtree": "cpp"
    }
 }
@@ -1,9 +1,11 @@
 cmake_minimum_required(VERSION 3.14)
+cmake_policy(VERSION 3.5) # For doctest
+

 project(
    simdjson
    # The version number is modified by tools/release.py
-    VERSION 3.2.1
+    VERSION 3.13.0
    DESCRIPTION "Parsing gigabytes of JSON per second"
    HOMEPAGE_URL "https://simdjson.org/"
    LANGUAGES CXX C
@@ -20,8 +22,14 @@ string(
 # ---- Options, variables ----

 # These version numbers are modified by tools/release.py
-set(SIMDJSON_LIB_VERSION "16.0.0" CACHE STRING "simdjson library version")
-set(SIMDJSON_LIB_SOVERSION "16" CACHE STRING "simdjson library soversion")
+set(SIMDJSON_LIB_VERSION "26.0.0" CACHE STRING "simdjson library version")
+set(SIMDJSON_LIB_SOVERSION "26" CACHE STRING "simdjson library soversion")
+
+option(SIMDJSON_BUILD_STATIC_LIB "Build simdjson_static library along with simdjson (only makes sense if BUILD_SHARED_LIBS=ON)" OFF)
+if(SIMDJSON_BUILD_STATIC_LIB AND NOT BUILD_SHARED_LIBS)
+  message(WARNING "SIMDJSON_BUILD_STATIC_LIB only makes sense if BUILD_SHARED_LIBS is set to ON")
+  message(WARNING "You might be building and installing a two identical static libraries.")
+endif()

 option(SIMDJSON_ENABLE_THREADS "Link with thread support" ON)

@@ -37,6 +45,20 @@ if(SIMDJSON_DISABLE_DEPRECATED_API)
  )
 endif()

+if(${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.25.0")
+    option(SIMDJSON_STATIC_REFLECTION "Enables static reflection (experimental), requires C++26" OFF)
+else()
+    set(SIMDJSON_STATIC_REFLECTION OFF CACHE BOOL "Enables static reflection (experimental)" FORCE)
+    message(WARNING "SIMDJSON_STATIC_REFLECTION is disabled because your CMake version is below 3.25")
+endif()
+
+if(SIMDJSON_STATIC_REFLECTION)
+  simdjson_add_props(
+      target_compile_definitions PUBLIC
+      SIMDJSON_STATIC_REFLECTION=1
+  )
+endif()
+
 option(SIMDJSON_DEVELOPMENT_CHECKS "Enable development-time aids, such as \
 checks for incorrect API usage. Enabled by default in DEBUG." OFF)
 if(SIMDJSON_DEVELOPMENT_CHECKS)
@@ -49,6 +71,7 @@ endif()
 if(is_top_project)
  option(SIMDJSON_DEVELOPER_MODE "Enable targets for developing simdjson" OFF)
  option(BUILD_SHARED_LIBS "Build simdjson as a shared library" OFF)
+  option(SIMDJSON_SINGLEHEADER "Disable singleheader generation" ON)
 endif()

 include(cmake/handle-deprecations.cmake)
@@ -56,8 +79,17 @@ include(cmake/developer-options.cmake)

 # ---- simdjson library ----

-add_library(simdjson src/simdjson.cpp)
+set(SIMDJSON_SOURCES src/simdjson.cpp)
+
+add_library(simdjson ${SIMDJSON_SOURCES})
 add_library(simdjson::simdjson ALIAS simdjson)
+set(SIMDJSON_LIBRARIES simdjson)
+
+if(SIMDJSON_BUILD_STATIC_LIB)
+  add_library(simdjson_static STATIC ${SIMDJSON_SOURCES})
+  add_library(simdjson::simdjson_static ALIAS simdjson_static)
+  list(APPEND SIMDJSON_LIBRARIES simdjson_static)
+endif()

 set_target_properties(
    simdjson PROPERTIES
@@ -68,7 +100,7 @@ set_target_properties(
 )

 # FIXME: Use proper CMake integration for exports
-if(MSVC AND BUILD_SHARED_LIBS)
+if(WIN32 AND BUILD_SHARED_LIBS)
  target_compile_definitions(
      simdjson
      PRIVATE SIMDJSON_BUILDING_WINDOWS_DYNAMIC_LIBRARY=1
@@ -82,7 +114,16 @@ simdjson_add_props(
    PRIVATE "$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/src>"
 )

-simdjson_add_props(target_compile_features PUBLIC cxx_std_11)
+if(SIMDJSON_STATIC_REFLECTION)
+  # We would like to require C++26, but no compiler supports that!
+  # This is a hack:
+  simdjson_add_props(
+      target_compile_options PUBLIC
+      -freflection -fexpansion-statements -stdlib=libc++ -std=c++26
+  )
+else()
+  simdjson_add_props(target_compile_features PUBLIC cxx_std_11)
+endif()

 # workaround for GNU GCC poor AVX load/store code generation
 if(
@@ -95,6 +136,30 @@ if(
  )
 endif()

+option(SIMDJSON_MINUS_ZERO_AS_FLOAT "Treat -0 as a floating-point value" OFF)
+
+if(SIMDJSON_MINUS_ZERO_AS_FLOAT)
+  simdjson_add_props(target_compile_definitions PRIVATE SIMDJSON_MINUS_ZERO_AS_FLOAT=1)
+endif(SIMDJSON_MINUS_ZERO_AS_FLOAT)
+
+if(CMAKE_SYSTEM_PROCESSOR MATCHES "^(loongarch64)$")
+    option(SIMDJSON_PREFER_LSX "Prefer LoongArch SX" ON)
+    include(CheckCXXCompilerFlag)
+    check_cxx_compiler_flag(-mlasx COMPILER_SUPPORTS_LASX)
+    check_cxx_compiler_flag(-mlsx COMPILER_SUPPORTS_LSX)
+    if(COMPILER_SUPPORTS_LASX AND NOT SIMDJSON_PREFER_LSX)
+        simdjson_add_props(
+            target_compile_options PRIVATE
+            -mlasx
+        )
+    elseif(COMPILER_SUPPORTS_LSX)
+        simdjson_add_props(
+            target_compile_options PRIVATE
+            -mlsx
+        )
+    endif()
+endif()
+
 # GCC and Clang have horrendous Debug builds when using SIMD.
 # A common fix is to use '-Og' instead.
 # bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=54412
@@ -117,17 +182,22 @@ if(SIMDJSON_ENABLE_THREADS)
 endif()

 simdjson_apply_props(simdjson)
+if(SIMDJSON_BUILD_STATIC_LIB)
+  simdjson_apply_props(simdjson_static)
+endif()

 # ---- Install rules ----

 include(CMakePackageConfigHelpers)
 include(GNUInstallDirs)

-install(
-    FILES singleheader/simdjson.h
-    DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
-    COMPONENT simdjson_Development
-)
+if(SIMDJSON_SINGLEHEADER)
+  install(
+      FILES singleheader/simdjson.h
+      DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
+      COMPONENT simdjson_Development
+  )
+endif()

 install(
    TARGETS simdjson
@@ -138,7 +208,6 @@ install(
    ARCHIVE COMPONENT simdjson_Development
    INCLUDES DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
 )
-
 configure_file(cmake/simdjson-config.cmake.in simdjson-config.cmake @ONLY)

 write_basic_package_version_file(
@@ -167,6 +236,21 @@ install(
    COMPONENT simdjson_Development
 )

+if(SIMDJSON_BUILD_STATIC_LIB)
+  install(
+      TARGETS simdjson_static
+      EXPORT simdjson_staticTargets
+      ARCHIVE COMPONENT simdjson_Development
+      INCLUDES DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
+  )
+  install(
+      EXPORT simdjson_staticTargets
+      NAMESPACE simdjson::
+      DESTINATION "${SIMDJSON_INSTALL_CMAKEDIR}"
+      COMPONENT simdjson_Development
+  )
+endif()
+
 # pkg-config
 include(cmake/JoinPaths.cmake)
 join_paths(PKGCONFIG_INCLUDEDIR "\${prefix}" "${CMAKE_INSTALL_INCLUDEDIR}")
@@ -234,6 +318,7 @@ enable_testing()
 add_custom_target(all_tests)

 add_subdirectory(windows)
+include(cmake/CPM.cmake)
 add_subdirectory(dependencies) ## This needs to be before tools because of cxxopts
 add_subdirectory(tools)  ## This needs to be before tests because of cxxopts

@@ -241,8 +326,9 @@ add_subdirectory(tools)  ## This needs to be before tests because of cxxopts
 # most of the data has been moved to https://github.com/simdjson/simdjson-data
 add_subdirectory(jsonexamples)

-
+if(SIMDJSON_SINGLEHEADER)
 add_subdirectory(singleheader)
+endif()



@@ -52,10 +52,11 @@ General Guidelines
 Contributors are encouraged to :

 - Document their changes. Though we do not enforce a rule regarding code comments, we prefer that non-trivial algorithms and techniques be somewhat documented in the code.
- Follow as much as possible the existing code style. We do not enforce a specific code style, but we prefer consistency.
+- Follow as much as possible the existing code style. We do not enforce a specific code style, but we prefer consistency. We avoid contractions (isn't, aren't) in the comments.
 - Modify as few lines of code as possible when working on an issue. The more lines you modify, the harder it is for your fellow human beings to understand what is going on.
 - Tools may report "problems" with the code, but we never delegate programming to tools: if there is a problem with the code, we need to understand it. Thus we will not "fix" code merely to please a static analyzer.
 - Provide tests for any new feature. We will not merge a new feature without tests.
+- Run before/after benchmarks so that we can appreciate the effect of the changes on the performance.

 Pull Requests
 --------------
@@ -91,7 +92,7 @@ We welcome contributions from women and less represented groups. If you need hel

 Consider the following points when engaging with the project:

- We discourage arguments from authority: ideas are discusssed on their own merits and not based on who stated it.
+- We discourage arguments from authority: ideas are discussed on their own merits and not based on who stated it.
 - Be mindful that what you may view as an aggression is maybe merely a difference of opinion or a misunderstanding.
 - Be mindful that a collection of small aggressions, even if mild in isolation, can become harmful.

@@ -38,7 +38,7 @@ PROJECT_NAME           = simdjson
 # could be handy for archiving the generated documentation or if some version
 # control system is used.

-PROJECT_NUMBER         = "3.2.1"
+PROJECT_NUMBER         = "3.13.0"

 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a
@@ -73,26 +73,34 @@ simdjson's source structure, from the top level, looks like this:

 * **CMakeLists.txt:** The main build system.
 * **include:** User-facing declarations and inline definitions (most user-facing functions are inlined).
-  * simdjson.h: A "main include" that includes files from include/simdjson/. This is equivalent to
+  * simdjson.h: the `simdjson` namespace. A "main include" that includes files from include/simdjson/. This is equivalent to
    the distributed simdjson.h.
-  * simdjson/*.h: Declarations for public simdjson classes and functions.
-  * simdjson/*-inl.h: Definitions for public simdjson classes and functions.
+    * simdjson/*.h: Declarations for public simdjson classes and functions.
+    * simdjson/*-inl.h: Definitions for public simdjson classes and functions.
+    * simdjson/internal/*.h: the `simdjson::internal` namespace. Private classes and functions used by the rest of simdjson.
+  * simdjson/dom.h: the `simdjson::dom` namespace. Includes all public DOM classes.
+    * simdjson/dom/*.h: Declarations/definitions for individual DOM classes.
+  * simdjson/arm64|fallback|haswell|icelake|ppc64|westmere.h: `simdjson::<implementation>` namespace. Common implementation-specific tools like number and string parsing, as well as minification.
+    * simdjson/arm64|fallback|haswell|icelake|ppc64|westmere/*.h: implementation-specific functions such as , etc.
+    * simdjson/generic/*.h: the bulk of the actual code, written generically and compiled for each implementation, using functions defined in the implementation's .h files.
+      * simdjson/generic/dependencies.h: dependencies on common, non-implementation-specific simdjson classes. This will be included before including amalgamated.h.
+      * simdjson/generic/amalgamated.h: all generic ondemand classes for an implementation.
+  * simdjson/ondemand.h: the `simdjson::ondemand` namespace. Includes all public ondemand classes.
+    * simdjson/builtin.h: the `simdjson::builtin` namespace. Aliased to the most universal implementation available.
+    * simdjson/builtin/ondemand.h: the `simdjson::builtin::ondemand` namespace.
+    * simdjson/arm64|fallback|haswell|icelake|ppc64|westmere/ondemand.h: the `simdjson::<implementation>::ondemand` namespace. On-Demand compiled for the specific implementation.
+    * simdjson/generic/ondemand/*.h: individual On-Demand classes, generically written.
+      * simdjson/generic/ondemand/dependencies.h: dependencies on common, non-implementation-specific simdjson classes. This will be included before including amalgamated.h.
+      * simdjson/generic/ondemand/amalgamated.h: all generic ondemand classes for an implementation.
 * **src:** The source files for non-inlined functionality (e.g. the architecture-specific parser
  implementations).
  * simdjson.cpp: A "main source" that includes all implementation files from src/. This is
    equivalent to the distributed simdjson.cpp.
-  * arm64/|fallback/|haswell/|ppc64/|westmere/: Architecture-specific implementations. All functions are
-    Each architecture defines its own namespace, e.g. simdjson::haswell.
-  * generic/: Generic implementations of the simdjson parser. These files may be included and
-    compiled multiple times, from whichever architectures use them. They assume they are already
-    enclosed in a namespace, e.g.:
-    ```c++
-    namespace simdjson {
-      namespace haswell {
-        #include "generic/stage1/json_structural_indexer.h"
-      }
-    }
-    ```
+  * *.cpp: other misc. implementations, such as `simdjson::implementation` and the minifier.
+  * arm64|fallback|haswell|icelake|ppc64|westmere.cpp: Architecture-specific parser implementations.
+    * generic/*.h: `simdjson::<implementation>` namespace. Generic implementation of the parser, particularly the `dom_parser_implementation`.
+    * generic/stage1/*.h: `simdjson::<implementation>::stage1` namespace. Generic implementation of the simd-heavy tokenizer/indexer pass of the simdjson parser. Used for the On-Demand interface
+    * generic/stage2/*.h: `simdjson::<implementation>::stage2` namespace. Generic implementation of the tape creator, which consumes the index from stage 1 and actually parses numbers and string and such. Used for the DOM interface.

 Other important files and directories:
 * **.drone.yml:** Definitions for Drone CI.
@@ -275,8 +283,6 @@ If your compiler does not default on C++11 support or better you may get failing

 Note that the name of directory (`build`) is arbitrary, you can name it as you want (e.g., `buildgcc`) and you can have as many different such directories as you would like (one per configuration).

-
-
 ## Usage (CMake on 64-bit Windows using Visual Studio 2019 or better)

 Recent versions of Visual Studio support CMake natively, [please refer to the Visual Studio documentation](https://learn.microsoft.com/en-us/cpp/build/cmake-projects-in-visual-studio?view=msvc-170).
@@ -296,17 +302,15 @@ Though having Visual Studio installed is necessary, one can build simdjson using
 - `mkdir build`
 - `cd build`
 - `cmake ..`
- `cmake --build . -config Release`
+- `cmake --build . --config Release`


 Furthermore, if you have installed LLVM clang on Windows, for example as a component of Visual Studio 2019, you can configure and build simdjson using LLVM clang on Windows using cmake:

-
 - `mkdir build`
 - `cd build`
 - `cmake -T ClangCL ..`
- `cmake --build . -config Release`
-
+- `cmake --build . --config Release`

 ## Various References

@@ -186,7 +186,7 @@
      same "printed page" as the copyright notice for easier
      identification within third-party archives.

-   Copyright 2018-2023 The simdjson authors
+   Copyright 2018-2025 The simdjson authors

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

-[![Ubuntu 20.04 CI](https://github.com/simdjson/simdjson/workflows/Ubuntu%2020.04%20CI%20(GCC%209)/badge.svg)](https://simdjson.org/plots.html)
-![VS16-CI](https://github.com/simdjson/simdjson/workflows/VS16-CI/badge.svg)
 [![Fuzzing Status](https://oss-fuzz-build-logs.storage.googleapis.com/badges/simdjson.svg)](https://bugs.chromium.org/p/oss-fuzz/issues/list?sort=-opened&can=1&q=proj:simdjson)
-![MinGW64-CI](https://github.com/simdjson/simdjson/workflows/MinGW64-CI/badge.svg)
-[![][license img]][license]
+[![][license img]][license] [![][licensemit img]][licensemit]
+

 [![Doxygen Documentation](https://img.shields.io/badge/docs-doxygen-green.svg)](https://simdjson.github.io/simdjson/)

@@ -31,7 +29,9 @@ Table of Contents
 * [Real-world usage](#real-world-usage)
 * [Quick Start](#quick-start)
 * [Documentation](#documentation)
+* [Godbolt](#godbolt)
 * [Performance results](#performance-results)
+* [Packages](#packages)
 * [Bindings and Ports of simdjson](#bindings-and-ports-of-simdjson)
 * [About simdjson](#about-simdjson)
 * [Funding](#funding)
@@ -42,9 +42,12 @@ Table of Contents
 Real-world usage
 ----------------

+- [Node.js](https://nodejs.org/)
 - [ClickHouse](https://github.com/ClickHouse/ClickHouse)
- [Facebook/Meta Velox](https://velox-lib.io)
+- [Meta Velox](https://velox-lib.io)
+- [Google Pax](https://github.com/google/paxml)
 - [milvus](https://github.com/milvus-io/milvus)
+- [QuestDB](https://questdb.io/blog/questdb-release-8-0-3/)
 - [Clang Build Analyzer](https://github.com/aras-p/ClangBuildAnalyzer)
 - [Shopify HeapProfiler](https://github.com/Shopify/heap-profiler)
 - [StarRocks](https://github.com/StarRocks/starrocks)
@@ -58,6 +61,10 @@ Real-world usage
 - [vast](https://github.com/tenzir/vast)
 - [ada-url](https://github.com/ada-url/ada)
 - [fastgron](https://github.com/adamritter/fastgron)
+- [WasmEdge](https://wasmedge.org)
+- [RonDB](https://github.com/logicalclocks/rondb)
+- [GreptimeDB](https://github.com/GreptimeTeam/greptimedb)
+

 If you are planning to use simdjson in a product, please work from one of our releases.

@@ -68,9 +75,9 @@ The simdjson library is easily consumable with a single .h and .cpp file.

 0. Prerequisites: `g++` (version 7 or better) or `clang++` (version 6 or better), and a 64-bit
   system with a command-line shell (e.g., Linux, macOS, freeBSD). We also support programming
-   environments like Visual Studio and Xcode, but different steps are needed.
+   environments like Visual Studio and Xcode, but different steps are needed. Users of clang++ may need to specify the C++ version (e.g., `c++ -std=c++17`) since clang++ tends to default on C++98.
 1. Pull [simdjson.h](singleheader/simdjson.h) and [simdjson.cpp](singleheader/simdjson.cpp) into a
-   directory, along with the sample file [twitter.json](jsonexamples/twitter.json).
+   directory, along with the sample file [twitter.json](jsonexamples/twitter.json). You can download them with the `wget` utility:

   ```
   wget https://raw.githubusercontent.com/simdjson/simdjson/master/singleheader/simdjson.h https://raw.githubusercontent.com/simdjson/simdjson/master/singleheader/simdjson.cpp https://raw.githubusercontent.com/simdjson/simdjson/master/jsonexamples/twitter.json
@@ -95,22 +102,25 @@ int main(void) {
   100 results.
  ```

+
 Documentation
 -------------

 Usage documentation is available:

 * [Basics](doc/basics.md) is an overview of how to use simdjson and its APIs.
+* [Builder](doc/builder.md) is an overview of how to efficiently write JSON strings using simdjson.
 * [Performance](doc/performance.md) shows some more advanced scenarios and how to tune for them.
 * [Implementation Selection](doc/implementation-selection.md) describes runtime CPU detection and
  how you can work with it.
 * [API](https://simdjson.github.io/simdjson/) contains the automatically generated API documentation.

+Godbolt
+-------------

 Some users may want to browse code along with the compiled assembly. You want to check out the following lists of examples:
-
-* [simdjson examples with errors handled through exceptions](https://godbolt.org/z/98Kx9Kqjn)
-* [simdjson examples with errors without exceptions](https://godbolt.org/z/PKG7GdbPo)
+* [simdjson examples with errors handled through exceptions](https://godbolt.org/z/7G5qE4sr9)
+* [simdjson examples with errors without exceptions](https://godbolt.org/z/e9dWb9E4v)

 Performance results
 -------------------
@@ -138,6 +148,9 @@ speed for [synthetic files over various sizes generated with a script](https://g
 For NDJSON files, we can exceed 3 GB/s with [our  multithreaded parsing functions](https://github.com/simdjson/simdjson/blob/master/doc/parse_many.md).


+Packages
+------------------------------
+[![Packaging status](https://repology.org/badge/vertical-allrepos/simdjson.svg)](https://repology.org/project/simdjson/versions)


 Bindings and Ports of simdjson
@@ -162,9 +175,12 @@ We distinguish between "bindings" (which just wrap the C++ code) and a port to a
 - [simdjsone](https://github.com/saleyn/simdjsone): erlang bindings.
 - [lua-simdjson](https://github.com/FourierTransformer/lua-simdjson): lua bindings.
 - [hermes-json](https://hackage.haskell.org/package/hermes-json): haskell bindings.
- [simdjzon](https://github.com/travisstaloch/simdjzon): zig port.
+- [zimdjson](https://github.com/EzequielRamis/zimdjson): Zig port.
+- [simdjzon](https://github.com/travisstaloch/simdjzon): Zig port.
 - [JSON-Simd](https://github.com/rawleyfowler/JSON-simd): Raku bindings.
 - [JSON::SIMD](https://metacpan.org/pod/JSON::SIMD): Perl bindings; fully-featured JSON module that uses simdjson for decoding.
+- [gemmaJSON](https://github.com/sainttttt/gemmaJSON): Nim JSON parser based on simdjson bindings.
+- [simdjson-java](https://github.com/simdjson/simdjson-java): Java port.

 About simdjson
 --------------
@@ -173,7 +189,11 @@ The simdjson library takes advantage of modern microarchitectures, parallelizing
 instructions, reducing branch misprediction, and reducing data dependency to take advantage of each
 CPU's multiple execution cores.

-Some people [enjoy reading our paper](https://arxiv.org/abs/1902.08318): A description of the design
+Our default front-end is called On-Demand, and we wrote a paper about it:
+
+- John Keiser, Daniel Lemire, [On-Demand JSON: A Better Way to Parse Documents?](http://arxiv.org/abs/2312.17149), Software: Practice and Experience 54 (6), 2024.
+
+Some people [enjoy reading the first (2019) simdjson paper](https://arxiv.org/abs/1902.08318): A description of the design
 and implementation of simdjson is in our research article:
 - Geoff Langdale, Daniel Lemire, [Parsing Gigabytes of JSON per Second](https://arxiv.org/abs/1902.08318), VLDB Journal 28 (6), 2019.

@@ -190,12 +210,17 @@ For the video inclined, <br />
 Funding
 -------

-The work is supported by the Natural Sciences and Engineering Research Council of Canada under grant
-number RGPIN-2017-03910.
+The work is supported by the Natural Sciences and Engineering Research Council of Canada under grants
+RGPIN-2017-03910 and RGPIN-2024-03787.

 [license]: LICENSE
 [license img]: https://img.shields.io/badge/License-Apache%202-blue.svg

+
+[licensemit]: LICENSE-MIT
+[licensemit img]: https://img.shields.io/badge/License-MIT-blue.svg
+
+
 Contributing to simdjson
 ------------------------

@@ -205,7 +230,7 @@ Head over to [CONTRIBUTING.md](CONTRIBUTING.md) for information on contributing
 License
 -------

-This code is made available under the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0.html).
+This code is made available under the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0.html) as well as under the MIT License. As a user, you can pick the license you prefer.

 Under Windows, we build some tools using the windows/dirent_portable.h file (which is outside our library code): it is under the liberal (business-friendly) MIT license.

@@ -0,0 +1,7 @@
+# Security Policy
+
+## Reporting a Vulnerability
+
+Please use the following contact information for reporting a vulnerability:
+
+- [Daniel Lemire](https://github.com/lemire) - daniel@lemire.me
@@ -4,6 +4,9 @@ add_subdirectory(dom)
 include_directories( . linux )
 link_libraries(simdjson-windows-headers test-data)
 link_libraries(simdjson)
+if(SIMDJSON_STATIC_REFLECTION)
+  add_compile_definitions(SIMDJSON_STATIC_REFLECTION=1)
+endif(SIMDJSON_STATIC_REFLECTION)

 add_executable(benchfeatures benchfeatures.cpp)
 add_executable(get_corpus_benchmark get_corpus_benchmark.cpp)
@@ -26,6 +29,12 @@ if (TARGET benchmark::benchmark)
    if(TARGET nlohmann_json)
      target_link_libraries(bench_ondemand PRIVATE nlohmann_json)
    endif()
+    if(TARGET boostjson)
+      target_link_libraries(bench_ondemand PRIVATE boostjson)
+    endif()
  endif()
 endif()

+if(SIMDJSON_STATIC_REFLECTION)
+  add_subdirectory(static_reflect)
+endif(SIMDJSON_STATIC_REFLECTION)
@@ -473,28 +473,6 @@ static void twitter_count(State& state) {
 }
 BENCHMARK(twitter_count);

-#ifndef SIMDJSON_DISABLE_DEPRECATED_API
-SIMDJSON_PUSH_DISABLE_WARNINGS
-SIMDJSON_DISABLE_DEPRECATED_WARNING
-static void iterator_twitter_count(State& state) {
-  // Prints the number of results in twitter.json
-  padded_string json = padded_string::load(TWITTER_JSON);
-  ParsedJson pj = build_parsed_json(json);
-  for (simdjson_unused auto _ : state) {
-    ParsedJson::Iterator iter(pj);
-    // uint64_t result_count = doc["search_metadata"]["count"];
-    if (!iter.move_to_key("search_metadata")) { return; }
-    if (!iter.move_to_key("count")) { return; }
-    if (!iter.is_integer()) { return; }
-    int64_t result_count = iter.get_integer();
-
-    if (result_count != 100) { return; }
-  }
-}
-BENCHMARK(iterator_twitter_count);
-SIMDJSON_POP_DISABLE_WARNINGS
-#endif // SIMDJSON_DISABLE_DEPRECATED_API
-
 static void twitter_default_profile(State& state) {
  // Count unique users with a default profile.
  dom::parser parser;
@@ -578,54 +556,6 @@ static void error_code_twitter_default_profile(State& state) noexcept {
 }
 BENCHMARK(error_code_twitter_default_profile);

-#ifndef SIMDJSON_DISABLE_DEPRECATED_API
-
-SIMDJSON_PUSH_DISABLE_WARNINGS
-SIMDJSON_DISABLE_DEPRECATED_WARNING
-
-static void iterator_twitter_default_profile(State& state) {
-  // Count unique users with a default profile.
-  padded_string json;
-  auto error = padded_string::load(TWITTER_JSON).get(json);
-  if (error) { std::cerr << error << std::endl; return; }
-  ParsedJson pj = build_parsed_json(json);
-  for (simdjson_unused auto _ : state) {
-    set<string_view> default_users;
-    ParsedJson::Iterator iter(pj);
-
-    // for (dom::object tweet : doc["statuses"]) {
-    if (!(iter.move_to_key("statuses") && iter.is_array())) { return; }
-    if (iter.down()) { // first status
-      do {
-
-        // dom::object user = tweet["user"];
-        if (!(iter.move_to_key("user") && iter.is_object())) { return; }
-
-        // if (user["default_profile"]) {
-        if (iter.move_to_key("default_profile")) {
-          if (iter.is_true()) {
-            if (!iter.up()) { return; } // back to user
-
-            // default_users.insert(user["screen_name"]);
-            if (!(iter.move_to_key("screen_name") && iter.is_string())) { return; }
-            default_users.emplace(iter.get_string(), iter.get_string_length());
-          }
-          if (!iter.up()) { return; } // back to user
-        }
-
-        if (!iter.up()) { return; } // back to status
-
-      } while (iter.next()); // next status
-    }
-
-    if (default_users.size() != 86) { return; }
-  }
-}
-
-SIMDJSON_POP_DISABLE_WARNINGS
-BENCHMARK(iterator_twitter_default_profile);
-#endif // SIMDJSON_DISABLE_DEPRECATED_API
-
 static void error_code_twitter_image_sizes(State& state) noexcept {
  // Count unique image sizes
  dom::parser parser;
@@ -680,92 +610,4 @@ static void parse_surrogate_pairs(State& state) {
 }
 BENCHMARK(parse_surrogate_pairs);

-
-#ifndef SIMDJSON_DISABLE_DEPRECATED_API
-
-SIMDJSON_PUSH_DISABLE_WARNINGS
-SIMDJSON_DISABLE_DEPRECATED_WARNING
-static void iterator_twitter_image_sizes(State& state) {
-  // Count unique image sizes
-  padded_string json;
-  auto error = padded_string::load(TWITTER_JSON).get(json);
-  if (error) { std::cerr << error << std::endl; return; }
-  ParsedJson pj = build_parsed_json(json);
-  for (simdjson_unused auto _ : state) {
-    set<tuple<uint64_t, uint64_t>> image_sizes;
-    ParsedJson::Iterator iter(pj);
-
-    // for (dom::object tweet : doc["statuses"]) {
-    if (!(iter.move_to_key("statuses") && iter.is_array())) { return; }
-    if (iter.down()) { // first status
-      do {
-
-        // dom::object media;
-        // not_found = tweet["entities"]["media"].get(media);
-        // if (!not_found) {
-        if (iter.move_to_key("entities")) {
-          if (!iter.is_object()) { return; }
-          if (iter.move_to_key("media")) {
-            if (!iter.is_array()) { return; }
-
-            //   for (dom::object image : media) {
-            if (iter.down()) { // first media
-              do {
-
-                // for (auto [key, size] : dom::object(image["sizes"])) {
-                if (!(iter.move_to_key("sizes") && iter.is_object())) { return; }
-                if (iter.down()) { // first size
-                  do {
-                    iter.move_to_value();
-
-                    // image_sizes.insert({ size["w"], size["h"] });
-                    if (!(iter.move_to_key("w")) && !iter.is_integer()) { return; }
-                    uint64_t width = iter.get_integer();
-                    if (!iter.up()) { return; } // back to size
-                    if (!(iter.move_to_key("h")) && !iter.is_integer()) { return; }
-                    uint64_t height = iter.get_integer();
-                    if (!iter.up()) { return; } // back to size
-                    image_sizes.emplace(width, height);
-
-                  } while (iter.next()); // next size
-                  if (!iter.up()) { return; } // back to sizes
-                }
-                if (!iter.up()) { return; } // back to image
-              } while (iter.next()); // next image
-              if (!iter.up()) { return; } // back to media
-            }
-            if (!iter.up()) { return; } // back to entities
-          }
-          if (!iter.up()) { return; } // back to status
-        }
-      } while (iter.next()); // next status
-    }
-
-    if (image_sizes.size() != 15) { return; };
-  }
-}
-BENCHMARK(iterator_twitter_image_sizes);
-
-#endif // SIMDJSON_DISABLE_DEPRECATED_API
-
-#ifndef SIMDJSON_DISABLE_DEPRECATED_API
-static void print_json(State& state) noexcept {
-  // Prints the number of results in twitter.json
-  dom::parser parser;
-
-  padded_string json;
-  auto error = padded_string::load(TWITTER_JSON).get(json);
-  if (error) { std::cerr << error << std::endl; return; }
-
-  int code = json_parse(json, parser);
-  if (code) { cerr << error_message(code) << endl; return; }
-  for (simdjson_unused auto _ : state) {
-    std::stringstream s;
-    if (!parser.print_json(s)) { cerr << "print_json failed" << endl; return; }
-  }
-}
-BENCHMARK(print_json);
-#endif // SIMDJSON_DISABLE_DEPRECATED_API
-SIMDJSON_POP_DISABLE_WARNINGS
-
 BENCHMARK_MAIN();
@@ -21,6 +21,10 @@ SIMDJSON_PUSH_DISABLE_ALL_WARNINGS
 #include <nlohmann/json.hpp>
 #endif

+#ifdef SIMDJSON_COMPETITION_BOOSTJSON
+#include <boost/json.hpp>
+#endif
+
 // This has to be last, for reasons I don't yet understand
 #include <benchmark/benchmark.h>

@@ -33,6 +37,7 @@ SIMDJSON_POP_DISABLE_WARNINGS
 #include "json2msgpack/sajson.h"
 #endif // SIMDJSON_COMPETITION_ONDEMAND_SAJSON
 #include "json2msgpack/nlohmann_json.h"
+#include "json2msgpack/boostjson.h"

 #include "partial_tweets/simdjson_ondemand.h"
 #include "partial_tweets/simdjson_dom.h"
@@ -48,6 +53,7 @@ SIMDJSON_POP_DISABLE_WARNINGS
 #if SIMDJSON_COMPETITION_SAX
 #include "partial_tweets/nlohmann_json_sax.h"
 #endif // SIMDJSON_COMPETITION_SAX
+#include "partial_tweets/boostjson.h"


 #include "distinct_user_id/simdjson_ondemand.h"
@@ -66,6 +72,7 @@ SIMDJSON_POP_DISABLE_WARNINGS
 #if SIMDJSON_COMPETITION_SAX
 #include "distinct_user_id/nlohmann_json_sax.h"
 #endif // SIMDJSON_COMPETITION_SAX
+#include "distinct_user_id/boostjson.h"

 #include "find_tweet/simdjson_ondemand.h"
 #include "find_tweet/simdjson_dom.h"
@@ -81,6 +88,7 @@ SIMDJSON_POP_DISABLE_WARNINGS
 #if SIMDJSON_COMPETITION_SAX
 #include "find_tweet/nlohmann_json_sax.h"
 #endif // SIMDJSON_COMPETITION_SAX
+#include "find_tweet/boostjson.h"

 #include "top_tweet/simdjson_ondemand.h"
 #include "top_tweet/simdjson_dom.h"
@@ -96,6 +104,7 @@ SIMDJSON_POP_DISABLE_WARNINGS
 #if SIMDJSON_COMPETITION_SAX
 #include "top_tweet/nlohmann_json_sax.h"
 #endif // SIMDJSON_COMPETITION_SAX
+#include "top_tweet/boostjson.h"


 #include "kostya/simdjson_ondemand.h"
@@ -112,6 +121,7 @@ SIMDJSON_POP_DISABLE_WARNINGS
 #if SIMDJSON_COMPETITION_SAX
 #include "kostya/nlohmann_json_sax.h"
 #endif // SIMDJSON_COMPETITION_SAX
+#include "kostya/boostjson.h"

 #include "large_random/simdjson_ondemand.h"
 #if SIMDJSON_COMPETITION_ONDEMAND_UNORDERED
@@ -130,6 +140,7 @@ SIMDJSON_POP_DISABLE_WARNINGS
 #if SIMDJSON_COMPETITION_SAX
 #include "large_random/nlohmann_json_sax.h"
 #endif // SIMDJSON_COMPETITION_SAX
+#include "large_random/boostjson.h"

 #include "amazon_cellphones/simdjson_dom.h"
 #include "amazon_cellphones/simdjson_ondemand.h"
@@ -169,22 +169,6 @@ BENCHMARK(parse_gsoc)->Repetitions(10)->ComputeStatistics("max", [](const std::v
  })->DisplayAggregatesOnly(true);


-
-#ifndef SIMDJSON_DISABLE_DEPRECATED_API
-SIMDJSON_PUSH_DISABLE_WARNINGS
-SIMDJSON_DISABLE_DEPRECATED_WARNING
-static void json_parse(State& state) {
-  ParsedJson pj;
-  if (!pj.allocate_capacity(EMPTY_ARRAY.length())) { return; }
-  for (simdjson_unused auto _ : state) {
-    auto error = json_parse(EMPTY_ARRAY, pj);
-    if (error) { return; }
-  }
-}
-SIMDJSON_POP_DISABLE_WARNINGS
-BENCHMARK(json_parse);
-#endif // SIMDJSON_DISABLE_DEPRECATED_API
-
 static void parser_parse_error_code(State& state) {
  dom::parser parser;
  if (parser.allocate(EMPTY_ARRAY.length())) { return; }
@@ -213,20 +197,6 @@ BENCHMARK(parser_parse_exception);

 #endif // SIMDJSON_EXCEPTIONS

-#ifndef SIMDJSON_DISABLE_DEPRECATED_API
-SIMDJSON_PUSH_DISABLE_WARNINGS
-SIMDJSON_DISABLE_DEPRECATED_WARNING
-static void build_parsed_json(State& state) {
-  for (simdjson_unused auto _ : state) {
-    dom::parser parser = simdjson::build_parsed_json(EMPTY_ARRAY);
-    if (!parser.valid) { return; }
-  }
-}
-SIMDJSON_POP_DISABLE_WARNINGS
-
-BENCHMARK(build_parsed_json);
-#endif
-
 static void document_parse_error_code(State& state) {
  for (simdjson_unused auto _ : state) {
    dom::parser parser;
@@ -0,0 +1,618 @@
+#!/bin/bash
+
+# JSON Parsing Compilation Benchmark: Reflection Usage vs Manual Parsing
+# Compares compilation times when ACTUALLY USING reflection for parsing vs manual parsing
+# This measures the compile-time cost of reflection-based automatic deserialization
+
+set -e
+
+echo "=== simdjson Reflection Usage Compilation Benchmark ==="
+echo "Measuring compilation impact of ACTUALLY USING reflection for parsing"
+echo "Starting at: $(date)"
+echo
+echo "╔════════════════════════════════════════════════════════════════════════════╗"
+echo "║                              METHODOLOGY                                   ║"
+echo "╠════════════════════════════════════════════════════════════════════════════╣"
+echo "║                                                                            ║"
+echo "║ FAIR COMPARISON STRATEGY:                                                  ║"
+echo "║ This benchmark compares two DIFFERENT approaches to parsing the same JSON: ║"
+echo "║                                                                            ║"
+echo "║ • MANUAL PARSING: Traditional simdjson with explicit .get() calls          ║"
+echo "║   - Uses doc[\"field\"].get(variable) for each field                         ║"
+echo "║   - No reflection involved                                                 ║"
+echo "║                                                                            ║"
+echo "║ • REFLECTION PARSING: Automatic deserialization with reflection            ║"
+echo "║   - Uses doc.get<MyStruct>() for automatic field mapping                   ║"
+echo "║   - Relies on compile-time reflection to generate parsing code             ║"
+echo "║                                                                            ║"
+echo "║ WHAT WE'RE MEASURING:                                                      ║"
+echo "║ • Compile-time cost of reflection-based automatic deserialization          ║"
+echo "║ • Template instantiation overhead for reflection parsing                   ║"
+echo "║ • Code generation complexity from using reflection features                ║"
+echo "║                                                                            ║"
+echo "║ TEST SCENARIOS:                                                            ║"
+echo "║                                                                            ║"
+echo "║ 1. SIMPLE STRUCT: Basic fields (string, int, bool)                         ║"
+echo "║    - Measures baseline reflection overhead                                 ║"
+echo "║                                                                            ║"
+echo "║ 2. NESTED STRUCT: Multiple levels of nested objects                        ║"
+echo "║    - Measures reflection complexity scaling                                ║"
+echo "║                                                                            ║"
+echo "║ 3. COMPLEX STRUCT: Arrays, optional fields, mixed types                    ║"
+echo "║    - Measures real-world reflection usage impact                           ║"
+echo "║                                                                            ║"
+echo "║ WHY THIS IS MEANINGFUL:                                                    ║"
+echo "║ • Shows actual cost of using reflection features                           ║"
+echo "║ • Measures compile-time code generation overhead                           ║"
+echo "║ • Helps developers understand reflection's compilation impact              ║"
+echo "║ • Compares equivalent functionality implemented two different ways         ║"
+echo "║                                                                            ║"
+echo "╚════════════════════════════════════════════════════════════════════════════╝"
+echo
+
+# Configuration
+ITERATIONS=10
+JOBS=4
+
+# ───────────────────────────── BOX-PRINT HELPER ────────────────────────────
+BOX_WIDTH=74                               # characters between the pipes
+print_box_line() {                         # usage: print_box_line "text"
+  printf "║ %-*s ║\n" "${BOX_WIDTH}" "$1"
+}
+
+# Function to test if a compiler supports reflection with debug output
+test_reflection_support() {
+    local compiler="$1"
+    echo "  → Testing compiler: $compiler"
+
+    if [ ! -x "$compiler" ] && ! command -v "$compiler" >/dev/null 2>&1; then
+        echo "  → Compiler not found or not executable"
+        return 1
+    fi
+
+    # Check compiler version first
+    echo "  → Compiler version: $("$compiler" --version 2>/dev/null | head -n1 || echo "version check failed")"
+
+    # Simple test: check if compiler accepts reflection flags
+    local test_file=$(mktemp /tmp/reflection_test_XXXXXX.cpp)
+    cat > "$test_file" << 'EOF'
+int main() {
+    return 0;
+}
+EOF
+
+    echo "  → Testing basic reflection flags..."
+    local test_exe=$(mktemp /tmp/reflection_test_XXXXXX)
+    local basic_result=$("$compiler" -freflection -fexpansion-statements -std=c++26 "$test_file" -o "$test_exe" 2>&1)
+    local basic_exit_code=$?
+
+    if [ $basic_exit_code -ne 0 ]; then
+        echo "  → Basic flags FAILED with exit code $basic_exit_code"
+        echo "  → Error output: $basic_result"
+        rm -f "$test_file" "$test_exe"
+        return 1
+    fi
+    echo "  → Basic flags: OK"
+    rm -f "$test_exe"
+
+    # Test reflection syntax
+    echo "  → Testing reflection syntax..."
+    cat > "$test_file" << 'EOF'
+struct Test {
+    int x;
+};
+
+int main() {
+    auto refl = ^^Test;
+    return 0;
+}
+EOF
+
+    local syntax_result=$("$compiler" -freflection -fexpansion-statements -std=c++26 "$test_file" -o "$test_exe" 2>&1)
+    local syntax_exit_code=$?
+
+    if [ $syntax_exit_code -eq 0 ]; then
+        echo "  → Reflection syntax: OK"
+        echo "  → ✓ REFLECTION SUPPORT CONFIRMED"
+        rm -f "$test_file" "$test_exe"
+        return 0
+    else
+        echo "  → Reflection syntax FAILED with exit code $syntax_exit_code"
+        echo "  → Error output: $syntax_result"
+        rm -f "$test_file" "$test_exe"
+        return 1
+    fi
+}
+
+# Find a compiler with reflection support
+echo "Searching for clang++ with reflection support..."
+
+REFLECTION_CXX=""
+REFLECTION_CC=""
+
+# List of potential clang++ locations to check
+POTENTIAL_COMPILERS=(
+    "/usr/local/bin/clang++"
+    "/opt/clang/bin/clang++"
+    "/usr/bin/clang++"
+    "clang++"
+)
+
+# If CXX is already set, test it first
+if [ -n "$CXX" ]; then
+    echo "Testing user-specified compiler: $CXX"
+    if test_reflection_support "$CXX"; then
+        REFLECTION_CXX="$CXX"
+        echo "✓ User-specified compiler supports reflection: $CXX"
+    else
+        echo "✗ User-specified compiler does not support reflection: $CXX"
+        echo "Will search for alternative..."
+    fi
+fi
+
+# If we don't have a working compiler yet, search for one
+if [ -z "$REFLECTION_CXX" ]; then
+    for compiler in "${POTENTIAL_COMPILERS[@]}"; do
+        echo "Testing: $compiler"
+        if test_reflection_support "$compiler"; then
+            REFLECTION_CXX="$compiler"
+            echo "✓ Found reflection-enabled compiler: $compiler"
+            break
+        else
+            echo "✗ No reflection support: $compiler"
+        fi
+    done
+fi
+
+# Check if we found a working compiler
+if [ -z "$REFLECTION_CXX" ]; then
+    echo
+    echo "╔════════════════════════════════════════════════════════════════════════════╗"
+    echo "║                                 ERROR                                      ║"
+    echo "╠════════════════════════════════════════════════════════════════════════════╣"
+    echo "║                                                                            ║"
+    echo "║ No clang++ compiler with reflection support found!                        ║"
+    echo "║                                                                            ║"
+    echo "║ This benchmark requires a compiler that supports C++26 reflection.        ║"
+    echo "║                                                                            ║"
+    echo "║ Options:                                                                   ║"
+    echo "║ 1. Use the Docker container: ./p2996/run_docker.sh                        ║"
+    echo "║ 2. Build clang with reflection from: https://github.com/bloomberg/clang-p2996 ║"
+    echo "║ 3. Set CXX environment variable to point to reflection-enabled clang++    ║"
+    echo "║                                                                            ║"
+    echo "║ Example: CXX=/path/to/reflection-clang++ ./benchmark_script.sh            ║"
+    echo "║                                                                            ║"
+    echo "╚════════════════════════════════════════════════════════════════════════════╝"
+    exit 1
+fi
+
+# Set the compilers
+export CXX="$REFLECTION_CXX"
+
+# Find corresponding C compiler
+if [ -n "$CC" ]; then
+    REFLECTION_CC="$CC"
+elif [ "$REFLECTION_CXX" = "/usr/local/bin/clang++" ]; then
+    REFLECTION_CC="/usr/local/bin/clang"
+elif [ "$REFLECTION_CXX" = "/opt/clang/bin/clang++" ]; then
+    REFLECTION_CC="/opt/clang/bin/clang"
+elif [ "$REFLECTION_CXX" = "/usr/bin/clang++" ]; then
+    REFLECTION_CC="/usr/bin/clang"
+else
+    REFLECTION_CC="clang"
+fi
+
+export CC="$REFLECTION_CC"
+
+echo
+echo "Using reflection-enabled compiler: $($CXX --version | head -n1)"
+echo "Using C compiler: $($CC --version | head -n1)"
+echo
+
+# Function to create manual parsing test
+create_manual_parsing_test() {
+    local test_name="$1"
+    local struct_complexity="$2"
+
+    cat > "${test_name}_manual.cpp" << 'EOF'
+#include <simdjson.h>
+#include <iostream>
+#include <string>
+#include <vector>
+#include <optional>
+
+// Test structures
+struct Person {
+    std::string name;
+    int age;
+    bool active;
+};
+
+struct Address {
+    std::string street;
+    std::string city;
+    int zipcode;
+};
+
+struct Employee {
+    Person person;
+    Address address;
+    std::vector<std::string> skills;
+    std::optional<std::string> department;
+    double salary;
+};
+
+// Manual parsing functions
+bool parse_person_manual(simdjson::ondemand::value& val, Person& person) {
+    auto obj = val.get_object();
+    if (obj.error()) return false;
+
+    for (auto field : obj) {
+        std::string_view key = field.unescaped_key();
+        if (key == "name") {
+            std::string_view name_val;
+            if (field.value().get(name_val)) return false;
+            person.name = name_val;
+        } else if (key == "age") {
+            if (field.value().get(person.age)) return false;
+        } else if (key == "active") {
+            if (field.value().get(person.active)) return false;
+        }
+    }
+    return true;
+}
+
+bool parse_address_manual(simdjson::ondemand::value& val, Address& address) {
+    auto obj = val.get_object();
+    if (obj.error()) return false;
+
+    for (auto field : obj) {
+        std::string_view key = field.unescaped_key();
+        if (key == "street") {
+            std::string_view street_val;
+            if (field.value().get(street_val)) return false;
+            address.street = street_val;
+        } else if (key == "city") {
+            std::string_view city_val;
+            if (field.value().get(city_val)) return false;
+            address.city = city_val;
+        } else if (key == "zipcode") {
+            if (field.value().get(address.zipcode)) return false;
+        }
+    }
+    return true;
+}
+
+bool parse_employee_manual(simdjson::ondemand::document& doc, Employee& employee) {
+    auto obj = doc.get_object();
+    if (obj.error()) return false;
+
+    for (auto field : obj) {
+        std::string_view key = field.unescaped_key();
+        if (key == "person") {
+            auto person_val = field.value();
+            if (!parse_person_manual(person_val, employee.person)) return false;
+        } else if (key == "address") {
+            auto addr_val = field.value();
+            if (!parse_address_manual(addr_val, employee.address)) return false;
+        } else if (key == "skills") {
+            auto skills_array = field.value().get_array();
+            if (skills_array.error()) return false;
+            for (auto skill : skills_array) {
+                std::string_view skill_val;
+                if (skill.get(skill_val)) return false;
+                employee.skills.emplace_back(skill_val);
+            }
+        } else if (key == "department") {
+            std::string_view dept_val;
+            if (!field.value().get(dept_val)) {
+                employee.department = dept_val;
+            }
+        } else if (key == "salary") {
+            if (field.value().get(employee.salary)) return false;
+        }
+    }
+    return true;
+}
+
+int main() {
+    simdjson::ondemand::parser parser;
+    std::string json_str = R"({
+        "person": {
+            "name": "John Doe",
+            "age": 30,
+            "active": true
+        },
+        "address": {
+            "street": "123 Main St",
+            "city": "Anytown",
+            "zipcode": 12345
+        },
+        "skills": ["C++", "JSON", "Programming"],
+        "department": "Engineering",
+        "salary": 85000.50
+    })";
+
+    simdjson::ondemand::document doc;
+    auto error = parser.iterate(simdjson::pad(json_str)).get(doc);
+    if (error) {
+        std::cerr << "Parse error" << std::endl;
+        return 1;
+    }
+
+    Employee employee;
+    if (!parse_employee_manual(doc, employee)) {
+        std::cerr << "Manual parsing failed" << std::endl;
+        return 1;
+    }
+
+    std::cout << "Manual parsing successful: " << employee.person.name
+              << ", age " << employee.person.age << std::endl;
+    return 0;
+}
+EOF
+}
+
+# Function to create reflection parsing test
+create_reflection_parsing_test() {
+    local test_name="$1"
+    local struct_complexity="$2"
+
+    cat > "${test_name}_reflection.cpp" << 'EOF'
+#include <simdjson.h>
+#include <iostream>
+#include <string>
+#include <vector>
+#include <optional>
+
+// Test structures (same as manual version)
+struct Person {
+    std::string name;
+    int age;
+    bool active;
+};
+
+struct Address {
+    std::string street;
+    std::string city;
+    int zipcode;
+};
+
+struct Employee {
+    Person person;
+    Address address;
+    std::vector<std::string> skills;
+    std::optional<std::string> department;
+    double salary;
+};
+
+int main() {
+    simdjson::ondemand::parser parser;
+    std::string json_str = R"({
+        "person": {
+            "name": "John Doe",
+            "age": 30,
+            "active": true
+        },
+        "address": {
+            "street": "123 Main St",
+            "city": "Anytown",
+            "zipcode": 12345
+        },
+        "skills": ["C++", "JSON", "Programming"],
+        "department": "Engineering",
+        "salary": 85000.50
+    })";
+
+    simdjson::ondemand::document doc;
+    auto error = parser.iterate(simdjson::pad(json_str)).get(doc);
+    if (error) {
+        std::cerr << "Parse error" << std::endl;
+        return 1;
+    }
+
+    // Use reflection-based automatic deserialization
+    Employee employee;
+    auto result = doc.get<Employee>();
+    if (result.error()) {
+        std::cerr << "Reflection parsing failed" << std::endl;
+        return 1;
+    }
+    employee = result.value();
+
+    std::cout << "Reflection parsing successful: " << employee.person.name
+              << ", age " << employee.person.age << std::endl;
+    return 0;
+}
+EOF
+}
+
+# Function to time compilation of parsing approach
+time_parsing_compilation() {
+    local description="$1"
+    local test_file="$2"
+    local use_reflection="$3"
+    local iteration="$4"
+
+    echo "[$iteration] $description"
+
+    # Clean build
+    rm -rf build_parsing_test
+    mkdir build_parsing_test
+    cd build_parsing_test
+
+    # Copy test file
+    cp "../$test_file" .
+
+    echo "  Configuring..."
+    if [ "$use_reflection" = "true" ]; then
+        cmake -DCMAKE_CXX_COMPILER="$CXX" \
+              -DSIMDJSON_DEVELOPER_MODE=ON \
+              -DSIMDJSON_STATIC_REFLECTION=ON \
+              -DBUILD_SHARED_LIBS=OFF \
+              ../.. >/dev/null 2>&1
+    else
+        cmake -DCMAKE_CXX_COMPILER="$CXX" \
+              -DSIMDJSON_DEVELOPER_MODE=ON \
+              -DSIMDJSON_STATIC_REFLECTION=OFF \
+              -DBUILD_SHARED_LIBS=OFF \
+              ../.. >/dev/null 2>&1
+    fi
+
+    echo "  Building simdjson..."
+    cmake --build . --target simdjson >/dev/null 2>&1
+
+    echo "  Compiling parsing test..."
+    # Time just the test compilation
+    start_time=$(date +%s.%N)
+
+    "$CXX" -std=c++17 -I../../include "$test_file" -L. -lsimdjson -o parsing_test >/dev/null 2>&1
+
+    end_time=$(date +%s.%N)
+
+    # Calculate time duration
+    time_taken=$(echo "$end_time $start_time" | awk '{printf "%.3f", $1 - $2}')
+    echo "  Completed in: ${time_taken}s"
+
+    cd ..
+    rm -rf build_parsing_test
+
+    echo "$time_taken"
+}
+
+# Create test files
+echo "Creating test files..."
+create_manual_parsing_test "complex" "complex"
+create_reflection_parsing_test "complex" "complex"
+
+# Arrays to store times
+times_manual=""
+times_reflection=""
+
+echo
+echo "=== MANUAL PARSING COMPILATION ==="
+echo "Testing traditional simdjson parsing with explicit .get() calls"
+echo
+
+for i in $(seq 1 $ITERATIONS); do
+    time_result=$(time_parsing_compilation "Compiling manual parsing test" "complex_manual.cpp" "false" "$i" | tail -n1)
+    times_manual="$times_manual $time_result"
+done
+
+echo
+echo "=== REFLECTION PARSING COMPILATION ==="
+echo "Testing automatic deserialization with doc.get<Struct>()"
+echo
+
+for i in $(seq 1 $ITERATIONS); do
+    time_result=$(time_parsing_compilation "Compiling reflection parsing test" "complex_reflection.cpp" "true" "$i" | tail -n1)
+    times_reflection="$times_reflection $time_result"
+done
+
+echo
+echo "╔════════════════════════════════════════════════════════════════════════════╗"
+echo "║           REFLECTION USAGE COMPILATION RESULTS                             ║"
+echo "╠════════════════════════════════════════════════════════════════════════════╣"
+echo "║                                                                            ║"
+echo "║ MANUAL PARSING (explicit .get() calls):                                    ║"
+count=1
+for t in $times_manual; do
+    if [[ "$t" =~ ^[0-9]+\.?[0-9]*$ ]]; then
+        line=$(printf "Run %2d: %7.3f seconds" "$count" "$t")
+        print_box_line "$line"
+        count=$((count + 1))
+    fi
+done
+echo "║                                                                            ║"
+echo "║ REFLECTION PARSING (automatic doc.get<Struct>()):                          ║"
+count=1
+for t in $times_reflection; do
+    if [[ "$t" =~ ^[0-9]+\.?[0-9]*$ ]]; then
+        line=$(printf "Run %2d: %7.3f seconds" "$count" "$t")
+        print_box_line "$line"
+        count=$((count + 1))
+    fi
+done
+echo "╚════════════════════════════════════════════════════════════════════════════╝"
+
+echo
+echo "╔════════════════════════════════════════════════════════════════════════════╗"
+echo "║                              ANALYSIS SUMMARY                              ║"
+echo "╠════════════════════════════════════════════════════════════════════════════╣"
+echo "║                                                                            ║"
+
+# Calculate averages and percentages - filter to only numeric values first
+manual_numbers=""
+reflection_numbers=""
+
+for t in $times_manual; do
+    if [[ "$t" =~ ^[0-9]+\.?[0-9]*$ ]]; then
+        manual_numbers="$manual_numbers $t"
+    fi
+done
+
+for t in $times_reflection; do
+    if [[ "$t" =~ ^[0-9]+\.?[0-9]*$ ]]; then
+        reflection_numbers="$reflection_numbers $t"
+    fi
+done
+
+if [ -n "$manual_numbers" ] && [ -n "$reflection_numbers" ]; then
+    manual_avg=$(echo "$manual_numbers" | awk '{sum=0; for(i=1;i<=NF;i++) sum+=$i; print sum/NF}')
+    reflection_avg=$(echo "$reflection_numbers" | awk '{sum=0; for(i=1;i<=NF;i++) sum+=$i; print sum/NF}')
+    overhead=$(echo "$reflection_avg $manual_avg" | awk '{printf "%.3f", $1 - $2}')
+
+    if [ $(echo "$manual_avg > 0" | awk '{print ($1 > 0)}') -eq 1 ]; then
+        percent=$(echo "$reflection_avg $manual_avg" | awk '{printf "%.1f", ($1 - $2) / $2 * 100}')
+    else
+        percent="0"
+    fi
+
+    print_box_line "MANUAL PARSING RESULTS:"
+    print_box_line "$(printf "Average compilation time: %.3fs" "$manual_avg")"
+    print_box_line ""
+    print_box_line "REFLECTION PARSING RESULTS:"
+    print_box_line "$(printf "Average compilation time: %.3fs" "$reflection_avg")"
+    print_box_line ""
+    print_box_line "REFLECTION OVERHEAD:"
+    print_box_line "$(printf "Additional time: %.3fs (%+.1f%%)" "$overhead" "$percent")"
+    print_box_line ""
+else
+    echo "║ ERROR: Could not extract valid timing data                                 ║"
+    echo "║ Manual times: $times_manual"
+    echo "║ Reflection times: $times_reflection"
+    echo "║                                                                            ║"
+fi
+
+echo "╠════════════════════════════════════════════════════════════════════════════╣"
+echo "║                              INTERPRETATION                                ║"
+echo "╠════════════════════════════════════════════════════════════════════════════╣"
+echo "║                                                                            ║"
+echo "║ WHAT THESE RESULTS SHOW:                                                   ║"
+echo "║                                                                            ║"
+echo "║ • COMPILE-TIME COST: How much longer reflection parsing takes to compile   ║"
+echo "║   - Higher % = more expensive template instantiation and codegen           ║"
+echo "║                                                                            ║"
+echo "║ • CODE GENERATION OVERHEAD: Reflection creates parsing code at compile     ║"
+echo "║   time, which requires more template processing than manual parsing        ║"
+echo "║                                                                            ║"
+echo "║ • DEVELOPER TRADE-OFF: Reflection provides automatic deserialization       ║"
+echo "║   but at the cost of increased compilation time                            ║"
+echo "║                                                                            ║"
+echo "║ EVALUATION:                                                                ║"
+echo "║ • Low overhead (0-20%): Reflection is compile-time efficient               ║"
+echo "║ • Medium overhead (20-50%): Noticeable but potentially acceptable          ║"
+echo "║ • High overhead (50%+): Significant compilation cost for reflection        ║"
+echo "║                                                                            ║"
+echo "║ REAL-WORLD IMPACT:                                                         ║"
+echo "║ • Small projects: Absolute time matters more than percentage               ║"
+echo "║ • Large projects: Percentage overhead compounds across many files          ║"
+echo "║ • CI/CD pipelines: Longer builds affect development velocity               ║"
+echo "║                                                                            ║"
+echo "╚════════════════════════════════════════════════════════════════════════════╝"
+
+# Clean up test files
+rm -f complex_manual.cpp complex_reflection.cpp
+
+echo
+echo "Completed at: $(date)"
@@ -445,7 +445,7 @@ struct benchmarker {
    return 100.0 * a / b;
  }

-  void print(bool tabbed_output) const {
+  void print(bool tabbed_output, bool stage1_only) const {
    if (tabbed_output) {
      char* filename_copy = reinterpret_cast<char*>(malloc(strlen(filename)+1));
      SIMDJSON_PUSH_DISABLE_WARNINGS
@@ -503,17 +503,21 @@ struct benchmarker {
          stats->blocks_with_16_structurals_flipped, percent(stats->blocks_with_16_structurals_flipped, stats->blocks));
      }
      printf("\n");
-      printf("All Stages (excluding allocation)\n");
-      print_aggregate("|    "   , all_stages_without_allocation.best);
-      // frequently, allocation is a tiny fraction of the running time so we omit it
-      if(allocate_stage.best.elapsed_sec() > 0.01 * all_stages_without_allocation.best.elapsed_sec()) {
-        printf("|- Allocation\n");
-        print_aggregate("|    ", allocate_stage.best);
+      if(!stage1_only) {
+        printf("All Stages (excluding allocation)\n");
+        print_aggregate("|    "   , all_stages_without_allocation.best);
+        // frequently, allocation is a tiny fraction of the running time so we omit it
+        if(allocate_stage.best.elapsed_sec() > 0.01 * all_stages_without_allocation.best.elapsed_sec()) {
+          printf("|- Allocation\n");
+          print_aggregate("|    ", allocate_stage.best);
+        }
      }
      printf("|- Stage 1\n");
      print_aggregate("|    ", stage1.best);
-      printf("|- Stage 2\n");
-      print_aggregate("|    ", stage2.best);
+      if(!stage1_only) {
+        printf("|- Stage 2\n");
+        print_aggregate("|    ", stage2.best);
+      }
      if (collector.has_events()) {
        double freq1 = (stage1.best.cycles() / stage1.best.elapsed_sec()) / 1000000000.0;
        double freq2 = (stage2.best.cycles() / stage2.best.elapsed_sec()) / 1000000000.0;
@@ -0,0 +1,29 @@
+#pragma once
+
+#ifdef SIMDJSON_COMPETITION_BOOSTJSON
+
+#include "distinct_user_id.h"
+
+namespace distinct_user_id {
+
+struct boostjson {
+  bool run(simdjson::padded_string &json, std::vector<uint64_t> &result) {
+
+    auto root = boost::json::parse(json);
+    for (const auto &tweet : root.at("statuses").as_array()) {
+      result.push_back(tweet.at("user").at("id").to_number<uint64_t>());
+
+      if (tweet.as_object().if_contains("retweeted_status")) {
+        result.push_back(tweet.at("retweeted_status").at("user").at("id").to_number<uint64_t>());
+      }
+    }
+
+    return true;
+  }
+};
+
+BENCHMARK_TEMPLATE(distinct_user_id, boostjson)->UseManualTime();
+
+} // namespace distinct_user_id
+
+#endif // SIMDJSON_COMPETITION_BOOSTJSON
@@ -218,7 +218,7 @@ int main(int argc, char *argv[]) {
  if (!options.verbose) { progress.erase(); }

  for (size_t i=0; i<options.files.size(); i++) {
-    benchmarkers[i]->print(options.tabbed_output);
+    benchmarkers[i]->print(options.tabbed_output, options.stage1_only);
    delete benchmarkers[i];
  }

@@ -34,11 +34,15 @@
 #include <string>
 #include <vector>

-#include "linux-perf-events.h"
 #ifdef __linux__
+#include "linux-perf-events.h"
 #include <libgen.h>
 #endif

+#if __APPLE__ &&  __aarch64__
+#include "apple/apple_arm_events.h"
+#endif
+
 #include "simdjson.h"

 using std::string;
@@ -118,6 +122,7 @@ struct event_aggregate {
  }

  double elapsed_sec() const { return total.elapsed_sec() / iterations; }
+  double total_elapsed_ns() const { return total.elapsed_ns(); }
  double elapsed_ns() const { return total.elapsed_ns() / iterations; }
  double cycles() const { return total.cycles() / iterations; }
  double instructions() const { return total.instructions() / iterations; }
@@ -134,7 +139,7 @@ struct event_collector {

 #if defined(__linux__)
  LinuxEvents<PERF_TYPE_HARDWARE> linux_events;
-  event_collector(simdjson_unused bool quiet = false) : linux_events(vector<int>{
+  event_collector() : linux_events(vector<int>{
  #if SIMDJSON_SIMPLE_PERFORMANCE_COUNTERS
    PERF_COUNT_HW_CPU_CYCLES,
    PERF_COUNT_HW_INSTRUCTIONS,
@@ -149,8 +154,17 @@ struct event_collector {
  bool has_events() {
    return linux_events.is_working();
  }
+#elif __APPLE__ &&  __aarch64__
+  AppleEvents apple_events;
+  performance_counters diff;
+  event_collector() : diff(0) {
+    apple_events.setup_performance_counters();
+  }
+  bool has_events() {
+    return apple_events.setup_performance_counters();
+  }
 #else
-  event_collector(simdjson_unused bool _quiet = false) {}
+  event_collector() {}
  bool has_events() {
    return false;
  }
@@ -159,6 +173,8 @@ struct event_collector {
  simdjson_inline void start() {
 #if defined(__linux)
    linux_events.start();
+#elif __APPLE__ &&  __aarch64__
+    if(has_events()) { diff = apple_events.get_counters(); }
 #endif
    start_clock = steady_clock::now();
  }
@@ -166,6 +182,16 @@ struct event_collector {
    time_point<steady_clock> end_clock = steady_clock::now();
 #if defined(__linux)
    linux_events.end(count.event_counts);
+#elif __APPLE__ &&  __aarch64__
+    if(has_events()) {
+      performance_counters end = apple_events.get_counters();
+      diff = end - diff;
+    }
+    count.event_counts[0] = diff.cycles;
+    count.event_counts[1] = diff.instructions;
+    count.event_counts[2] = diff.missed_branches;
+    count.event_counts[3] = 0;
+    count.event_counts[4] = 0;
 #endif
    count.elapsed = end_clock - start_clock;
    return count;
@@ -0,0 +1,30 @@
+#pragma once
+
+#ifdef SIMDJSON_COMPETITION_BOOSTJSON
+
+#include "find_tweet.h"
+
+namespace find_tweet {
+
+struct boostjson {
+  using StringType=std::string;
+
+  bool run(simdjson::padded_string &json, uint64_t find_id, std::string &result) {
+
+    auto root = boost::json::parse(json);
+    for (const auto &tweet : root.at("statuses").as_array()) {
+      if (tweet.at("id") == find_id) {
+        result = tweet.at("text").as_string();
+        return true;
+      }
+    }
+
+    return false;
+  }
+};
+
+BENCHMARK_TEMPLATE(find_tweet, boostjson)->UseManualTime();
+
+} // namespace find_tweet
+
+#endif // SIMDJSON_COMPETITION_BOOSTJSON
@@ -13,7 +13,7 @@ struct nlohmann_json {
    auto root = nlohmann::json::parse(json.data(), json.data() + json.size());
    for (auto tweet : root["statuses"]) {
      if (tweet["id"] == find_id) {
-        result = tweet["text"];
+        result = to_string(tweet["text"]);
        return true;
      }
    }
@@ -0,0 +1,104 @@
+#pragma once
+
+#ifdef SIMDJSON_COMPETITION_BOOSTJSON
+
+#include "json2msgpack.h"
+
+namespace json2msgpack {
+
+struct boostjson2msgpack {
+  inline std::string_view to_msgpack(const boost::json::value &root, uint8_t *buf) {
+    buff = buf;
+    recursive_processor(root);
+    return std::string_view(reinterpret_cast<char *>(buf), size_t(buff - buf));
+  }
+
+private:
+  uint8_t *buff{};
+
+  inline void write_double(const double d) noexcept {
+    *buff++ = 0xcb;
+    ::memcpy(buff, &d, sizeof(d));
+    buff += sizeof(d);
+  }
+
+  inline void write_byte(const uint8_t b) noexcept {
+    *buff = b;
+    buff++;
+  }
+
+  inline void write_uint32(const uint32_t w) noexcept {
+    ::memcpy(buff, &w, sizeof(w));
+    buff += sizeof(w);
+  }
+
+  inline void write_string(const std::string & str) {
+    write_byte(0xdb);
+    write_uint32(uint32_t(str.size()));
+    ::memcpy(buff, str.data(), str.size());
+    buff += str.size();
+  }
+
+  inline void recursive_processor(const boost::json::value &element) {
+    switch(element.kind()) {
+    case boost::json::kind::array: {
+      write_byte(0xdd);
+      const auto &array = element.as_array();
+      write_uint32(static_cast<uint32_t>(array.size()));
+      for (const auto &child : array) {
+        recursive_processor(child);
+      }
+    } break;
+
+    case boost::json::kind::object: {
+      write_byte(0xdf);
+      const auto &object = element.as_object();
+      write_uint32(static_cast<uint32_t>(object.size()));
+      for (const auto &child : object) {
+        write_string(child.key_c_str());
+        recursive_processor(child.value());
+      }
+    } break;
+
+    case boost::json::kind::int64:
+    case boost::json::kind::uint64:
+    case boost::json::kind::double_:
+      write_double(element.to_number<double>());
+      break;
+
+    case boost::json::kind::string:
+      write_string(element.as_string().c_str());
+      break;
+
+    case boost::json::kind::bool_:
+      write_byte(0xc2 + element.as_bool());
+      break;
+
+    case boost::json::kind::null:
+      write_byte(0xc0);
+      break;
+
+    default:
+      printf("unexpected\n");
+      break;
+    }
+  }
+};
+
+struct boostjson {
+  using StringType=std::string;
+
+  boostjson2msgpack parser{};
+
+  bool run(simdjson::padded_string &json, char *buffer, std::string_view &result) {
+    auto root = boost::json::parse(json);
+    result = parser.to_msgpack(root, reinterpret_cast<uint8_t *>(buffer));
+    return true;
+  }
+};
+
+BENCHMARK_TEMPLATE(json2msgpack, boostjson)->UseManualTime();
+
+} // namespace json2msgpack
+
+#endif // SIMDJSON_COMPETITION_BOOSTJSON
@@ -24,7 +24,7 @@ struct file_runner : public runner_base<I> {

  simdjson_warn_unused bool before_run(benchmark::State &state) {
    if (!runner_base<I>::after_run(state)) { return false; };
-    // Copy the original json in case we did *in situ* last time
+    // Copy the original JSON in case we did *in situ* last time
    std::memcpy(json.data(), original_json.data(), original_json.size());
    return true;
  }
@@ -19,7 +19,7 @@ void maybe_display_implementation() {
 template<typename B, typename R> static void run_json_benchmark(benchmark::State &state) {
  maybe_display_implementation();

-  event_collector collector(true);
+  event_collector collector;
  event_aggregate events;

  // Warmup and equality check (make sure the data is right!)
@@ -13,7 +13,7 @@ struct string_runner : public runner_base<I> {

  simdjson_warn_unused bool before_run(benchmark::State &state) {
    if (!runner_base<I>::after_run(state)) { return false; };
-    // Copy the original json in case we did *in situ*
+    // Copy the original JSON in case we did *in situ*
    std::memcpy(json.data(), original_json.data(), original_json.size());
    return true;
  }
@@ -0,0 +1,29 @@
+#pragma once
+
+#ifdef SIMDJSON_COMPETITION_BOOSTJSON
+
+#include "kostya.h"
+
+namespace kostya {
+
+struct boostjson {
+  static constexpr diff_flags DiffFlags = diff_flags::IMPRECISE_FLOATS;
+
+  bool run(simdjson::padded_string &json, std::vector<point> &result) {
+    auto root = boost::json::parse(json);
+    for (const auto &point : root.at("coordinates").as_array()) {
+      result.emplace_back(json_benchmark::point{
+        point.at("x").to_number<double>(),
+        point.at("y").to_number<double>(),
+        point.at("z").to_number<double>()
+      });
+    }
+    return true;
+  }
+};
+
+BENCHMARK_TEMPLATE(kostya, boostjson)->UseManualTime();
+
+} // namespace kostya
+
+#endif // SIMDJSON_COMPETITION_BOOSTJSON
@@ -0,0 +1,29 @@
+#pragma once
+
+#ifdef SIMDJSON_COMPETITION_BOOSTJSON
+
+#include "large_random.h"
+
+namespace large_random {
+
+struct boostjson {
+  static constexpr diff_flags DiffFlags = diff_flags::IMPRECISE_FLOATS;
+
+  bool run(simdjson::padded_string &json, std::vector<point> &result) {
+    auto root = boost::json::parse(json);
+    for (const auto &point : root.as_array()) {
+      result.emplace_back(json_benchmark::point{
+        point.at("x").to_number<double>(),
+        point.at("y").to_number<double>(),
+        point.at("z").to_number<double>()
+      });
+    }
+    return true;
+  }
+};
+
+BENCHMARK_TEMPLATE(large_random, boostjson)->UseManualTime();
+
+} // namespace large_random
+
+#endif // SIMDJSON_COMPETITION_BOOSTJSON
@@ -23,7 +23,29 @@ struct simdjson_ondemand {
 };

 BENCHMARK_TEMPLATE(large_random, simdjson_ondemand)->UseManualTime();
+#if SIMDJSON_STATIC_REFLECTION

+struct simdjson_ondemand_static_reflect {
+  static constexpr diff_flags DiffFlags = diff_flags::NONE;
+
+  ondemand::parser parser{};
+
+  bool run(simdjson::padded_string &json, std::vector<point> &result) {
+    auto doc = parser.iterate(json);
+    if(auto e = doc.get_array().get<std::vector<point>>(result); e) { return false; }
+    // We can also do it like so:
+    //for (ondemand::object coord : doc) {
+    //  result.emplace_back(coord.get<point>());
+    //}
+    // It seems that doing the reflection is slower than doing the manual lookup.
+    // E.g., it is faster if we do result.emplace_back(coord["x"], coord["y"], coord["z"]);
+    return true;
+  }
+};
+BENCHMARK_TEMPLATE(large_random, simdjson_ondemand_static_reflect)->UseManualTime();
+
+
+#endif
 } // namespace large_random

 #endif // SIMDJSON_EXCEPTIONS
@@ -0,0 +1,43 @@
+#pragma once
+
+#ifdef SIMDJSON_COMPETITION_BOOSTJSON
+
+#include "partial_tweets.h"
+
+namespace partial_tweets {
+
+struct boostjson {
+  using StringType=std::string;
+
+  bool run(simdjson::padded_string &json, std::vector<tweet<StringType>> &result) {
+
+    auto root = boost::json::parse(json);
+    for (const auto &tweet : root.at("statuses").as_array()) {
+      const auto &user = tweet.at("user");
+
+      auto in_reply_to_status_id = tweet.as_object().if_contains("in_reply_to_status_id")
+        ? tweet.at("in_reply_to_status_id") : boost::json::value();
+
+      result.emplace_back(partial_tweets::tweet<StringType>{
+        tweet.at("created_at").as_string().c_str(),
+        tweet.at("id").to_number<uint64_t>(),
+        tweet.at("text").as_string().c_str(),
+        in_reply_to_status_id.is_null() ? 0 : in_reply_to_status_id.to_number<uint64_t>(),
+        {
+          user.at("id").to_number<uint64_t>(),
+          user.at("screen_name").as_string().c_str()
+        },
+        tweet.at("retweet_count").to_number<uint64_t>(),
+        tweet.at("favorite_count").to_number<uint64_t>()
+      });
+    }
+
+    return true;
+  }
+};
+
+BENCHMARK_TEMPLATE(partial_tweets, boostjson)->UseManualTime();
+
+} // namespace partial_tweets
+
+#endif // SIMDJSON_COMPETITION_BOOSTJSON
@@ -13,7 +13,7 @@ class OnDemand {
 public:
  OnDemand() {
    if(!displayed_implementation) {
-      std::cout << "On Demand implementation: " << builtin_implementation()->name() << std::endl;
+      std::cout << "On-Demand implementation: " << builtin_implementation()->name() << std::endl;
      displayed_implementation = true;
    }
  }
@@ -0,0 +1,44 @@
+# Include reflect-cpp
+CPMAddPackage(
+  NAME reflect-cpp
+  GITHUB_REPOSITORY getml/reflect-cpp
+  GIT_TAG v0.17.0
+  EXCLUDE_FROM_ALL YES
+)
+
+
+
+if(NOT WIN32)
+# We want the check whether Rust is available before trying to build a crate.
+CPMAddPackage(
+  NAME corrosion
+  GITHUB_REPOSITORY corrosion-rs/corrosion
+  VERSION 0.4.4
+  DOWNLOAD_ONLY ON
+  OPTIONS "Rust_FIND_QUIETLY OFF"
+)
+include("${corrosion_SOURCE_DIR}/cmake/FindRust.cmake")
+endif()
+
+if(RUST_FOUND)
+  message(STATUS "Rust found: " ${Rust_VERSION} )
+  add_subdirectory("${corrosion_SOURCE_DIR}" "${PROJECT_BINARY_DIR}/_deps/corrosion" EXCLUDE_FROM_ALL)
+  # Important: we want to build in release mode!
+  corrosion_import_crate(MANIFEST_PATH "serde-benchmark/Cargo.toml" NO_LINKER_OVERRIDE PROFILE release)
+else()
+  message(STATUS "Rust/Cargo is unavailable." )
+  message(STATUS "We will not benchmark serde-benchmark." )
+  if (${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+    message(STATUS "Under macOS, you may be able to install rust with")
+    message(STATUS "curl https://sh.rustup.rs -sSf | sh")
+  elseif(CMAKE_SYSTEM_NAME STREQUAL "Linux")
+    message(STATUS "Under Linux, you may be able to install rust with a command such as")
+    message(STATUS "apt-get install cargo" )
+    message(STATUS "or" )
+    message(STATUS "curl https://sh.rustup.rs -sSf | sh")
+  endif()
+endif()
+
+# Add the benchmark executable targets
+add_subdirectory(twitter_benchmark)
+add_subdirectory(citm_catalog_benchmark)
@@ -0,0 +1,52 @@
+#ifndef BENCHMARK_HELPER_HPP
+#define BENCHMARK_HELPER_HPP
+#include "event_counter.h"
+#include <atomic>
+
+inline event_collector &get_collector() {
+  static event_collector collector;
+  return collector;
+}
+
+template <class function_type>
+event_aggregate bench(const function_type &function, size_t min_repeat = 10,
+                      size_t min_time_ns = 1000000000,
+                      size_t max_repeat = 100000) {
+  event_collector &collector = get_collector();
+  event_aggregate aggregate{};
+  size_t N = min_repeat;
+  if (N == 0) {
+    N = 1;
+  }
+  for (size_t i = 0; i < N; i++) {
+    std::atomic_thread_fence(std::memory_order_acquire);
+    collector.start();
+    function();
+    std::atomic_thread_fence(std::memory_order_release);
+    event_count allocate_count = collector.end();
+    aggregate << allocate_count;
+    if ((i + 1 == N) && (aggregate.total_elapsed_ns() < min_time_ns) &&
+        (N < max_repeat)) {
+      N *= 10;
+    }
+  }
+  return aggregate;
+}
+
+// Source of the 2 functions below:
+// https://github.com/simdutf/simdutf/blob/master/benchmarks/base64/benchmark_base64.cpp
+inline void pretty_print(size_t strings, size_t bytes, std::string name,
+                         event_aggregate agg) {
+  event_collector &collector = get_collector();
+  printf("%-60s : ", name.c_str());
+  printf(" %5.2f MB/s ", bytes * 1000 / agg.elapsed_ns());
+  printf(" %5.2f Ms/s ", strings * 1000 / agg.elapsed_ns());
+  if (collector.has_events()) {
+    printf(" %5.2f GHz ", agg.cycles() / agg.elapsed_ns());
+    printf(" %5.2f c/b ", agg.cycles() / bytes);
+    printf(" %5.2f i/b ", agg.instructions() / bytes);
+    printf(" %5.2f i/c ", agg.instructions() / agg.cycles());
+  }
+  printf("\n");
+}
+#endif
@@ -0,0 +1,14 @@
+add_executable(benchmark_serialization_citm_catalog benchmark_serialization_citm_catalog.cpp)
+
+# Link with Rust benchmarking code if available
+if(TARGET serde-benchmark)
+    message(STATUS "serde-benchmark target was created. Linking CITM catalog benchmark with serde-benchmark.")
+    target_link_libraries(benchmark_serialization_citm_catalog PRIVATE serde-benchmark)
+    target_compile_definitions(benchmark_serialization_citm_catalog PRIVATE SIMDJSON_RUST_VERSION="${Rust_VERSION}")
+endif()
+
+target_link_libraries(benchmark_serialization_citm_catalog PRIVATE simdjson::simdjson nlohmann_json)
+target_link_libraries(benchmark_serialization_citm_catalog PRIVATE reflectcpp)
+target_compile_definitions(benchmark_serialization_citm_catalog PRIVATE SIMDJSON_BENCH_CPP_REFLECT=1)
+
+target_compile_definitions(benchmark_serialization_citm_catalog PRIVATE JSON_FILE="${BENCH_CITM_JSON}")
@@ -0,0 +1,177 @@
+#include <cassert>
+#include <cstdlib>
+#include <ctime>
+#include <format>
+#include <fstream>
+#include <iostream>
+#include <nlohmann/json.hpp>
+#include <simdjson.h>
+#include <string>
+#include "citm_catalog_data.h"
+#include "nlohmann_citm_catalog_data.h"
+#include "../benchmark_utils/benchmark_helper.h"
+
+#if SIMDJSON_BENCH_CPP_REFLECT
+#include <rfl.hpp>
+#include <rfl/json.hpp>
+void bench_reflect_cpp(CitmCatalog &data) {
+  std::string output = rfl::json::write(data);
+  size_t output_volume = output.size();
+  printf("# output volume: %zu bytes\n", output_volume);
+
+  volatile size_t measured_volume = 0;
+  pretty_print(1, output_volume, "bench_reflect_cpp",
+               bench([&data, &measured_volume, &output_volume]() {
+                 std::string output = rfl::json::write(data);
+                 measured_volume = output.size();
+                 if (measured_volume != output_volume) {
+                   printf("mismatch\n");
+                 }
+               }));
+}
+#endif // SIMDJSON_BENCH_CPP_REFLECT
+
+#ifdef SIMDJSON_RUST_VERSION
+#include "../serde-benchmark/serde_benchmark.h"
+
+void bench_rust(serde_benchmark::CitmCatalog *data) {
+  const char * output = serde_benchmark::str_from_citm(data);
+  size_t output_volume = strlen(output);
+  printf("# output volume: %zu bytes\n", output_volume);
+  volatile size_t measured_volume = 0;
+  pretty_print(1, output_volume, "bench_rust",
+               bench([&data, &measured_volume, &output_volume]() {
+                 const char * output = serde_benchmark::str_from_citm(data);
+                 measured_volume = strlen(output);
+                 if (measured_volume != output_volume) {
+                   printf("mismatch\n");
+                 }
+                 serde_benchmark::free_str(const_cast<char*>(output));
+               }));
+  serde_benchmark::free_str(const_cast<char*>(output));
+}
+#endif // SIMDJSON_RUST_VERSION
+
+void bench_nlohmann(CitmCatalog &data) {
+  std::string output = nlohmann_serialize(data);
+  size_t output_volume = output.size();
+  printf("# output volume: %zu bytes\n", output_volume);
+
+  volatile size_t measured_volume = 0;
+  pretty_print(1, output_volume, "bench_nlohmann",
+               bench([&data, &measured_volume, &output_volume]() {
+                 std::string output = nlohmann_serialize(data);
+                 measured_volume = output.size();
+                 if (measured_volume != output_volume) {
+                   printf("mismatch\n");
+                 }
+               }));
+}
+
+void bench_simdjson_static_reflection(CitmCatalog &data) {
+  simdjson::builder::string_builder sb;
+  simdjson::builder::append(sb, data);
+  std::string_view p;
+  if(sb.view().get(p)) {
+    std::cerr << "Error!" << std::endl;
+  }
+  size_t output_volume = p.size();
+  sb.clear();
+  printf("# output volume: %zu bytes\n", output_volume);
+
+  volatile size_t measured_volume = 0;
+  pretty_print(sizeof(data), output_volume, "bench_simdjson_static_reflection",
+               bench([&data, &measured_volume, &output_volume, &sb]() {
+                 sb.clear();
+                 simdjson::builder::append(sb, data);
+                 std::string_view p;
+                 if(sb.view().get(p)) {
+                   std::cerr << "Error!" << std::endl;
+                 }
+                 measured_volume = sb.size();
+                 if (measured_volume != output_volume) {
+                   printf("mismatch\n");
+                 }
+               }));
+}
+
+std::string read_file(const std::string &file_path, size_t read_size = 65536) {
+  std::ifstream stream(file_path, std::ios::binary);
+  if(!stream) {
+    std::cerr << "Could not open file '" << file_path << "'" << std::endl;
+    exit(EXIT_FAILURE);
+  }
+  stream.exceptions(std::ios_base::badbit);
+  std::string out;
+  std::string buf(read_size, '\0');
+  while (stream.read(&buf[0], read_size)) {
+    out.append(buf, 0, size_t(stream.gcount()));
+  }
+  out.append(buf, 0, size_t(stream.gcount()));
+  return out;
+}
+
+// Function to check if benchmark name contains filter substring
+bool matches_filter(const std::string& benchmark_name, const std::string& filter) {
+  return filter.empty() || benchmark_name.find(filter) != std::string::npos;
+}
+
+int main(int argc, char* argv[]) {
+  std::string filter;
+
+  // Parse command-line arguments
+  for (int i = 1; i < argc; ++i) {
+      if (strcmp(argv[i], "-f") == 0 || strcmp(argv[i], "--filter") == 0) {
+          if (i + 1 < argc) {
+              filter = argv[++i];
+          } else {
+              std::cerr << "Error: -f/--filter requires an argument" << std::endl;
+              return EXIT_FAILURE;
+          }
+      }
+  }
+  // Testing correctness of round-trip (serialization + deserialization)
+  std::string json_str = read_file(JSON_FILE);
+
+  // Loading up the data into a structure.
+  simdjson::ondemand::parser parser;
+  simdjson::ondemand::document doc;
+  if(parser.iterate(simdjson::pad(json_str)).get(doc)) {
+    std::cerr << "Error loading the document!" << std::endl;
+    return EXIT_FAILURE;
+  }
+  CitmCatalog my_struct;
+  if(doc.get<CitmCatalog>().get(my_struct)) {
+    std::cerr << "Error loading CitmCatalog!" << std::endl;
+    return EXIT_FAILURE;
+  }
+
+  // Benchmarking the serialization
+  if (matches_filter("nlohmann", filter)) {
+    bench_nlohmann(my_struct);
+  }
+  if (matches_filter("simdjson_static_reflection", filter)) {
+    bench_simdjson_static_reflection(my_struct);
+  }
+#ifdef SIMDJSON_RUST_VERSION
+  if (matches_filter("rust", filter)) {
+    printf("# WARNING: The Rust benchmark may not be directly comparable since it does not use an equivalent data structure.\n");
+    // Create a Rust-compatible CitmCatalog structure from the JSON string
+    serde_benchmark::CitmCatalog* rust_data =
+      serde_benchmark::citm_from_str(json_str.c_str(), json_str.size());
+
+    if (rust_data == nullptr) {
+      printf("# Failed to initialize Rust data structure\n");
+    } else {
+      bench_rust(rust_data);
+      serde_benchmark::free_citm(rust_data);
+    }
+  }
+#endif
+#if SIMDJSON_BENCH_CPP_REFLECT
+  if (matches_filter("reflect_cpp", filter)) {
+    bench_reflect_cpp(my_struct);
+  }
+#endif
+  return EXIT_SUCCESS;
+}
@@ -0,0 +1,82 @@
+#ifndef CITM_CATALOG_DATA_H
+#define CITM_CATALOG_DATA_H
+
+#include <string>
+#include <vector>
+#include <map>
+
+struct Area {
+  int64_t id;
+  std::string name;
+  int64_t parent;
+  std::vector<int64_t> childAreas;
+  bool operator==(const Area &other) const = default;
+};
+
+struct AudienceSubCategory {
+  int64_t id;
+  std::string name;
+  int64_t parent;
+  bool operator==(const AudienceSubCategory &other) const = default;
+};
+
+struct Event {
+  int64_t id;
+  std::string name;
+  std::string description;
+  int64_t subTopic;
+  int64_t topic;
+  std::vector<int64_t> audience;
+  bool operator==(const Event &other) const = default;
+};
+
+struct Performance {
+  int64_t id;
+  std::string name;
+  int64_t event;
+  std::string start;
+  int64_t venueCode;
+  bool operator==(const Performance &other) const = default;
+};
+
+struct SeatCategory {
+  int64_t id;
+  std::string name;
+  std::vector<int64_t> areas;
+  bool operator==(const SeatCategory &other) const = default;
+};
+
+struct SubTopic {
+  int64_t id;
+  std::string name;
+  int64_t parent;
+  bool operator==(const SubTopic &other) const = default;
+};
+
+struct Topic {
+  int64_t id;
+  std::string name;
+  bool operator==(const Topic &other) const = default;
+};
+
+struct Venue {
+  int64_t id;
+  std::string name;
+  int64_t address;
+  bool operator==(const Venue &other) const = default;
+};
+
+struct CitmCatalog {
+  std::map<std::string, Area> areas;
+  std::map<std::string, AudienceSubCategory> audienceSubCategory;
+  std::map<std::string, Event> events;
+  std::map<std::string, Performance> performances;
+  std::map<std::string, SeatCategory> seatCategory;
+  std::map<std::string, SubTopic> subTopic;
+  std::map<std::string, Topic> topic;
+  std::map<std::string, Venue> venue;
+
+  bool operator==(const CitmCatalog &other) const = default;
+};
+
+#endif
@@ -0,0 +1,171 @@
+// nlohmann_citm_catalog_data.h
+#ifndef NLOHMANN_CITM_CATALOG_DATA_H
+#define NLOHMANN_CITM_CATALOG_DATA_H
+
+#include "citm_catalog_data.h"
+#include <nlohmann/json.hpp>
+#include <string>
+
+using json = nlohmann::json;
+
+// ---- Area ----
+inline void to_json(json &j, const Area &a) {
+    j = json{
+      {"id", a.id},
+      {"name", a.name},
+      {"parent", a.parent},
+      {"childAreas", a.childAreas}
+    };
+}
+inline void from_json(const json &j, Area &a) {
+    j.at("id").get_to(a.id);
+    j.at("name").get_to(a.name);
+    j.at("parent").get_to(a.parent);
+    j.at("childAreas").get_to(a.childAreas);
+}
+
+// ---- AudienceSubCategory ----
+inline void to_json(json &j, const AudienceSubCategory &asc) {
+    j = json{
+      {"id", asc.id},
+      {"name", asc.name},
+      {"parent", asc.parent}
+    };
+}
+inline void from_json(const json &j, AudienceSubCategory &asc) {
+    j.at("id").get_to(asc.id);
+    j.at("name").get_to(asc.name);
+    j.at("parent").get_to(asc.parent);
+}
+
+// ---- Event ----
+inline void to_json(json &j, const Event &e) {
+    j = json{
+      {"id", e.id},
+      {"name", e.name},
+      {"description", e.description},
+      {"subTopic", e.subTopic},
+      {"topic", e.topic},
+      {"audience", e.audience}
+    };
+}
+inline void from_json(const json &j, Event &e) {
+    j.at("id").get_to(e.id);
+    j.at("name").get_to(e.name);
+    j.at("description").get_to(e.description);
+    j.at("subTopic").get_to(e.subTopic);
+    j.at("topic").get_to(e.topic);
+    j.at("audience").get_to(e.audience);
+}
+
+// ---- Performance ----
+inline void to_json(json &j, const Performance &p) {
+    j = json{
+      {"id", p.id},
+      {"name", p.name},
+      {"event", p.event},
+      {"start", p.start},
+      {"venueCode", p.venueCode}
+    };
+}
+inline void from_json(const json &j, Performance &p) {
+    j.at("id").get_to(p.id);
+    j.at("name").get_to(p.name);
+    j.at("event").get_to(p.event);
+    j.at("start").get_to(p.start);
+    j.at("venueCode").get_to(p.venueCode);
+}
+
+// ---- SeatCategory ----
+inline void to_json(json &j, const SeatCategory &sc) {
+    j = json{
+      {"id", sc.id},
+      {"name", sc.name},
+      {"areas", sc.areas}
+    };
+}
+inline void from_json(const json &j, SeatCategory &sc) {
+    j.at("id").get_to(sc.id);
+    j.at("name").get_to(sc.name);
+    j.at("areas").get_to(sc.areas);
+}
+
+// ---- SubTopic ----
+inline void to_json(json &j, const SubTopic &st) {
+    j = json{
+      {"id", st.id},
+      {"name", st.name},
+      {"parent", st.parent}
+    };
+}
+inline void from_json(const json &j, SubTopic &st) {
+    j.at("id").get_to(st.id);
+    j.at("name").get_to(st.name);
+    j.at("parent").get_to(st.parent);
+}
+
+// ---- Topic ----
+inline void to_json(json &j, const Topic &t) {
+    j = json{
+      {"id", t.id},
+      {"name", t.name}
+    };
+}
+inline void from_json(const json &j, Topic &t) {
+    j.at("id").get_to(t.id);
+    j.at("name").get_to(t.name);
+}
+
+// ---- Venue ----
+inline void to_json(json &j, const Venue &v) {
+    j = json{
+      {"id", v.id},
+      {"name", v.name},
+      {"address", v.address}
+    };
+}
+inline void from_json(const json &j, Venue &v) {
+    j.at("id").get_to(v.id);
+    j.at("name").get_to(v.name);
+    j.at("address").get_to(v.address);
+}
+
+// ---- CitmCatalog ----
+inline void to_json(json &j, const CitmCatalog &c) {
+    j = json{
+      {"areas", c.areas},
+      {"audienceSubCategory", c.audienceSubCategory},
+      {"events", c.events},
+      {"performances", c.performances},
+      {"seatCategory", c.seatCategory},
+      {"subTopic", c.subTopic},
+      {"topic", c.topic},
+      {"venue", c.venue}
+    };
+}
+inline void from_json(const json &j, CitmCatalog &c) {
+    j.at("areas").get_to(c.areas);
+    j.at("audienceSubCategory").get_to(c.audienceSubCategory);
+    j.at("events").get_to(c.events);
+    j.at("performances").get_to(c.performances);
+    j.at("seatCategory").get_to(c.seatCategory);
+    j.at("subTopic").get_to(c.subTopic);
+    j.at("topic").get_to(c.topic);
+    j.at("venue").get_to(c.venue);
+}
+
+// Optional convenience functions for benchmarking
+inline std::string nlohmann_serialize(const CitmCatalog &catalog) {
+    json j = catalog;
+    return j.dump();
+}
+inline bool nlohmann_deserialize(const std::string &json_in, CitmCatalog &catalog) {
+    try {
+        catalog = json::parse(json_in);
+        return false; // success
+    } catch(...) {
+        return true;  // failure
+    }
+}
+
+#endif // NLOHMANN_CITM_CATALOG_DATA_H
@@ -0,0 +1,103 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "itoa"
+version = "1.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
+
+[[package]]
+name = "libc"
+version = "0.2.158"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8adc4bb1803a324070e64a98ae98f38934d91957a99cfb3a43dcbc01bc56439"
+
+[[package]]
+name = "memchr"
+version = "2.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.86"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "ryu"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f"
+
+[[package]]
+name = "serde"
+version = "1.0.209"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "99fce0ffe7310761ca6bf9faf5115afbc19688edd00171d81b1bb1b116c63e09"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde-benchmark"
+version = "0.1.0"
+dependencies = [
+ "libc",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.209"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a5831b979fd7b5439637af1752d535ff49f4860c0f341d1baeb6faf0f4242170"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.127"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8043c06d9f82bd7271361ed64f415fe5e12a77fdb52e573e7f06a516dea329ad"
+dependencies = [
+ "itoa",
+ "memchr",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.76"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "578e081a14e0cefc3279b0472138c513f37b41a08d5a3cca9b6e4e8ceb6cd525"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
@@ -0,0 +1,17 @@
+[package]
+name = "serde-benchmark"
+version = "0.1.0"
+
+[lib]
+path = "lib.rs"
+crate-type = ["cdylib"]
+
+[dependencies]
+serde = { version = "1.0", features = ["derive"] }
+libc = "0.2"
+serde_json = "1.0"
+
+[profile.release]
+opt-level = 3
+debug = false
+lto = true
@@ -0,0 +1,18 @@
+## Rust Serde FFI
+
+This folder includes FFI bindings for rust/serde.
+
+### Links
+
+- https://github.com/eqrion/cbindgen/blob/master/docs.md
+- https://gist.github.com/zbraniecki/b251714d77ffebbc73c03447f2b2c69f
+- https://michael-f-bryan.github.io/rust-ffi-guide/setting_up.html
+
+### Building
+
+- Generating cbindgen output
+  - Install dependencies with `brew install cbindgen` or `apt-get install cbindgen` or `cargo install cbindgen` or the equivalent: we used `cargo install --version 0.23.0 cbindgen`.
+  - Go to the directory where this README.md file is located
+  - Generate with `cbindgen --config cbindgen.toml --crate serde-benchmark --output serde_benchmark.h`
+- Building
+  - Run with `cargo build --release`
@@ -0,0 +1,12 @@
+autogen_warning = "/* Warning, this file is autogenerated by cbindgen. Don't modify this manually. */"
+include_version = true
+braces = "SameLine"
+line_length = 100
+tab_width = 2
+language = "C++"
+namespaces = ["serde_benchmark"]
+include_guard = "serde_benchmark_ffi_h"
+
+[parse]
+parse_deps = true
+include = ["serde_json", "serde"]
@@ -0,0 +1,482 @@
+extern crate serde;
+extern crate serde_json;
+extern crate libc;
+
+use libc::{c_char, size_t};
+use serde::{Serialize, Deserialize};
+use std::{collections::HashMap, ffi::CString, ptr, slice};
+use serde::de::{self, Deserializer};
+/******************************************************/
+/******************************************************/
+/**
+ * Warning: the C++ code may not generate the same JSON.
+ */
+ /******************************************************/
+ /******************************************************/
+
+// This has no equivalent in C++:
+#[derive(Serialize, Deserialize)]
+pub struct Metadata {
+    result_type: String,
+    iso_language_code: String,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct User {
+    id: i64,
+    id_str: String,
+    name: String,
+    screen_name: String,
+    location: String,
+    description: String,
+    // C++ does not have those:
+    // url: Option<String>,
+    //protected: bool,
+    //listed_count: i64,
+    //created_at: String,
+    //favourites_count: i64,
+    //utc_offset: Option<i64>,
+    //time_zone: Option<String>,
+    //geo_enabled: bool,
+    verified: bool,
+    followers_count: i64,
+    friends_count: i64,
+    statuses_count: i64,
+    // C++ does not have those:
+    //lang: String,
+    //profile_background_color: String,
+    //profile_background_image_url: String,
+    //profile_background_image_url_https: String,
+    //profile_background_tile: bool,
+    //profile_image_url: String,
+    //profile_image_url_https: String,
+    //profile_banner_url: Option<String>,
+    //profile_link_color: String,
+    //profile_sidebar_border_color: String,
+    //profile_sidebar_fill_color: String,
+    //profile_text_color: String,
+    //profile_use_background_image: bool,
+    //default_profile: bool,
+    //default_profile_image: bool,
+    //following: bool,
+    //follow_request_sent: bool,
+    //notifications: bool,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct Hashtag {
+    text: String,
+
+    // C++ has those but D. Lemire does not know what they are, they don't appear in the JSON:
+    // int64_t indices_start;
+    // int64_t indices_end;
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct Url {
+    url: String,
+    expanded_url: String,
+    display_url: String,
+    // C++ has those but D. Lemire does not know what they are, they don't appear in the JSON:
+    // int64_t indices_start;
+    // int64_t indices_end;
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct UserMention {
+    id: i64,
+    name: String,
+    screen_name: String,
+    // Not in the C++ equivalent:
+    //id_str: String,
+    //indices: Vec<i64>,
+    // C++ has those but D. Lemire does not know what they are, they don't appear in the JSON:
+    // int64_t indices_start;
+    // int64_t indices_end;
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct Entities {
+    hashtags: Vec<Hashtag>,
+    urls: Vec<Url>,
+    user_mentions: Vec<UserMention>,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct Status {
+    created_at: String,
+    id: i64,
+    text: String,
+    user: User,
+    entities: Entities,
+    retweet_count: i64,
+    favorite_count: i64,
+    favorited: bool,
+    retweeted: bool,
+    // None of these are in the C++ equivalent:
+    /*
+    metadata: Metadata,
+    id_str: String,
+    source: String,
+    truncated: bool,
+    in_reply_to_status_id: Option<i64>,
+    in_reply_to_status_id_str: Option<String>,
+    in_reply_to_user_id: Option<i64>,
+    in_reply_to_user_id_str: Option<String>,
+    in_reply_to_screen_name: Option<String>,
+    geo: Option<String>,
+    coordinates: Option<String>,
+    place: Option<String>,
+    contributors: Option<String>,
+    lang: String,
+    */
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct TwitterData {
+    statuses: Vec<Status>,
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn  twitter_from_str(raw_input: *const c_char, raw_input_length: size_t) -> *mut TwitterData {
+  let input = std::str::from_utf8_unchecked(slice::from_raw_parts(raw_input as *const u8, raw_input_length));
+  match serde_json::from_str(&input) {
+    Ok(result) => Box::into_raw(Box::new(result)),
+    Err(_) => std::ptr::null_mut(),
+  }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn str_from_twitter(raw: *mut TwitterData) -> *const c_char {
+  let twitter_thing = { &*raw };
+  let serialized = serde_json::to_string(&twitter_thing).unwrap();
+  return std::ffi::CString::new(serialized.as_str()).unwrap().into_raw()
+}
+
+
+#[no_mangle]
+pub unsafe extern "C" fn free_twitter(raw: *mut TwitterData) {
+  if raw.is_null() {
+    return;
+  }
+
+  drop(Box::from_raw(raw))
+}
+
+
+#[no_mangle]
+pub unsafe extern fn free_string(ptr: *const c_char) {
+    let _ = std::ffi::CString::from_raw(ptr as *mut _);
+}
+
+// Functions associated with the CitmCatalog benchmark
+
+#[derive(Serialize, Deserialize)]
+pub struct Area {
+    pub id: i64,
+    pub name: Option<String>,  // Changed to Option
+    pub parent: i64,
+    #[serde(rename = "childAreas")]
+    pub child_areas: Vec<i64>,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct AudienceSubCategory {
+    pub id: i64,
+    pub name: Option<String>,  // Changed to Option
+    pub parent: i64,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct Event {
+    #[serde(default)]
+    pub description: Option<String>,
+    pub id: i64,
+    #[serde(default)]
+    pub logo: Option<String>,
+    #[serde(default)]
+    pub name: Option<String>,
+    #[serde(default)]
+    pub subTopicIds: Vec<i64>,
+    #[serde(default)]
+    pub subjectCode: Option<String>,
+    #[serde(default)]
+    pub subtitle: Option<String>,
+    #[serde(default)]
+    pub topicIds: Vec<i64>,
+    // Add a catch-all for any other fields
+    #[serde(flatten)]
+    pub extra: HashMap<String, serde_json::Value>,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct Performance {
+    #[serde(default)]
+    pub id: i64,
+
+    #[serde(default)]
+    pub name: Option<String>,
+
+    #[serde(default)]
+    pub event: i64,
+
+    // This is the key fix - accept any JSON value type for timestamps
+    // This allows both string dates and integer timestamps (line 3511)
+    #[serde(default)]
+    pub start: serde_json::Value,
+
+    #[serde(rename = "venueCode")]
+    pub venue_code: String,
+
+    // Add a catch-all for any other fields
+    #[serde(flatten)]
+    pub extra: HashMap<String, serde_json::Value>,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct SeatCategory {
+    pub id: i64,
+    pub name: Option<String>,  // Changed to Option
+    pub areas: Vec<i64>,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct SubTopic {
+    pub id: i64,
+    pub name: Option<String>,  // Changed to Option
+    pub parent: i64,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct Topic {
+    pub id: i64,
+    pub name: Option<String>,  // Changed to Option
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct Venue {
+    pub id: i64,
+    pub name: Option<String>,  // Changed to Option
+    pub address: i64,
+}
+
+// Custom deserializers
+fn deserialize_string_to_area<'de, D>(deserializer: D) -> Result<HashMap<String, Area>, D::Error>
+where D: Deserializer<'de> {
+    let string_map: HashMap<String, String> = HashMap::deserialize(deserializer)?;
+    let mut result = HashMap::new();
+
+    for (id, name) in string_map {
+        let id_num = id.parse::<i64>().unwrap_or(0);
+        result.insert(id.clone(), Area {
+            id: id_num,
+            name: Some(name),
+            parent: 0,
+            child_areas: Vec::new(),
+        });
+    }
+
+    Ok(result)
+}
+
+fn deserialize_string_to_audience_subcategory<'de, D>(deserializer: D) -> Result<HashMap<String, AudienceSubCategory>, D::Error>
+where D: Deserializer<'de> {
+    let string_map: HashMap<String, String> = HashMap::deserialize(deserializer)?;
+    let mut result = HashMap::new();
+
+    for (id, name) in string_map {
+        let id_num = id.parse::<i64>().unwrap_or(0);
+        result.insert(id.clone(), AudienceSubCategory {
+            id: id_num,
+            name: Some(name),
+            parent: 0,
+        });
+    }
+
+    Ok(result)
+}
+
+fn deserialize_string_to_seat_category<'de, D>(deserializer: D) -> Result<HashMap<String, SeatCategory>, D::Error>
+where D: Deserializer<'de> {
+    let string_map: HashMap<String, String> = HashMap::deserialize(deserializer)?;
+    let mut result = HashMap::new();
+
+    for (id, name) in string_map {
+        let id_num = id.parse::<i64>().unwrap_or(0);
+        result.insert(id.clone(), SeatCategory {
+            id: id_num,
+            name: Some(name),
+            areas: Vec::new(),
+        });
+    }
+
+    Ok(result)
+}
+
+fn deserialize_string_to_subtopic<'de, D>(deserializer: D) -> Result<HashMap<String, SubTopic>, D::Error>
+where D: Deserializer<'de> {
+    let string_map: HashMap<String, String> = HashMap::deserialize(deserializer)?;
+    let mut result = HashMap::new();
+
+    for (id, name) in string_map {
+        let id_num = id.parse::<i64>().unwrap_or(0);
+        result.insert(id.clone(), SubTopic {
+            id: id_num,
+            name: Some(name),
+            parent: 0,
+        });
+    }
+
+    Ok(result)
+}
+
+fn deserialize_string_to_topic<'de, D>(deserializer: D) -> Result<HashMap<String, Topic>, D::Error>
+where D: Deserializer<'de> {
+    let string_map: HashMap<String, String> = HashMap::deserialize(deserializer)?;
+    let mut result = HashMap::new();
+
+    for (id, name) in string_map {
+        let id_num = id.parse::<i64>().unwrap_or(0);
+        result.insert(id.clone(), Topic {
+            id: id_num,
+            name: Some(name),
+        });
+    }
+
+    Ok(result)
+}
+
+fn deserialize_string_to_venue<'de, D>(deserializer: D) -> Result<HashMap<String, Venue>, D::Error>
+where D: Deserializer<'de> {
+    let string_map: HashMap<String, String> = HashMap::deserialize(deserializer)?;
+    let mut result = HashMap::new();
+
+    for (id, name) in string_map {
+        result.insert(id.clone(), Venue {
+            id: 0,
+            name: Some(name),
+            address: 0,
+        });
+    }
+
+    Ok(result)
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct CitmCatalog {
+    #[serde(rename = "areaNames")]
+    pub area_names: HashMap<String, String>,
+
+    #[serde(rename = "audienceSubCategoryNames")]
+    pub audience_subcategory_names: HashMap<String, String>,
+
+    #[serde(default)]
+    #[serde(rename = "blockNames")]
+    pub block_names: HashMap<String, String>,
+
+    pub events: HashMap<String, Event>,
+
+    #[serde(default)]
+    pub performances: Vec<Performance>,
+
+    #[serde(rename = "seatCategoryNames")]
+    pub seat_category_names: HashMap<String, String>,
+
+    #[serde(rename = "subTopicNames")]
+    pub subtopic_names: HashMap<String, String>,
+
+    #[serde(default)]
+    #[serde(rename = "subjectNames")]
+    pub subject_names: HashMap<String, String>,
+
+    #[serde(rename = "topicNames")]
+    pub topic_names: HashMap<String, String>,
+
+    #[serde(rename = "topicSubTopics")]
+    pub topic_subtopics: HashMap<String, Vec<i64>>,
+
+    #[serde(rename = "venueNames")]
+    pub venue_names: HashMap<String, String>,
+
+    // Catch-all for other fields
+    #[serde(flatten)]
+    pub extra: HashMap<String, serde_json::Value>,
+}
+
+/// Creates a CitmCatalog from a JSON string (UTF-8 encoded).
+#[no_mangle]
+pub unsafe extern "C" fn citm_from_str(
+    raw_input: *const c_char,
+    raw_input_length: usize
+) -> *mut CitmCatalog {
+    if raw_input.is_null() {
+        eprintln!("Error: Input pointer is null");
+        return ptr::null_mut();
+    }
+
+    // Convert the raw pointer + length into a Rust slice
+    let bytes = slice::from_raw_parts(raw_input as *const u8, raw_input_length);
+    let input_str = match std::str::from_utf8(bytes) {
+        Ok(s) => s,
+        Err(e) => {
+            eprintln!("Error: Invalid UTF-8 string: {}", e);
+            return ptr::null_mut();
+        }
+    };
+
+    // Try deserializing the input string into CitmCatalog
+    match serde_json::from_str::<CitmCatalog>(input_str) {
+        Ok(catalog) => Box::into_raw(Box::new(catalog)),
+        Err(e) => {
+            eprintln!("Error deserializing JSON: {}", e);
+            eprintln!("JSON snippet (first 200 chars): {:.200}...", input_str);
+            ptr::null_mut()
+        }
+    }
+}
+
+/// Serializes a CitmCatalog into a JSON string (UTF-8).
+#[no_mangle]
+pub unsafe extern "C" fn str_from_citm(raw_catalog: *mut CitmCatalog) -> *mut c_char {
+    if raw_catalog.is_null() {
+        eprintln!("Error: Catalog pointer is null");
+        return ptr::null_mut();
+    }
+
+    // Fix: Actually serialize the catalog
+    let catalog = &*raw_catalog;
+
+    match serde_json::to_string(catalog) {
+        Ok(serialized) => {
+            match CString::new(serialized) {
+                Ok(cstr) => cstr.into_raw(),
+                Err(e) => {
+                    eprintln!("Error creating CString: {}", e);
+                    ptr::null_mut()
+                }
+            }
+        },
+        Err(e) => {
+            eprintln!("Error serializing catalog to JSON: {}", e);
+            ptr::null_mut()
+        }
+    }
+}
+
+/// Frees the CitmCatalog pointer.
+#[no_mangle]
+pub unsafe extern "C" fn free_citm(raw_catalog: *mut CitmCatalog) {
+    if !raw_catalog.is_null() {
+        drop(Box::from_raw(raw_catalog));
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn free_str(ptr: *mut c_char) {
+    if !ptr.is_null() {
+        unsafe {
+            // Convert back into a CString, which automatically frees the memory
+            let _ = CString::from_raw(ptr);
+        }
+    }
+}
@@ -0,0 +1,45 @@
+#ifndef serde_benchmark_ffi_h
+#define serde_benchmark_ffi_h
+
+/* Generated with cbindgen:0.28.0 */
+
+/* Warning, this file is autogenerated by cbindgen. Don't modify this manually. */
+
+#include <cstdarg>
+#include <cstdint>
+#include <cstdlib>
+#include <ostream>
+#include <new>
+
+namespace serde_benchmark {
+
+struct CitmCatalog;
+
+struct TwitterData;
+
+extern "C" {
+
+TwitterData *twitter_from_str(const char *raw_input, size_t raw_input_length);
+
+const char *str_from_twitter(TwitterData *raw);
+
+void free_twitter(TwitterData *raw);
+
+void free_string(const char *ptr);
+
+/// Creates a CitmCatalog from a JSON string (UTF-8 encoded).
+CitmCatalog *citm_from_str(const char *raw_input, uintptr_t raw_input_length);
+
+/// Serializes a CitmCatalog into a JSON string (UTF-8).
+char *str_from_citm(CitmCatalog *raw_catalog);
+
+/// Frees the CitmCatalog pointer.
+void free_citm(CitmCatalog *raw_catalog);
+
+void free_str(char *ptr);
+
+}  // extern "C"
+
+}  // namespace serde_benchmark
+
+#endif  // serde_benchmark_ffi_h
@@ -0,0 +1,14 @@
+
+# Add executable targets
+add_executable(benchmark_serialization_twitter benchmark_serialization_twitter.cpp)
+
+ if(TARGET serde-benchmark)
+    message(STATUS "serde-benchmark target was created. Linking benchmarks and serde-benchmark.")
+    target_link_libraries(benchmark_serialization_twitter PRIVATE serde-benchmark)
+    target_compile_definitions(benchmark_serialization_twitter PRIVATE SIMDJSON_RUST_VERSION="${Rust_VERSION}")
+endif()
+target_link_libraries(benchmark_serialization_twitter PRIVATE simdjson::simdjson nlohmann_json)
+target_link_libraries(benchmark_serialization_twitter PRIVATE reflectcpp)
+target_compile_definitions(benchmark_serialization_twitter PRIVATE SIMDJSON_BENCH_CPP_REFLECT=1)
+
+target_compile_definitions(benchmark_serialization_twitter PRIVATE JSON_FILE="${EXAMPLE_JSON}")
@@ -0,0 +1,168 @@
+#include <cassert>
+#include <cstdlib>
+#include <ctime>
+#include <format>
+#include <fstream>
+#include <iostream>
+#include <nlohmann/json.hpp>
+#include <simdjson.h>
+#include <string>
+#include "twitter_data.h"
+#include "nlohmann_twitter_data.h"
+#include "../benchmark_utils/benchmark_helper.h"
+#if SIMDJSON_BENCH_CPP_REFLECT
+#include <rfl.hpp>
+#include <rfl/json.hpp>
+void bench_reflect_cpp(TwitterData &data) {
+  std::string output = rfl::json::write(data);
+  size_t output_volume = output.size();
+  printf("# output volume: %zu bytes\n", output_volume);
+
+  volatile size_t measured_volume = 0;
+  pretty_print(1, output_volume, "bench_reflect_cpp",
+               bench([&data, &measured_volume, &output_volume]() {
+                 std::string output = rfl::json::write(data);
+                 measured_volume = output.size();
+                 if (measured_volume != output_volume) {
+                   printf("mismatch\n");
+                 }
+               }));
+}
+#endif // SIMDJSON_BENCH_CPP_REFLECT
+
+#ifdef SIMDJSON_RUST_VERSION
+#include "../serde-benchmark/serde_benchmark.h"
+
+
+void bench_rust(serde_benchmark::TwitterData *data) {
+  const char * output = serde_benchmark::str_from_twitter(data);
+  size_t output_volume = strlen(output);
+  printf("# output volume: %zu bytes\n", output_volume);
+  volatile size_t measured_volume = 0;
+  pretty_print(1, output_volume, "bench_rust",
+               bench([&data, &measured_volume, &output_volume]() {
+                 const char * output = serde_benchmark::str_from_twitter(data);
+                 serde_benchmark::free_string(output);
+               }));
+}
+#endif
+
+template <class T> void bench_simdjson_static_reflection(T &data) {
+  simdjson::builder::string_builder sb;
+  simdjson::builder::append(sb, data);
+  std::string_view p;
+  if(sb.view().get(p)) {
+    std::cerr << "Error!" << std::endl;
+  }
+  size_t output_volume = p.size();
+  sb.clear();
+  printf("# output volume: %zu bytes\n", output_volume);
+
+  volatile size_t measured_volume = 0;
+  pretty_print(sizeof(data), output_volume, "bench_simdjson_static_reflection",
+               bench([&data, &measured_volume, &output_volume, &sb]() {
+                 sb.clear();
+                 simdjson::builder::append(sb, data);
+                 std::string_view p;
+                 if(sb.view().get(p)) {
+                   std::cerr << "Error!" << std::endl;
+                 }
+                 measured_volume = sb.size();
+                 if (measured_volume != output_volume) {
+                   printf("mismatch\n");
+                 }
+               }));
+}
+
+void bench_nlohmann(TwitterData &data) {
+  std::string output = nlohmann_serialize(data);
+  size_t output_volume = output.size();
+  printf("# output volume: %zu bytes\n", output_volume);
+
+  volatile size_t measured_volume = 0;
+  pretty_print(1, output_volume, "bench_nlohmann",
+               bench([&data, &measured_volume, &output_volume]() {
+                 std::string output = nlohmann_serialize(data);
+                 measured_volume = output.size();
+                 if (measured_volume != output_volume) {
+                   printf("mismatch\n");
+                 }
+               }));
+}
+
+size_t WriteCallback(void *contents, size_t size, size_t nmemb, void *userp) {
+  ((std::string *)userp)->append((char *)contents, size * nmemb);
+  return size * nmemb;
+}
+
+std::string read_file(std::string filename) {
+  printf("# Reading file %s\n", filename.c_str());
+  constexpr size_t read_size = 4096;
+  auto stream = std::ifstream(filename.c_str());
+  stream.exceptions(std::ios_base::badbit);
+  std::string out;
+  std::string buf(read_size, '\0');
+  while (stream.read(&buf[0], read_size)) {
+    out.append(buf, 0, size_t(stream.gcount()));
+  }
+  out.append(buf, 0, size_t(stream.gcount()));
+  return out;
+}
+
+// Function to check if benchmark name contains filter substring
+bool matches_filter(const std::string& benchmark_name, const std::string& filter) {
+  return filter.empty() || benchmark_name.find(filter) != std::string::npos;
+}
+
+int main(int argc, char* argv[]) {
+  std::string filter;
+
+  // Parse command-line arguments
+  for (int i = 1; i < argc; ++i) {
+      if (strcmp(argv[i], "-f") == 0 || strcmp(argv[i], "--filter") == 0) {
+          if (i + 1 < argc) {
+              filter = argv[++i];
+          } else {
+              std::cerr << "Error: -f/--filter requires an argument" << std::endl;
+              return EXIT_FAILURE;
+          }
+      }
+  }
+  // Testing correctness of round-trip (serialization + deserialization)
+  std::string json_str = read_file(JSON_FILE);
+
+  // Loading up the data into a structure.
+  simdjson::ondemand::parser parser;
+  simdjson::ondemand::document doc;
+  if(parser.iterate(simdjson::pad(json_str)).get(doc)) {
+    std::cerr << "Error loading the document!" << std::endl;
+    return EXIT_FAILURE;
+  }
+  TwitterData my_struct;
+  if(doc.get<TwitterData>().get(my_struct)) {
+    std::cerr << "Error loading TwitterData!" << std::endl;
+    return EXIT_FAILURE;
+  }
+
+  // Benchmarking the serialization
+  if (matches_filter("nlohmann", filter)) {
+    bench_nlohmann(my_struct);
+  }
+  if (matches_filter("simdjson_static_reflection", filter)) {
+    bench_simdjson_static_reflection(my_struct);
+  }
+#ifdef SIMDJSON_RUST_VERSION
+  if (matches_filter("rust", filter)) {
+    printf("# WARNING: The Rust benchmark may not be directly comparable since it does not use an equivalent data structure.\n");
+    serde_benchmark::TwitterData * td = serde_benchmark::twitter_from_str(json_str.c_str(), json_str.size());
+    bench_rust(td);
+    serde_benchmark::free_twitter(td);
+  }
+#endif
+#if SIMDJSON_BENCH_CPP_REFLECT
+  if (matches_filter("reflect_cpp", filter)) {
+    bench_reflect_cpp(my_struct);
+  }
+#endif
+  return EXIT_SUCCESS;
+}
@@ -0,0 +1,116 @@
+#ifndef NLOHMANN_TWITTER_DATA_H
+#define NLOHMANN_TWITTER_DATA_H
+
+#include "twitter_data.h"
+#include <nlohmann/json.hpp>
+
+void to_json(nlohmann::json &j, const User &u) {
+  j = nlohmann::json{{"id", u.id},
+                     {"name", u.name},
+                     {"screen_name", u.screen_name},
+                     {"location", u.location},
+                     {"description", u.description},
+                     {"verified", u.verified},
+                     {"followers_count", u.followers_count},
+                     {"friends_count", u.friends_count},
+                     {"statuses_count", u.statuses_count}};
+}
+
+void to_json(nlohmann::json &j, const Hashtag &h) {
+  j = nlohmann::json{{"text", h.text},
+                     {"indices_start", h.indices_start},
+                     {"indices_end", h.indices_end}};
+}
+
+void to_json(nlohmann::json &j, const Url &u) {
+  j = nlohmann::json{{"url", u.url},
+                     {"expanded_url", u.expanded_url},
+                     {"display_url", u.display_url},
+                     {"indices_start", u.indices_start},
+                     {"indices_end", u.indices_end}};
+}
+
+void to_json(nlohmann::json &j, const UserMention &um) {
+  j = nlohmann::json{{"id", um.id},
+                     {"name", um.name},
+                     {"screen_name", um.screen_name},
+                     {"indices_start", um.indices_start},
+                     {"indices_end", um.indices_end}};
+}
+
+void to_json(nlohmann::json &j, const Entities &e) {
+  j = nlohmann::json{{"hashtags", e.hashtags},
+                     {"urls", e.urls},
+                     {"user_mentions", e.user_mentions}};
+}
+
+void to_json(nlohmann::json &j, const Status &s) {
+  j = nlohmann::json{{"created_at", s.created_at},
+                     {"id", s.id},
+                     {"text", s.text},
+                     {"user", s.user},
+                     {"entities", s.entities},
+                     {"retweet_count", s.retweet_count},
+                     {"favorite_count", s.favorite_count},
+                     {"favorited", s.favorited},
+                     {"retweeted", s.retweeted}};
+}
+
+
+std::string nlohmann_serialize(const std::vector<Hashtag>& v) {
+  nlohmann::json a = nlohmann::json::array();
+  for(const Hashtag & h : v) {
+    a.push_back(nlohmann::json{{"text", h.text},
+                     {"indices_start", h.indices_start},
+                     {"indices_end", h.indices_end}});
+  }
+  return a.dump();
+}
+std::string nlohmann_serialize(const std::vector<Url>& v) {
+  nlohmann::json a = nlohmann::json::array();
+  for(const Url & u : v) {
+    a.push_back(nlohmann::json{{"url", u.url},
+                     {"expanded_url", u.expanded_url},
+                     {"display_url", u.display_url},
+                     {"indices_start", u.indices_start},
+                     {"indices_end", u.indices_end}});
+  }
+  return a.dump();
+}
+std::string nlohmann_serialize(const std::vector<UserMention>& v) {
+  nlohmann::json a = nlohmann::json::array();
+  for(const UserMention & um : v) {
+    a.push_back(nlohmann::json{{"id", um.id},
+                     {"name", um.name},
+                     {"screen_name", um.screen_name},
+                     {"indices_start", um.indices_start},
+                     {"indices_end", um.indices_end}});
+  }
+  return a.dump();
+}
+
+std::string nlohmann_serialize(const std::vector<Status>& v) {
+  nlohmann::json a = nlohmann::json::array();
+  for(const Status & s : v) {
+    a.push_back(nlohmann::json{{"created_at", s.created_at},
+                     {"id", s.id},
+                     {"text", s.text},
+                     {"user", s.user},
+                     {"entities", s.entities},
+                     {"retweet_count", s.retweet_count},
+                     {"favorite_count", s.favorite_count},
+                     {"favorited", s.favorited},
+                     {"retweeted", s.retweeted}});
+  }
+  return a.dump();
+}
+
+void to_json(nlohmann::json &j, const TwitterData &t) {
+  j = nlohmann::json{{"statuses", t.statuses}};
+}
+
+std::string nlohmann_serialize(const TwitterData &data) {
+  return nlohmann_serialize(data.statuses);
+}
+
+#endif // NLOHMANN_TWITTER_DATA_H
@@ -0,0 +1,71 @@
+#ifndef TWITTER_DATA_H
+#define TWITTER_DATA_H
+
+#include <string>
+#include <vector>
+
+struct User {
+  int64_t id;
+  std::string id_str;
+  std::string name;
+  std::string screen_name;
+  std::string location;
+  std::string description;
+  bool verified;
+  int64_t followers_count;
+  int64_t friends_count;
+  int64_t statuses_count;
+  bool operator<=>(const User &other) const = default;
+};
+
+struct Hashtag {
+  std::string text;
+  int64_t indices_start;
+  int64_t indices_end;
+  bool operator<=>(const Hashtag &other) const = default;
+};
+
+struct Url {
+  std::string url;
+  std::string expanded_url;
+  std::string display_url;
+  int64_t indices_start;
+  int64_t indices_end;
+  bool operator<=>(const Url &other) const = default;
+};
+
+struct UserMention {
+  int64_t id;
+  std::string name;
+  std::string screen_name;
+  int64_t indices_start;
+  int64_t indices_end;
+  bool operator<=>(const UserMention &other) const = default;
+};
+
+struct Entities {
+  std::vector<Hashtag> hashtags;
+  std::vector<Url> urls;
+  std::vector<UserMention> user_mentions;
+  bool operator==(const Entities &other) const = default;
+};
+
+struct Status {
+  std::string created_at;
+  int64_t id;
+  std::string text;
+  User user;
+  Entities entities;
+  int64_t retweet_count;
+  int64_t favorite_count;
+  bool favorited;
+  bool retweeted;
+  bool operator==(const Status &other) const = default;
+};
+
+struct TwitterData {
+  std::vector<Status> statuses;
+  bool operator==(const TwitterData &other) const = default;
+};
+
+#endif
@@ -0,0 +1,37 @@
+#pragma once
+
+#if SIMDJSON_COMPETITION_BOOSTJSON
+
+#include "top_tweet.h"
+
+namespace top_tweet {
+
+using namespace simdjson;
+
+struct boostjson {
+  using StringType=std::string;
+
+  bool run(simdjson::padded_string &json, int64_t max_retweet_count, top_tweet_result<StringType> &result) {
+    result.retweet_count = -1;
+    boost::json::value top_tweet{};
+
+    auto root = boost::json::parse(json);
+    for (const auto &tweet : root.at("statuses").as_array()) {
+      int64_t retweet_count = tweet.at("retweet_count").as_int64();
+      if (retweet_count <= max_retweet_count && retweet_count >= result.retweet_count) {
+        result.retweet_count = retweet_count;
+        top_tweet = tweet;
+      }
+    }
+
+    result.text = top_tweet.at("text").as_string();
+    result.screen_name = top_tweet.at("user").at("screen_name").as_string();
+    return result.retweet_count != -1;
+  }
+};
+
+BENCHMARK_TEMPLATE(top_tweet, boostjson)->UseManualTime();
+
+} // namespace top_tweet
+
+#endif // SIMDJSON_COMPETITION_BOOSTJSON
@@ -26,8 +26,8 @@ struct nlohmann_json {
      }
    }

-    result.text = top_tweet["text"];
-    result.screen_name = top_tweet["user"]["screen_name"];
+    result.text = to_string(top_tweet["text"]);
+    result.screen_name = to_string(top_tweet["user"]["screen_name"]);
    return result.retweet_count != -1;
  }
 };
@@ -0,0 +1,24 @@
+# SPDX-License-Identifier: MIT
+#
+# SPDX-FileCopyrightText: Copyright (c) 2019-2023 Lars Melchior and contributors
+
+set(CPM_DOWNLOAD_VERSION 0.40.2)
+set(CPM_HASH_SUM "c8cdc32c03816538ce22781ed72964dc864b2a34a310d3b7104812a5ca2d835d")
+
+if(CPM_SOURCE_CACHE)
+  set(CPM_DOWNLOAD_LOCATION "${CPM_SOURCE_CACHE}/cpm/CPM_${CPM_DOWNLOAD_VERSION}.cmake")
+elseif(DEFINED ENV{CPM_SOURCE_CACHE})
+  set(CPM_DOWNLOAD_LOCATION "$ENV{CPM_SOURCE_CACHE}/cpm/CPM_${CPM_DOWNLOAD_VERSION}.cmake")
+else()
+  set(CPM_DOWNLOAD_LOCATION "${CMAKE_BINARY_DIR}/cmake/CPM_${CPM_DOWNLOAD_VERSION}.cmake")
+endif()
+
+# Expand relative path. This is important if the provided path contains a tilde (~)
+get_filename_component(CPM_DOWNLOAD_LOCATION ${CPM_DOWNLOAD_LOCATION} ABSOLUTE)
+
+file(DOWNLOAD
+     https://github.com/cpm-cmake/CPM.cmake/releases/download/v${CPM_DOWNLOAD_VERSION}/CPM.cmake
+     ${CPM_DOWNLOAD_LOCATION} EXPECTED_HASH SHA256=${CPM_HASH_SUM}
+)
+
+include(${CPM_DOWNLOAD_LOCATION})
@@ -2,7 +2,10 @@
 # Flags used by exes and by the simdjson library (project-wide flags)
 #
 add_library(simdjson-internal-flags INTERFACE)
-
+if(NOT DEFINED CMAKE_POSITION_INDEPENDENT_CODE)
+  # We default to ON for all targets, so that we can use the library in shared libraries.
+  set_target_properties(simdjson-internal-flags PROPERTIES POSITION_INDEPENDENT_CODE ON)
+endif(NOT DEFINED CMAKE_POSITION_INDEPENDENT_CODE)

 option(SIMDJSON_CHECK_EOF "Check for the end of the input buffer. The setting is unnecessary since we require padding of the inputs. You should expect tests to fail with this option turned on." OFF)
 if(SIMDJSON_CHECK_EOF)
@@ -52,7 +55,6 @@ endif()

 option(SIMDJSON_SANITIZE_MEMORY "Sanitize memory" OFF)

-
 if(SIMDJSON_SANITIZE_MEMORY)
  message(STATUS "Setting the memory sanitizer.")
  add_compile_options(
@@ -110,14 +112,24 @@ endif()

 # We compile tools, tests, etc. with C++ 17. Override yourself if you need on a
 # target.
-set(SIMDJSON_CXX_STANDARD 17 CACHE STRING "the C++ standard to use for simdjson")
-set(CMAKE_CXX_STANDARD ${SIMDJSON_CXX_STANDARD})
+if(SIMDJSON_STATIC_REFLECTION)
+  # This is temporary.
+  set(SIMDJSON_CXX_STANDARD 26 CACHE STRING "the C++ standard to use for simdjson")
+  #set(CMAKE_CXX_STANDARD ${SIMDJSON_CXX_STANDARD})
+else()
+  set(SIMDJSON_CXX_STANDARD 17 CACHE STRING "the C++ standard to use for simdjson")
+  set(CMAKE_CXX_STANDARD ${SIMDJSON_CXX_STANDARD})
+endif()
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
-set(CMAKE_MACOSX_RPATH OFF)
 set(CMAKE_THREAD_PREFER_PTHREAD ON)
 set(THREADS_PREFER_PTHREAD_FLAG ON)
+set(SIMDJSON_STRUCTURAL_INDEXER_STEP CACHE STRING "the SIMDJSON_STRUCTURAL_INDEXER_STEP variable")

+if(SIMDJSON_STRUCTURAL_INDEXER_STEP)
+  message(STATUS "Setting SIMDJSON_STRUCTURAL_INDEXER_STEP to ${SIMDJSON_STRUCTURAL_INDEXER_STEP}.")
+  add_compile_definitions(SIMDJSON_STRUCTURAL_INDEXER_STEP=${SIMDJSON_STRUCTURAL_INDEXER_STEP})
+endif()
 # LTO seems to create all sorts of fun problems. Let us
 # disable temporarily.
 #include(CheckIPOSupported)
@@ -154,9 +166,6 @@ We recommend Visual Studio 2019 or better on a 64-bit system.")
    add_compile_options(/Zi)
  endif()
 else()
-  if(NOT WIN32)
-    target_compile_options(simdjson-internal-flags INTERFACE -fPIC)
-  endif()
  target_compile_options(
      simdjson-internal-flags INTERFACE
      -Werror -Wall -Wextra -Weffc++ -Wsign-compare -Wshadow -Wwrite-strings
@@ -4,3 +4,4 @@ if("@SIMDJSON_ENABLE_THREADS@")
 endif()

 include("${CMAKE_CURRENT_LIST_DIR}/simdjsonTargets.cmake")
+include("${CMAKE_CURRENT_LIST_DIR}/simdjson_staticTargets.cmake" OPTIONAL)
@@ -1,5 +1,4 @@
 include(CMakeDependentOption)
-include(import.cmake)

 option(SIMDJSON_ALLOW_DOWNLOADS
        "Allow dependencies to be downloaded during configure time"
@@ -8,21 +7,25 @@ option(SIMDJSON_ALLOW_DOWNLOADS
 cmake_dependent_option(SIMDJSON_COMPETITION "Compile competitive benchmarks" ON
        SIMDJSON_ALLOW_DOWNLOADS OFF)
 cmake_dependent_option(SIMDJSON_GOOGLE_BENCHMARKS "compile the Google Benchmark benchmarks" ON
-        SIMDJSON_ALLOW_DOWNLOADS OFF)
+        "SIMDJSON_ALLOW_DOWNLOADS OR MINGW" OFF)

 if(SIMDJSON_GOOGLE_BENCHMARKS)
-  set_off(BENCHMARK_ENABLE_TESTING)
-  set_off(BENCHMARK_ENABLE_INSTALL)
-  set_off(BENCHMARK_ENABLE_WERROR)
-
-  import_dependency(google_benchmarks google/benchmark v1.7.1)
-  add_dependency(google_benchmarks)
+  CPMAddPackage(
+        NAME google_benchmarks
+        URL https://github.com/google/benchmark/archive/refs/tags/v1.9.4.zip
+        OPTIONS
+        "BENCHMARK_ENABLE_TESTING OFF"
+        "BENCHMARK_ENABLE_INSTALL OFF"
+        "BENCHMARK_ENABLE_WERROR OFF"
+  )
 endif()

-# The bulk of our benchmarking and testing data has been moved simdjson/simdjson-data
-import_dependency(simdjson-data simdjson/simdjson-data a5b13babe65c1bba7186b41b43d4cbdc20a5c470)
-add_dependency(simdjson-data)
+CPMAddPackage(
+        NAME simdjson-data
+        URL https://github.com/simdjson/simdjson-data/archive/351949906abde446f0314bf79606fb5d884f5be7.zip
+)

+option(SIMDJSON_USE_BOOST_JSON "Try to include BOOST_JSON, this may break your binaries under some systems." OFF)
 # This prevents variables declared with set() from unnecessarily escaping and
 # should not be called more than once
 function(competition_scope_)
@@ -36,22 +39,32 @@ function(competition_scope_)
 #endif

 int main() {}
-]] USE_BOOST_JSON)
-  if(USE_BOOST_JSON)
-    import_dependency(boostjson boostorg/json ee8d72d)
+]] SIMDJSON_FOUND_STRING_VIEW)
+  if(SIMDJSON_FOUND_STRING_VIEW AND SIMDJSON_USE_BOOST_JSON)
+    CPMAddPackage(
+        NAME boostjson
+        URL https://github.com/boostorg/json/archive/ee8d72d8502b409b5561200299cad30ccdb91415.zip
+    )
    add_library(boostjson STATIC "${boostjson_SOURCE_DIR}/src/src.cpp")
    target_compile_definitions(boostjson PUBLIC BOOST_JSON_STANDALONE)
    target_include_directories(boostjson SYSTEM PUBLIC
            "${boostjson_SOURCE_DIR}/include")
    target_compile_definitions(boostjson INTERFACE SIMDJSON_COMPETITION_BOOSTJSON)
  endif()
-
-  import_dependency(cjson DaveGamble/cJSON c69134d)
+  CPMAddPackage(
+      NAME cjson
+      URL https://github.com/DaveGamble/cJSON/archive/c69134d01746dcf551dd7724b4edb12f922eb0d1.zip
+      DOWNLOAD_ONLY YES
+  )
  add_library(cjson STATIC "${cjson_SOURCE_DIR}/cJSON.c")
  target_include_directories(cjson SYSTEM PUBLIC "${cjson_SOURCE_DIR}")
  target_compile_definitions(cjson INTERFACE SIMDJSON_COMPETITION_CJSON)

-  import_dependency(fastjson mikeando/fastjson 485f994)
+  CPMAddPackage(
+      NAME fastjson
+      URL https://github.com/mikeando/fastjson/archive/485f994a61a64ac73fa6a40d4d639b99b463563b.zip
+      DOWNLOAD_ONLY YES
+  )
  add_library(fastjson STATIC
          "${fastjson_SOURCE_DIR}/src/fastjson.cpp"
          "${fastjson_SOURCE_DIR}/src/fastjson2.cpp"
@@ -60,38 +73,42 @@ int main() {}
          "${fastjson_SOURCE_DIR}/include")
  target_compile_definitions(fastjson INTERFACE SIMDJSON_COMPETITION_FASTJSON)

-  import_dependency(gason vivkin/gason 7aee524)
+  CPMAddPackage(
+      NAME gason
+      URL https://github.com/vivkin/gason/archive/7aee524189da1c1ecd19f67981e3d903dae25470.zip
+      DOWNLOAD_ONLY YES
+  )
  add_library(gason STATIC "${gason_SOURCE_DIR}/src/gason.cpp")
  target_include_directories(gason SYSTEM PUBLIC "${gason_SOURCE_DIR}/src")
  target_compile_definitions(gason INTERFACE SIMDJSON_COMPETITION_GASON)

-  import_dependency(jsmn zserge/jsmn 18e9fe4)
+  CPMAddPackage(
+      NAME jsmn
+      URL https://github.com/zserge/jsmn/archive/18e9fe42cbfe21d65076f5c77ae2be379ad1270f.zip
+      DOWNLOAD_ONLY YES
+  )
  add_library(jsmn STATIC "${jsmn_SOURCE_DIR}/jsmn.c")
  target_include_directories(jsmn SYSTEM PUBLIC "${jsmn_SOURCE_DIR}")
  target_compile_definitions(jsmn INTERFACE SIMDJSON_COMPETITION_JSMN)

-  message(STATUS "Importing json (nlohmann/json@v3.10.5)")
-  set(nlohmann_json_SOURCE_DIR "${dep_root}/json")
-  if(NOT EXISTS "${nlohmann_json_SOURCE_DIR}")
-    file(DOWNLOAD
-            "https://github.com/nlohmann/json/releases/download/v3.10.5/json.hpp"
-            "${nlohmann_json_SOURCE_DIR}/nlohmann/json.hpp")
-  endif()
-  add_library(nlohmann_json INTERFACE)
-  target_include_directories(nlohmann_json SYSTEM INTERFACE "${nlohmann_json_SOURCE_DIR}")
-  target_compile_definitions(nlohmann_json INTERFACE SIMDJSON_COMPETITION_NLOHMANN_JSON)
+  CPMAddPackage(
+      NAME nlohmann_json
+      URL https://github.com/nlohmann/json/archive/refs/tags/v3.12.0.zip
+  )
+
+  set_property(TARGET nlohmann_json APPEND PROPERTY INTERFACE_COMPILE_DEFINITIONS SIMDJSON_COMPETITION_NLOHMANN_JSON)

-  import_dependency(json11 dropbox/json11 ec4e452)
-  add_library(json11 STATIC "${json11_SOURCE_DIR}/json11.cpp")
-  target_include_directories(json11 SYSTEM PUBLIC "${json11_SOURCE_DIR}")
-  target_compile_definitions(json11 INTERFACE SIMDJSON_COMPETITION_JSON11)

  set(jsoncpp_SOURCE_DIR "${simdjson_SOURCE_DIR}/dependencies/jsoncppdist")
  add_library(jsoncpp STATIC "${jsoncpp_SOURCE_DIR}/jsoncpp.cpp")
  target_include_directories(jsoncpp SYSTEM PUBLIC "${jsoncpp_SOURCE_DIR}")
  target_compile_definitions(jsoncpp INTERFACE SIMDJSON_COMPETITION_JSONCPP)

-  import_dependency(rapidjson Tencent/rapidjson f54b0e4)
+  CPMAddPackage(
+      NAME rapidjson
+      URL https://github.com/Tencent/rapidjson/archive/805d7ed5dfe97a39b8b0816fd5eeed8731dc4936.zip
+      DOWNLOAD_ONLY YES
+  )
  add_library(rapidjson INTERFACE)
  target_compile_definitions(rapidjson INTERFACE RAPIDJSON_HAS_STDSTRING)
  include (TestBigEndian)
@@ -104,16 +121,28 @@ int main() {}
  target_compile_definitions(rapidjson INTERFACE RAPIDJSON_HAS_STDSTRING)
  target_include_directories(rapidjson SYSTEM INTERFACE
          "${rapidjson_SOURCE_DIR}/include")
-  target_compile_definitions(rapidjson INTERFACE SIMDJSON_COMPETITION_RAPIDJSON)
+  if (CMAKE_COMPILER_IS_GNUCC AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 14)
+    message(STATUS "Disabling rapidjson")
+  else()
+    target_compile_definitions(rapidjson INTERFACE SIMDJSON_COMPETITION_RAPIDJSON)
+  endif()

-  import_dependency(sajson chadaustin/sajson 2dcfd35)
+  CPMAddPackage(
+      NAME sajson
+      URL https://github.com/chadaustin/sajson/archive/2dcfd350586375f9910f74821d4f07d67ae455ba.zip
+      DOWNLOAD_ONLY YES
+  )
  add_library(sajson INTERFACE)
  target_compile_definitions(sajson INTERFACE SAJSON_UNSORTED_OBJECT_KEYS)
  target_include_directories(sajson SYSTEM INTERFACE
          "${sajson_SOURCE_DIR}/include")
  target_compile_definitions(sajson INTERFACE SIMDJSON_COMPETITION_SAJSON)

-  import_dependency(ujson4c esnme/ujson4c e14f3fd)
+  CPMAddPackage(
+      NAME ujson4c
+      URL https://github.com/esnme/ujson4c/archive/e14f3fd5207fe30d1bdea723f260609e69d1abfa.zip
+      DOWNLOAD_ONLY YES
+  )
  add_library(ujson4c STATIC
          "${ujson4c_SOURCE_DIR}/src/ujdecode.c"
          "${ujson4c_SOURCE_DIR}/3rdparty/ultrajsondec.c")
@@ -122,7 +151,11 @@ int main() {}
          "${ujson4c_SOURCE_DIR}/3rdparty")
  target_compile_definitions(ujson4c INTERFACE SIMDJSON_COMPETITION_UJSON4C)

-  import_dependency(yyjson ibireme/yyjson c385651)
+  CPMAddPackage(
+      NAME yyjson
+      URL https://github.com/ibireme/yyjson/archive/c3856514de0a67d7b66939bf3ed491a2d6e61277.zip
+      DOWNLOAD_ONLY YES
+  )
  add_library(yyjson STATIC "${yyjson_SOURCE_DIR}/src/yyjson.c")
  target_include_directories(yyjson SYSTEM PUBLIC "${yyjson_SOURCE_DIR}/src")
  target_compile_definitions(yyjson INTERFACE SIMDJSON_COMPETITION_YYJSON)
@@ -130,13 +163,13 @@ int main() {}
  add_library(competition-core INTERFACE)
  target_link_libraries(competition-core INTERFACE nlohmann_json rapidjson sajson cjson jsmn yyjson)

-  if(USE_BOOST_JSON)
+  if(TARGET boostjson)
     target_compile_definitions(boostjson INTERFACE HAS_BOOST_JSON)
     target_link_libraries(competition-core INTERFACE boostjson)
  endif()

  add_library(competition-all INTERFACE)
-  target_link_libraries(competition-all INTERFACE competition-core jsoncpp json11 fastjson gason ujson4c)
+  target_link_libraries(competition-all INTERFACE competition-core jsoncpp fastjson gason ujson4c)
 endfunction()

 if(SIMDJSON_COMPETITION)
@@ -147,10 +180,12 @@ cmake_dependent_option(SIMDJSON_CXXOPTS "Download cxxopts (necessary for tools)"
        SIMDJSON_ALLOW_DOWNLOADS OFF)

 if(SIMDJSON_CXXOPTS)
-  set_off(CXXOPTS_BUILD_EXAMPLES)
-  set_off(CXXOPTS_BUILD_TESTS)
-  set_off(CXXOPTS_ENABLE_INSTALL)
-
-  import_dependency(cxxopts jarro2783/cxxopts 794c975)
-  add_dependency(cxxopts)
+  CPMAddPackage(
+        NAME cxxopts
+        URL https://github.com/jarro2783/cxxopts/archive/59656709c0c58fcd0ed18b38e02938dbe05284c5.zip
+        OPTIONS
+        "CXXOPTS_BUILD_EXAMPLES OFF"
+        "CXXOPTS_BUILD_TESTS OFF"
+        "CXXOPTS_ENABLE_INSTALL OFF"
+  )
 endif()
@@ -1,48 +0,0 @@
-set(dep_root "${simdjson_SOURCE_DIR}/dependencies/.cache")
-if(DEFINED ENV{simdjson_DEPENDENCY_CACHE_DIR})
-  set(dep_root "$ENV{simdjson_DEPENDENCY_CACHE_DIR}")
-endif()
-
-function(import_dependency NAME GITHUB_REPO COMMIT)
-  message(STATUS "Importing ${NAME} (${GITHUB_REPO}@${COMMIT})")
-  set(target "${dep_root}/${NAME}")
-
-  # If the folder exists in the cache, then we assume that everything is as
-  # should be and do nothing
-  if(EXISTS "${target}")
-    set("${NAME}_SOURCE_DIR" "${target}" PARENT_SCOPE)
-    return()
-  endif()
-
-  set(zip_url "https://github.com/${GITHUB_REPO}/archive/${COMMIT}.zip")
-  set(archive "${dep_root}/archive.zip")
-  set(dest "${dep_root}/_extract")
-
-  file(DOWNLOAD "${zip_url}" "${archive}")
-  file(MAKE_DIRECTORY "${dest}")
-  execute_process(
-          WORKING_DIRECTORY "${dest}"
-          COMMAND "${CMAKE_COMMAND}" -E tar xf "${archive}")
-  file(REMOVE "${archive}")
-
-  # GitHub archives only ever have one folder component at the root, so this
-  # will always match that single folder
-  file(GLOB dir LIST_DIRECTORIES YES "${dest}/*")
-
-  file(RENAME "${dir}" "${target}")
-
-  set("${NAME}_SOURCE_DIR" "${target}" PARENT_SCOPE)
-endfunction()
-
-# Delegates to the dependency
-macro(add_dependency NAME)
-  if(NOT DEFINED "${NAME}_SOURCE_DIR")
-    message(FATAL_ERROR "Missing ${NAME}_SOURCE_DIR variable")
-  endif()
-
-  add_subdirectory("${${NAME}_SOURCE_DIR}" "${PROJECT_BINARY_DIR}/_deps/${NAME}" EXCLUDE_FROM_ALL)
-endmacro()
-
-function(set_off NAME)
-  set("${NAME}" OFF CACHE INTERNAL "")
-endfunction()
@@ -0,0 +1,132 @@
+Builder
+==========
+
+Sometimes you want to generate JSON string outputs efficiently.
+The simdjson library provides high-performance low-level facilities.
+When using these low-level functionalities, you are responsible to
+define the structure of your JSON document. However, string escaping
+and UTF-8 validation is automated.
+
+Overview: string_builder
+---------------------------
+
+The string_builder class is a low-level utility for constructing JSON strings representing documents. It is optimized for performance, potentially leveraging kernel-specific features like SIMD instructions for tasks such as string escaping. This class supports atomic types (e.g., booleans, numbers, strings) but does not handle composed types directly (like arrays or objects).
+
+An `string_builder` is created with an initial buffer capacity (e.g., 1kB). The memory
+is reallocated when needed. It has the following methods to add content to the string:
+
+
+- `append(number_type v)`: Appends a number (including booleans) to the JSON buffer. Booleans are converted to the strings "false" or "true". Numbers are formatted according to the JSON standard, with floating-point numbers using the shortest representation that accurately reflects the value.
+- `append(char c)`: Appends a single character to the JSON buffer.
+- `append_null()`: Appends the string "null" to the JSON buffer.
+- `clear()`: Clears the contents of the JSON buffer, resetting the position to 0 while retaining the allocated capacity.
+- `escape_and_append(std::string_view input)`: Appends a string view to the JSON buffer after escaping special characters (e.g., quotes, backslashes) as required by JSON.
+- `escape_and_append_with_quotes(std::string_view input)` Appends a string view surrounded by double quotes (e.g., "input") to the JSON buffer after escaping special characters.
+Parameters:
+- `escape_and_append_with_quotes(char input)`: Appends a single character surrounded by double quotes (e.g., "c") to the JSON buffer after escaping it if necessary.
+- `append_raw(const char *c)`: Appends a null-terminated C string directly to the JSON buffer without escaping.
+- `append_raw(std::string_view input)`: Appends a string view directly to the JSON buffer without escaping.
+- `append_raw(const char *str, size_t len)`: Appends a specified number of characters from a C string directly to the JSON
+
+After writting the content, if you have reasons to believe that the content might violate UTF-8 conventions, you can check it as follows:
+
+- `validate_unicode()`: Checks if the content in the JSON buffer is valid UTF-8. Returns: true if the content is valid UTF-8, false otherwise.
+
+Once you are satisfied, you can recover the string as follows:
+
+- `operator std::string()`: Converts the JSON buffer to an std::string. (Might throw if an error occurred.)
+- `operator std::string_view()`: Converts the JSON buffer to an std::string_view.  (Might throw if an error occurred.)
+- `view()`: Returns a view of the written JSON buffer as a `simdjson_result<std::string_view>`.
+
+The later method (`view()`) is recommended.
+
+Example: string_builder
+---------------------------
+
+```C++
+
+    void serialize_car(const Car& car, simdjson::builder::string_builder& builder) {
+        // start of JSON
+        builder.start_object();
+
+        // "make"
+        builder.append_key_value("make", car.make);
+        builder.append_comma();
+
+        // "model"
+        builder.append_key_value("model", car.model);
+        builder.append_comma();
+
+        // "year"
+        builder.append_key_value("year", car.year);
+        builder.append_comma();
+
+        // "tire_pressure"
+        builder.escape_and_append_with_quotes("tire_pressure");
+        builder.append_colon();
+        builder.start_array();
+        // vector tire_pressure
+        for (size_t i = 0; i < car.tire_pressure.size(); ++i) {
+            builder.append(car.tire_pressure[i]);
+            if (i < car.tire_pressure.size() - 1) {
+                builder.append_comma();
+            }
+        }
+        builder.end_array();
+        builder.end_object();
+    }
+
+    bool car_test() {
+        simdjson::builder::string_builder sb;
+        Car c = {"Toyota", "Corolla", 2017, {30.0,30.2,30.513,30.79}};
+        serialize_car(c, sb);
+        std::string_view p;
+        if(sb.view().get(p)) {
+            return false; // there was an error
+        }
+        // p holds the JSON:
+        // "{\"make\":\"Toyota\",\"model\":\"Corolla\",\"year\":2017,\"tire_pressure\":[30.0,30.2,30.513,30.79]}"
+        return true;
+    }
+```
+
+C++26 static reflection
+------------------------
+
+If you have a compiler with support C++26 static reflection, you can compile
+your code with the `SIMDJSON_STATIC_REFLECTION` macro set:
+
+```cpp
+#define SIMDJSON_STATIC_REFLECTION 1
+//...
+#include "simdjson.h"
+```
+
+And then you can append your data structures to a `string_builder` instance
+automatically. In most cases, it should work automatically:
+
+```cpp
+    bool car_test() {
+        simdjson::builder::string_builder sb;
+        Car c = {"Toyota", "Corolla", 2017, {30.0,30.2,30.513,30.79}};
+        append(sb, c);
+        std::string_view p;
+        if(sb.view().get(p)) {
+            return false; // there was an error
+        }
+        // p holds the JSON:
+        // "{\"make\":\"Toyota\",\"model\":\"Corolla\",\"year\":2017,\"tire_pressure\":[30.0,30.2,30.513,30.79]}"
+        return true;
+    }
+```
+
+If you prefer, you can also create a string directly:
+
+```cpp
+  std::string json;
+  if(simdjson::builder::to_json_string(c).get(json)) {
+    // there was an error
+  } else {
+    // json contain the serialized JSON
+  }
+```
@@ -3,11 +3,13 @@ The Document-Object-Model (DOM) front-end

 An overview of what you need to know to use simdjson, with examples.

-* [DOM vs On Demand](#dom-vs-on-demand)
+* [DOM vs On-Demand](#dom-vs-on-demand)
 * [The Basics: Loading and Parsing JSON Documents](#the-basics-loading-and-parsing-json-documents-using-the-dom-front-end)
 * [Using the Parsed JSON](#using-the-parsed-json)
 * [C++17 Support](#c17-support)
+* [C++20 Support](#c20-support)
 * [JSON Pointer](#json-pointer)
+* [JSONPath](#jsonpath)
 * [Error Handling](#error-handling)
  * [Error Handling Example](#error-handling-example)
  * [Exceptions](#exceptions)
@@ -18,7 +20,7 @@ An overview of what you need to know to use simdjson, with examples.
 * [Padding and Temporary Copies](#padding-and-temporary-copies)
 * [Performance Tips](#performance-tips)

-DOM vs On Demand
+DOM vs On-Demand
 ----------------------------------------------

 The simdjson library offers two distinct approaches on how to access a JSON document. We support
@@ -59,6 +61,26 @@ std::string data = "my data";
 simdjson::padded_string my_padded_data(data); // copies to a padded buffer
 ```

+You can then parse the JSON document from the `simdjson::padded_string` instance:
+
+```cpp
+simdjson::dom::parser parser;
+simdjson::dom::element doc = parser.parse(my_padded_data);
+```
+
+Whenever you pass an `std::string` reference to `parser::parse`,
+the parser will access the bytes beyond the end of
+the string but before the end of the allocated memory (`std::string::capacity()`).
+If you are using a sanitizer that checks for reading uninitialized bytes or `std::string`'s
+container-overflow checks, you may encounter sanitizer warnings.
+You can safely ignore these warnings. Or you can call `simdjson::pad(std::string&)` to pad the
+string with `SIMDJSON_PADDING` spaces: this function returns a `simdjson::padding_string_view` which can be be passed to the parser's iterator function:
+
+```c++
+std::string json = "[1]";
+dom::element doc = parser.parse(simdjson::pad(json));
+```
+
 The parsed document resulting from the `parser.load` and `parser.parse` calls depends on the `parser` instance. Thus the `parser` instance must remain in scope. Furthermore, you must have at most one parsed document in play per `parser` instance.
 You cannot copy a `parser` instance, you may only move it.

@@ -69,8 +91,14 @@ During the`load` or `parse` calls, neither the input file nor the input string a
 For best performance, a `parser` instance should be reused over several files: otherwise you will needlessly reallocate memory, an expensive process. It is also possible to avoid entirely memory allocations during parsing when using simdjson. [See our performance notes for details](performance.md).

 If you need a lower-level interface, you may call the function `parser.parse(const char * p, size_t l)` on a pointer `p` while specifying the
-length of your input `l` in bytes. To see how to get the very best performance from a low-level approach, you way want to read our [performance notes](https://github.com/simdjson/simdjson/blob/master/doc/performance.md#padding-and-temporary-copies) on this topic (see the Padding and Temporary Copies section).
+length of your input `l` in bytes.

+*Windows-specific*:  Windows users who need to read files with
+non-ANSI characters in the name should set their code page to
+UTF-8 (65001). This should be the default with Windows 11 and better.
+Further, they may use the AreFileApisANSI function to determine whether
+the filename is interpreted using the ANSI or the system default OEM
+codepage, and they may call SetFileApisToOEM accordingly.

 Using the Parsed JSON
 ---------------------
@@ -92,6 +120,12 @@ Once you have an element, you can navigate it with idiomatic C++ iterators, oper
  std::cout << "I parsed " << value << " from " << numberstring.data() << std::endl;
  ```
  The strings contain unescaped valid UTF-8 strings: no unmatched surrogate is allowed.
+  Internally, numbers are stored as either 64-bit integers or 64-bit floating-point numbers.
+  Thus it is possible to get the full 64-bit integer range (either signed or  unsigned).
+  By default, the string `-0` is parsed as the integer 0 as in Pytho or C++. If you set the macro
+  `SIMDJSON_MINUS_ZERO_AS_FLOAT` to `1` when building simdjson, you can get that `-0` is mapped to `-0.0`
+  as in JavaScript. You can get the desired effect by building simdjson with cmake setting the
+  `SIMDJSON_MINUS_ZERO_AS_FLOAT` to on: `cmake -B build -D SIMDJSON_MINUS_ZERO_AS_FLOAT=ON`.
 * **Field Access:** To get the value of the "foo" field in an object, use `object["foo"]`.
 * **Array Iteration:** To iterate through an array, use `for (auto value : array) { ... }`. If you
  know the type of the value, you can cast it right there, too! `for (double value : array) { ... }`
@@ -105,7 +139,7 @@ Once you have an element, you can navigate it with idiomatic C++ iterators, oper
  with the `size()` method.
 * **Checking an Element Type:** You can check an element's type with `element.type()`. It
  returns an `element_type` with values such as `simdjson::dom::element_type::ARRAY`, `simdjson::dom::element_type::OBJECT`, `simdjson::dom::element_type::INT64`,  `simdjson::dom::element_type::UINT64`,`simdjson::dom::element_type::DOUBLE`, `simdjson::dom::element_type::STRING`, `simdjson::dom::element_type::BOOL` or, `simdjson::dom::element_type::NULL_VALUE`.
-* **Output to streams and strings:** Given a document or an element (or node) out of a JSON document, you can output a minified string version using the C++ stream idiom (`out << element`). You can also request the construction of a minified string version (`simdjson::minify(element)`). Numbers are serialized as 64-bit floating-point numbers (`double`).
+* **Output to streams and strings:** Given a document or an element (or node) out of a JSON document, you can output a minified string version using the C++ stream idiom (`out << element`). You can also request the construction of a minified string version (`simdjson::minify(element)`) or a prettified string version (`simdjson::prettify(element)`). Numbers are serialized as 64-bit floating-point numbers (`double`).

 ### Examples

@@ -205,6 +239,23 @@ for (dom::key_value_pair field : object) {
 }
 ```

+C++20 Support
+------------
+
+simdjson library also supports some C++20 feature including `std::ranges`:
+
+```c++
+auto cars_json = R"( [
+  { "make": "Toyota", "model": "Camry",  "year": 2018, "tire_pressure": [ 40.1, 39.9, 37.7, 40.4 ] },
+  { "make": "Kia",    "model": "Soul",   "year": 2012, "tire_pressure": [ 30.1, 31.0, 28.6, 28.7 ] },
+  { "make": "Toyota", "model": "Tercel", "year": 1999, "tire_pressure": [ 29.8, 30.0, 30.2, 30.5 ] }
+] )"_padded;
+dom::parser parser;
+auto justmodel = [](auto car) { return car["model"]; };
+for (auto car : parser.parse(cars_json).get_array() | std::views::transform(justmodel)) {
+  std::cout << car << std::endl;
+}
+```

 JSON Pointer
 ------------
@@ -223,13 +274,13 @@ dom::element cars = parser.parse(cars_json);
 cout << cars.at_pointer("/0/tire_pressure/1") << endl; // Prints 39.9
 ```

-A JSON Path is a sequence of segments each starting with the '/' character. Within arrays, an integer
+A JSON Pointer expression is a sequence of segments each starting with the '/' character. Within arrays, an integer
 index allows you to select the indexed node. Within objects, the string value of the key allows you to
 select the value. If your keys contain the characters '/' or '~', they must be escaped as '~1' and
-'~0' respectively. An empty JSON Path refers to the whole document.
+'~0' respectively. An empty JSON Pointer expression refers to the whole document.

 We also extend the JSON Pointer support to include *relative* paths.
-You can apply a JSON path to any node and the path gets interpreted relatively, as if the current node were a whole JSON document.
+You can apply a JSON Pointer expression to any node and the path gets interpreted relatively, as if the current node were a whole JSON document.

 Consider the following example:

@@ -251,6 +302,49 @@ for (dom::element car_element : cars) {
 }
 ```

+JSONPath
+------------
+
+
+The simdjson library supports a subset of [JSONPath](https://datatracker.ietf.org/doc/html/draft-normington-jsonpath-00) through the `at_path()` method, allowing you to reach further into the document in a single call. The subset of JSONPath that is implemented is the subset that is trivially convertible into the JSON Pointer format, using `.` to access a field and `[]` to access a specific index.
+
+Consider the following example:
+
+```c++
+auto cars_json = R"( [
+  { "make": "Toyota", "model": "Camry",  "year": 2018, "tire_pressure": [ 40.1, 39.9, 37.7, 40.4 ] },
+  { "make": "Kia",    "model": "Soul",   "year": 2012, "tire_pressure": [ 30.1, 31.0, 28.6, 28.7 ] },
+  { "make": "Toyota", "model": "Tercel", "year": 1999, "tire_pressure": [ 29.8, 30.0, 30.2, 30.5 ] }
+] )"_padded;
+dom::parser parser;
+dom::element doc;
+auto error = parser.parse(cars_json).get(doc);
+if(error) { /*won't happen*/ }
+double p;
+error = doc.at_path("[0].tire_pressure[1]").get(p);
+if(error) { /*won't happen*/ }
+cout << p << endl; // Prints 39.9
+```
+
+
+We also support the `$` prefix. When you start a JSONPath expression with $, you are indicating that the path starts from the root of the JSON document. E.g.,
+
+```c++
+auto json = R"( { "c" :{ "foo": { "a": [ 10, 20, 30 ] }}, "d": { "foo2": { "a": [ 10, 20, 30 ] }} , "e": 120 })"_padded;
+dom::parser parser;
+dom::element doc;
+auto error = parser.parse(json).get(doc);
+if(error) { /*won't happen*/ }
+dom::object obj;
+error = doc.get_object().get(obj);
+if(error) { /*won't happen*/ }
+int64_t x;
+error = obj.at_path("$[3].foo.a[1]").get(x);
+if(error) { /*won't happen*/ }
+if(x != 20) { /*won't happen*/ }
+x = obj.at_path("$.d.foo2.a.2");
+if(error) { /*won't happen*/ }
+```


 Error Handling
@@ -329,10 +423,10 @@ int main(void) {
  simdjson::dom::parser parser;
  simdjson::dom::element tweets; // invalid until the get() succeeds
  auto error = parser.load("twitter.json").get(tweets);
-  if(error) { std::cerr << error << std::endl; return EXIT_FAILURE; }
+  if (error) { std::cerr << error << std::endl; return EXIT_FAILURE; }
  uint64_t identifier;
  error = tweets["statuses"].at(0)["id"].get(identifier);
-  if(error) { std::cerr << error << std::endl; return EXIT_FAILURE; }
+  if (error) { std::cerr << error << std::endl; return EXIT_FAILURE; }
  std::cout << identifier << std::endl;
  return EXIT_SUCCESS;
 }
@@ -663,5 +757,5 @@ Setting the `realloc_if_needed` parameter `false` in this manner may lead to bet
 Performance Tips
 ---------------------

- For release builds, we recommend setting `NDEBUG` pre-processor directive when compiling the `simdjson` library. Importantly, using the optimization flags `-O2` or `-O3` under GCC and LLVM clang does not set the `NDEBUG` directrive, you must set it manually (e.g., `-DNDEBUG`).
+- For release builds, we recommend setting `NDEBUG` pre-processor directive when compiling the `simdjson` library. Importantly, using the optimization flags `-O2` or `-O3` under GCC and LLVM clang does not set the `NDEBUG` directive, you must set it manually (e.g., `-DNDEBUG`).
 - For long streams of JSON documents, consider [`iterate_many`](iterate_many.md) and [`parse_many`](parse_many.md) for better performance.
--- a/Show More
+++ b/Show More