version bump.

* add get_int32() and get_uint32() to the On Demand API

Add convenience methods that call get_int64()/get_uint64() and
range-check the result, returning NUMBER_OUT_OF_RANGE on overflow.

Added to value, document, document_reference, and their
simdjson_result wrappers.

Closes #1890

* fix document_reference streaming for get_int32/get_uint32

The document_reference getters delegated to document::get_int32/get_uint32
which call get_root_int64/get_root_uint64 with allow_trailing_content=true,
rejecting the next document in a stream as trailing content.

Call get_root_value_iterator().get_root_int64/get_root_uint64(false) directly
to allow trailing content, matching get_int64/get_uint64.

Add streaming tests for both getters.

* add get_int32/get_uint32 to basics.md

* add get_int32/get_uint32 to wrong-type error tests

* add get<uint32_t>/get<int32_t> template specializations

Wire the 32-bit getters into the generic get<T>() and get(T&)
dispatch so that doc.get<uint32_t>() compiles on C++11/14/17
without requiring the C++20 concepts path in std_deserialize.h.

.github/ISSUE_TEMPLATE/bug_report.md

@@ -29,6 +29,9 @@ We accept the identification of an issue by a sanitizer or some checker tool (e.
 
 We recommend that you run your tests using different optimization levels. In particular, we recommend your run tests with the simdjson library and you code compiled in debug mode. The simdjson then sets the SIMDJSON_DEVELOPMENT_CHECKS macro to 1, and this triggers additional checks on your code and on the internals of the library. If possible, we recommend that you run tests with sanitizers (e.g., see [No more leaks with sanitize flags in gcc and clang](https://lemire.me/blog/2016/04/20/no-more-leaks-with-sanitize-flags-in-gcc-and-clang/)).  You can compile the library with sanitizers for debugging purposes (e.g., set SIMDJSON_SANITIZE to ON using CMake), but you should also turn on sanitizers on your own code. You may also use tools like valgrind or the commercial equivalent.
 
+Mixing debug and release simdjson code is unsafe: you either build all your code using simdjson in
+release mode or all of it in debug mode.
+
 Before reporting a bug, please ensure that you have read our documentation.
 
 **To Reproduce**
@@ -55,6 +58,7 @@ We support up-to-date 64-bit ARM and x64 FreeBSD, macOS, Windows and Linux syste
 * 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.
+* Vendors (e.g., Apple and Microsoft) stop supporting old systems. Once a compiler system is no longer supported by its vendor, we no longer support it. We will gladly accept code contributions, but we do not consider it a *bug* if you have issues with an obsolete compiler systems. This policy extends to obsolete standard libraries, linkers and other build tools. Please do not report it as an issue. If you cannot resolve the issue yourself, we encourage you to reach out to the vendor for legacy support.
 
 Under Windows, we support Visual Studio (both with LLVM and without). We do not support MinGW and other alternate compiler systems. Windows users should be aware that there [is a long-running bug with GCC under Windows](https://gcc.gnu.org/bugzilla/show_bug.cgi?id=54412).
 

.github/pull_request_template.md

@@ -20,7 +20,7 @@ How to verify / test
 Please read before contributing:
 - CONTRIBUTING: https://github.com/simdjson/simdjson/blob/master/CONTRIBUTING.md
 - HACKING: https://github.com/simdjson/simdjson/blob/master/HACKING.md
-
+- AI Usage Policy: https://github.com/simdjson/simdjson/blob/master/AI_USAGE_POLICY.md
 
 
 If you can, we recommend running our tests with the sanitizers turned on.

.github/workflows/rvv-1024-clang-18.yml

@@ -19,11 +19,11 @@ jobs:
         sudo apt-get install -y cmake make g++-riscv64-linux-gnu qemu-user-static clang-18
     - name: Build
       run: |
-        CXX=clang++-18 CXXFLAGS="--target=riscv64-linux-gnu -march=rv64gcv_zvbb" \
-        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DCMAKE_BUILD_TYPE=Release -B build
-        cmake --build build/ -j$(nproc)
+        CC=clang-18 CXX=clang++-18 CFLAGS="--target=riscv64-linux-gnu -march=rv64gcv_zvbb" CXXFLAGS="${CFLAGS}" \
+        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DSIMDJSON_DEVELOPER_MODE=ON -B build
+        cmake --build build/ -j$(nproc) --config Release
     - name: Test VLEN=1024
       run: |
-        export QEMU_LD_PREFIX="/usr/riscv64-linux-gnu"
-        export QEMU_CPU="rv64,v=on,zvbb=on,vlen=1024,rvv_ta_all_1s=on,rvv_ma_all_1s=on"
+        QEMU_LD_PREFIX="/usr/riscv64-linux-gnu" \
+        QEMU_CPU="rv64,v=on,zvbb=on,vlen=1024,rvv_ta_all_1s=on,rvv_ma_all_1s=on" \
         ctest --timeout 1800 --output-on-failure --test-dir build -j $(nproc)

.github/workflows/rvv-128-clang-17.yml

@@ -19,11 +19,6 @@ jobs:
         sudo apt-get install -y cmake make g++-riscv64-linux-gnu qemu-user-static clang-17
     - name: Build
       run: |
-        CXX=clang++-17 CXXFLAGS="--target=riscv64-linux-gnu -march=rv64gcv" \
-        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DCMAKE_BUILD_TYPE=Release -B build
-        cmake --build build/ -j$(nproc)
-    - name: Test VLEN=128
-      run: |
-        export QEMU_LD_PREFIX="/usr/riscv64-linux-gnu"
-        export QEMU_CPU="rv64,v=on,vlen=128,rvv_ta_all_1s=on,rvv_ma_all_1s=on"
-        ctest --timeout 1800 --output-on-failure --test-dir build -j $(nproc)
+        CC=clang-17 CXX=clang++-17 CFLAGS="--target=riscv64-linux-gnu -march=rv64gcv" CXXFLAGS="${CFLAGS}" \
+        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DSIMDJSON_DEVELOPER_MODE=ON -B build
+        cmake --build build/ -j$(nproc) --config Release

.github/workflows/rvv-128-clang-20.yml

@@ -0,0 +1,39 @@
+name: Ubuntu rvv VLEN=128 (clang 20)
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  build:
+    runs-on: ubuntu-24.04
+    steps:
+    - uses: actions/checkout@v4
+    - name: Install packages
+      run: |
+        sudo apt-get update -q -y
+        sudo apt-get install -y cmake make g++-riscv64-linux-gnu qemu-user-static clang-20
+    - name: Build
+      run: |
+        CC=clang-20 CXX=clang++-20 CFLAGS="--target=riscv64-linux-gnu -march=rv64gcv" CXXFLAGS="${CFLAGS}" \
+        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DSIMDJSON_DEVELOPER_MODE=ON -B build
+        cmake --build build/ -j$(nproc) --config Release
+    - name: Test VLEN=128
+      run: |
+        QEMU_LD_PREFIX="/usr/riscv64-linux-gnu" \
+        QEMU_CPU="rv64,v=on,vlen=128,rvv_ta_all_1s=on,rvv_ma_all_1s=on" \
+        ctest --timeout 1800 --output-on-failure --test-dir build -j $(nproc)
+    - name: Build VLS
+      run: |
+        CC=clang-20 CXX=clang++-20 CFLAGS="--target=riscv64-linux-gnu -march=rv64gcv_zvl128b_zba_zbb_zbc -mrvv-vector-bits=zvl" CXXFLAGS="${CFLAGS}" \
+        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DSIMDJSON_DEVELOPER_MODE=ON -B build-vls
+        cmake --build build-vls/ -j$(nproc) --config Release
+    - name: Test VLEN=128 VLS
+      run: |
+        QEMU_LD_PREFIX="/usr/riscv64-linux-gnu" \
+        QEMU_CPU="rv64,v=on,zba=on,zbb=on,zbc=on,vlen=128,rvv_ta_all_1s=on,rvv_ma_all_1s=on" \
+        ctest --timeout 1800 --output-on-failure --test-dir build-vls -j $(nproc)

.github/workflows/rvv-256-gcc-14.yml

@@ -19,11 +19,21 @@ jobs:
         sudo apt-get install -y cmake make g++-14-riscv64-linux-gnu qemu-user-static
     - name: Build
       run: |
-        CXX=riscv64-linux-gnu-g++-14 CXXFLAGS=-march=rv64gcv \
-        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DCMAKE_BUILD_TYPE=Release -B build
-        cmake --build build/ -j$(nproc)
+        CC=riscv64-linux-gnu-gcc-14 CXX=riscv64-linux-gnu-g++-14 CFLAGS=-march=rv64gcv CXXFLAGS="${CFLAGS}" \
+        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DSIMDJSON_DEVELOPER_MODE=ON -B build
+        cmake --build build/ -j$(nproc) --config Release
     - name: Test VLEN=256
       run: |
-        export QEMU_LD_PREFIX="/usr/riscv64-linux-gnu"
-        export QEMU_CPU="rv64,v=on,zvbb=on,vlen=256,rvv_ta_all_1s=on,rvv_ma_all_1s=on"
+        QEMU_LD_PREFIX="/usr/riscv64-linux-gnu" \
+        QEMU_CPU="rv64,v=on,zvbb=on,vlen=256,rvv_ta_all_1s=on,rvv_ma_all_1s=on" \
         ctest --timeout 1800 --output-on-failure --test-dir build -j $(nproc)
+    - name: Build VLS
+      run: |
+        CC=riscv64-linux-gnu-gcc-14 CXX=riscv64-linux-gnu-g++-14 CFLAGS="-march=rv64gcv_zvl256b -mrvv-vector-bits=zvl" CXXFLAGS="${CFLAGS}" \
+        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DSIMDJSON_DEVELOPER_MODE=ON -B build-vls
+        cmake --build build-vls/ -j$(nproc) --config Release
+    - name: Test VLEN=256 VLS
+      run: |
+        QEMU_LD_PREFIX="/usr/riscv64-linux-gnu" \
+        QEMU_CPU="rv64,v=on,zvbb=on,vlen=256,rvv_ta_all_1s=on,rvv_ma_all_1s=on" \
+        ctest --timeout 1800 --output-on-failure --test-dir build-vls -j $(nproc)

.github/workflows/rvv-512-clang-19.yml

@@ -0,0 +1,39 @@
+name: Ubuntu rvv VLEN=512 (clang 19)
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  build:
+    runs-on: ubuntu-24.04
+    steps:
+    - uses: actions/checkout@v4
+    - name: Install packages
+      run: |
+        sudo apt-get update -q -y
+        sudo apt-get install -y cmake make g++-riscv64-linux-gnu qemu-user-static clang-19
+    - name: Build
+      run: |
+        CC=clang-19 CXX=clang++-19 CFLAGS="--target=riscv64-linux-gnu -march=rv64gcv" CXXFLAGS="${CFLAGS}" \
+        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DSIMDJSON_DEVELOPER_MODE=ON -B build
+        cmake --build build/ -j$(nproc) --config Release
+    - name: Test VLEN=512
+      run: |
+        QEMU_LD_PREFIX="/usr/riscv64-linux-gnu" \
+        QEMU_CPU="rv64,v=on,vlen=512,rvv_ta_all_1s=on,rvv_ma_all_1s=on" \
+        ctest --timeout 1800 --output-on-failure --test-dir build -j $(nproc)
+    - name: Build VLS
+      run: |
+        CC=clang-19 CXX=clang++-19 CFLAGS="--target=riscv64-linux-gnu -march=rv64gcv_zvl512b_zba_zbb_zbc -mrvv-vector-bits=zvl" CXXFLAGS="${CFLAGS}" \
+        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DSIMDJSON_DEVELOPER_MODE=ON -B build-vls
+        cmake --build build-vls/ -j$(nproc) --config Release
+    - name: Test VLEN=512 VLS
+      run: |
+        QEMU_LD_PREFIX="/usr/riscv64-linux-gnu" \
+        QEMU_CPU="rv64,v=on,zba=on,zbb=on,zbc=on,vlen=512,rvv_ta_all_1s=on,rvv_ma_all_1s=on" \
+        ctest --timeout 1800 --output-on-failure --test-dir build-vls -j $(nproc)

.github/workflows/ubuntu24-checkperf.yml

@@ -1,4 +1,4 @@
-name: Performance check on Ubuntu 20.04 CI (GCC 9)
+name: Performance check on Ubuntu 24.04 CI (GCC 13)
 
 on:
   push:

.github/workflows/ubuntu24-noexcept.yml

@@ -1,4 +1,4 @@
-name: Ubuntu 20.04 CI (GCC 9) without exceptions
+name: Ubuntu 24.04 CI (GCC 13) without exceptions
 
 on: [push, pull_request]
 
@@ -24,7 +24,7 @@ jobs:
           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  -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_EXCEPTIONS=OFF -DBUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
           cmake --build .   &&
           ctest --output-on-failure -LE explicitonly -j   &&
           make install  &&

.github/workflows/ubuntu24-nothread.yml

@@ -1,4 +1,4 @@
-name: Ubuntu 20.04 CI (GCC 9) Without Threads
+name: Ubuntu 24.04 CI (GCC 13) Without Threads
 
 on: [push, pull_request]
 

.github/workflows/ubuntu24-sani.yml

@@ -1,9 +1,9 @@
-name: Ubuntu 20.04 CI (GCC 9) With Memory Sanitizer
+name: Ubuntu 24.04 CI (GCC 13) With Memory Sanitizer
 
 on: [push, pull_request]
 
 jobs:
-  ubuntu-build-address-sanitizier:
+  ubuntu-build-address-sanitizer:
     if: >-
       ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
       ! contains(toJSON(github.event.commits.*.message), '[skip github]')

AI_USAGE_POLICY.md

@@ -0,0 +1,56 @@
+# AI Usage Policy
+
+Contributors can use whatever tools they would like to
+craft their contributions, but there must be a **human in the loop**.
+**Contributors must read and review all LLM-generated code or text before they
+ask other project members to review it.** The contributor is always the author
+and is fully accountable for their contributions. Contributors should be
+sufficiently confident that the contribution is high enough quality that asking
+for a review is a good use of scarce maintainer time, and they should be **able
+to answer questions about their work** during review.
+
+We expect that new contributors will be less confident in their contributions,
+and our guidance to them is to **start with small contributions** that they can
+fully understand to build confidence. We aspire to be a welcoming community
+that helps new contributors grow their expertise, but learning involves taking
+small steps, getting feedback, and iterating. Passing maintainer feedback to an
+LLM doesn't help anyone grow, and does not sustain our community.
+
+This policy includes, but is not limited to, the following kinds of
+contributions:
+
+- Code, usually in the form of a pull request
+- Issues or security vulnerabilities
+- Comments and feedback on pull requests
+
+## Extractive Contributions
+
+The reason for our "human-in-the-loop" contribution policy is that processing
+patches, PRs, RFCs, and comments is not free -- it takes a lot of
+maintainer time and energy to review those contributions! Sending the
+unreviewed output of an LLM to open source project maintainers *extracts* work
+from them in the form of design and code review, so we call this kind of
+contribution an "extractive contribution".
+
+## Transparency
+
+For contributions involving significant AI assistance, we encourage you to disclose
+its use and explain your process. If a submission appears to rely heavily on AI
+without disclosure, we may doubt that the **human-in-the-loop** requirement has
+been met. Please show awareness of your use of AI.
+
+## Copyright
+
+Artificial intelligence systems raise many questions around copyright that have
+yet to be answered. Our policy on AI tools is similar to our copyright policy:
+Contributors are responsible for ensuring that they have the right to
+contribute code under the terms of our license, typically meaning that either
+they, their employer, or their collaborators hold the copyright. Using AI tools
+to regenerate copyrighted material does not remove the copyright, and
+contributors are responsible for ensuring that such material does not appear in
+their contributions. Contributions found to violate this policy will be removed
+just like any other offending contribution.
+
+## Reference
+
+- [LLVM AI Tool Use Policy](https://discourse.llvm.org/t/rfc-llvm-ai-tool-policy-human-in-the-loop/89159)

CMakeLists.txt

@@ -12,7 +12,7 @@ endif()
 project(
     simdjson
     # The version number is modified by tools/release.py
-    VERSION 4.2.4
+    VERSION 4.6.2
     DESCRIPTION "Parsing gigabytes of JSON per second"
     HOMEPAGE_URL "https://simdjson.org/"
     LANGUAGES CXX C
@@ -29,8 +29,8 @@ string(
 # ---- Options, variables ----
 
 # These version numbers are modified by tools/release.py
-set(SIMDJSON_LIB_VERSION "29.0.0" CACHE STRING "simdjson library version")
-set(SIMDJSON_LIB_SOVERSION "29" CACHE STRING "simdjson library soversion")
+set(SIMDJSON_LIB_VERSION "33.0.0" CACHE STRING "simdjson library version")
+set(SIMDJSON_LIB_SOVERSION "33" 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)
@@ -76,9 +76,12 @@ if(SIMDJSON_DEVELOPMENT_CHECKS)
 endif()
 
 if(is_top_project)
+  option(SIMDJSON_INSTALL "Enable target install" ON)
   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)
+else()
+  option(SIMDJSON_INSTALL "Enable target install" ${BUILD_SHARED_LIBS})
 endif()
 
 include(cmake/handle-deprecations.cmake)
@@ -92,13 +95,16 @@ add_library(simdjson ${SIMDJSON_SOURCES})
 add_library(simdjson::simdjson ALIAS simdjson)
 set(SIMDJSON_LIBRARIES simdjson)
 
+# Check for <bit> header compatibility
+include(CheckIncludeFileCXX)
+check_include_file_cxx(bit SIMDJSON_HAS_BIT_HEADER)
+
 # Enable precompiled headers for faster builds
 if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.16")
-  target_precompile_headers(simdjson PRIVATE
+  set(SIMDJSON_PRECOMPILE_HEADERS
     <algorithm>
     <array>
     <atomic>
-    <bit>
     <cassert>
     <cctype>
     <cerrno>
@@ -111,6 +117,12 @@ if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.16")
     <utility>
     <vector>
   )
+
+  if(SIMDJSON_HAS_BIT_HEADER)
+    list(APPEND SIMDJSON_PRECOMPILE_HEADERS <bit>)
+  endif()
+
+  target_precompile_headers(simdjson PRIVATE ${SIMDJSON_PRECOMPILE_HEADERS})
 endif()
 
 if(SIMDJSON_BUILD_STATIC_LIB)
@@ -216,87 +228,89 @@ endif()
 
 # ---- Install rules ----
 
-include(CMakePackageConfigHelpers)
-include(GNUInstallDirs)
+if(SIMDJSON_INSTALL)
+    include(CMakePackageConfigHelpers)
+    include(GNUInstallDirs)
 
-if(SIMDJSON_SINGLEHEADER)
-  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
+        EXPORT simdjsonTargets
+        RUNTIME COMPONENT simdjson_Runtime
+        LIBRARY COMPONENT simdjson_Runtime
+        NAMELINK_COMPONENT simdjson_Development
+        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(
+        simdjson-config-version.cmake
+        COMPATIBILITY SameMinorVersion
+    )
+
+    set(
+        SIMDJSON_INSTALL_CMAKEDIR "${CMAKE_INSTALL_LIBDIR}/cmake/simdjson"
+        CACHE STRING "CMake package config location relative to the install prefix"
+    )
+    mark_as_advanced(SIMDJSON_INSTALL_CMAKEDIR)
+
+    install(
+        FILES
+        "${PROJECT_BINARY_DIR}/simdjson-config.cmake"
+        "${PROJECT_BINARY_DIR}/simdjson-config-version.cmake"
+        DESTINATION "${SIMDJSON_INSTALL_CMAKEDIR}"
+        COMPONENT simdjson_Development
+    )
+
+    install(
+        EXPORT simdjsonTargets
+        NAMESPACE simdjson::
+        DESTINATION "${SIMDJSON_INSTALL_CMAKEDIR}"
+        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}")
+    join_paths(PKGCONFIG_LIBDIR "\${prefix}" "${CMAKE_INSTALL_LIBDIR}")
+
+    if(SIMDJSON_ENABLE_THREADS)
+      set(PKGCONFIG_CFLAGS "-DSIMDJSON_THREADS_ENABLED=1")
+      if(CMAKE_THREAD_LIBS_INIT)
+        set(PKGCONFIG_LIBS_PRIVATE "Libs.private: ${CMAKE_THREAD_LIBS_INIT}")
+      endif()
+    endif()
+
+    configure_file("simdjson.pc.in" "simdjson.pc" @ONLY)
+    install(
+        FILES "${CMAKE_CURRENT_BINARY_DIR}/simdjson.pc"
+        DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig"
+    )
 endif()
 
-install(
-    TARGETS simdjson
-    EXPORT simdjsonTargets
-    RUNTIME COMPONENT simdjson_Runtime
-    LIBRARY COMPONENT simdjson_Runtime
-    NAMELINK_COMPONENT simdjson_Development
-    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(
-    simdjson-config-version.cmake
-    COMPATIBILITY SameMinorVersion
-)
-
-set(
-    SIMDJSON_INSTALL_CMAKEDIR "${CMAKE_INSTALL_LIBDIR}/cmake/simdjson"
-    CACHE STRING "CMake package config location relative to the install prefix"
-)
-mark_as_advanced(SIMDJSON_INSTALL_CMAKEDIR)
-
-install(
-    FILES
-    "${PROJECT_BINARY_DIR}/simdjson-config.cmake"
-    "${PROJECT_BINARY_DIR}/simdjson-config-version.cmake"
-    DESTINATION "${SIMDJSON_INSTALL_CMAKEDIR}"
-    COMPONENT simdjson_Development
-)
-
-install(
-    EXPORT simdjsonTargets
-    NAMESPACE simdjson::
-    DESTINATION "${SIMDJSON_INSTALL_CMAKEDIR}"
-    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}")
-join_paths(PKGCONFIG_LIBDIR "\${prefix}" "${CMAKE_INSTALL_LIBDIR}")
-
-if(SIMDJSON_ENABLE_THREADS)
-  set(PKGCONFIG_CFLAGS "-DSIMDJSON_THREADS_ENABLED=1")
-  if(CMAKE_THREAD_LIBS_INIT)
-    set(PKGCONFIG_LIBS_PRIVATE "Libs.private: ${CMAKE_THREAD_LIBS_INIT}")
-  endif()
-endif()
-
-configure_file("simdjson.pc.in" "simdjson.pc" @ONLY)
-install(
-    FILES "${CMAKE_CURRENT_BINARY_DIR}/simdjson.pc"
-    DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig"
-)
-
 #
 # CPack
 #

CONTRIBUTING.md

@@ -101,3 +101,10 @@ Getting Started Hacking
 
 An overview of simdjson's directory structure, with pointers to architecture and design
 considerations and other helpful notes, can be found at [HACKING.md](HACKING.md).
+
+
+
+AI Usage Policy
+---------------
+
+Please also review our [AI Usage Policy](AI_USAGE_POLICY.md).

Doxyfile

@@ -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         = "4.2.4"
+PROJECT_NUMBER         = "4.6.2"
 
 # 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

README.md

@@ -64,6 +64,8 @@ Real-world usage
 - [RonDB](https://github.com/logicalclocks/rondb)
 - [GreptimeDB](https://github.com/GreptimeTeam/greptimedb)
 - [mamba](https://github.com/mamba-org/mamba)
+- [Ladybird Browser](https://ladybird.org)
+- [SereneDB](https://github.com/serenedb/serenedb)
 
 
 If you are planning to use simdjson in a product, please work from one of our releases.
@@ -187,6 +189,7 @@ We distinguish between "bindings" (which just wrap the C++ code) and a port to a
 - [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.
+- [mruby-fast-json](https://github.com/Asmod4n/mruby-fast-json): mruby binding with high API coverage.
 
 About simdjson
 --------------
@@ -209,10 +212,16 @@ We have an in-depth paper focused on the UTF-8 validation:
 
 We also have an informal [blog post providing some background and context](https://branchfree.org/2019/02/25/paper-parsing-gigabytes-of-json-per-second/).
 
-For the video inclined, <br />
+For the video inclined, we had a talk at QCon San Francisco 2019<br />
 [![simdjson at QCon San Francisco 2019](http://img.youtube.com/vi/wlvKAT7SZIQ/0.jpg)](http://www.youtube.com/watch?v=wlvKAT7SZIQ)<br />
 (It was the best voted talk, we're kinda proud of it.)
 
+We also had a CppCon 2025 talk. We show how C++26 reflection allows for one-line serialization (to_json(player)) or deserialization—without invasive macros or manual mapping—using nothing but the C++ standard library. Whether you’re a performance junkie or simply interested in the roadmap for the next decade of C++ development, watch our full talk!
+
+[![simdjson at CppCon 2025](http://img.youtube.com/vi/Mcgk3CxHYMs/0.jpg)](http://www.youtube.com/watch?v=Mcgk3CxHYMs)<br />
+
+
+
 Citing this work
 -----------------
 

benchmark/static_reflect/CMakeLists.txt

@@ -8,7 +8,7 @@ CPMAddPackage(
 
 option(SIMDJSON_USE_RUST "Build the static_reflect benchmark" OFF)
 
-if(SIMDJSON_USER_RUST)
+if(SIMDJSON_USE_RUST)
   if(NOT WIN32)
   # We want the check whether Rust is available before trying to build a crate.
   CPMAddPackage(
@@ -39,9 +39,9 @@ if(SIMDJSON_USER_RUST)
       message(STATUS "curl https://sh.rustup.rs -sSf | sh")
     endif()
   endif()
-else(SIMDJSON_USER_RUST)
+else(SIMDJSON_USE_RUST)
   message(STATUS "We will not benchmark serde-benchmark." )
-endif(SIMDJSON_USER_RUST)
+endif(SIMDJSON_USE_RUST)
 
 # Add the benchmark executable targets
 add_subdirectory(twitter_benchmark)

benchmark/static_reflect/citm_catalog_benchmark/CMakeLists.txt

@@ -1,4 +1,5 @@
 add_executable(benchmark_serialization_citm_catalog benchmark_serialization_citm_catalog.cpp)
+add_executable(benchmark_parsing_citm benchmark_parsing_citm.cpp)
 
 # Link with Rust benchmarking code if available
 if(TARGET serde-benchmark)
@@ -11,4 +12,29 @@ target_link_libraries(benchmark_serialization_citm_catalog PRIVATE simdjson::sim
 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}")
+if(TARGET yyjson)
+    target_link_libraries(benchmark_serialization_citm_catalog PRIVATE yyjson)
+    target_compile_definitions(benchmark_serialization_citm_catalog PRIVATE SIMDJSON_COMPETITION_YYJSON)
+endif()
+
+target_compile_definitions(benchmark_serialization_citm_catalog PRIVATE JSON_FILE="${BENCH_CITM_JSON}")
+
+# Configuration for parsing benchmark
+if(TARGET serde-benchmark)
+    target_link_libraries(benchmark_parsing_citm PRIVATE serde-benchmark)
+    target_compile_definitions(benchmark_parsing_citm PRIVATE SIMDJSON_RUST_VERSION="${Rust_VERSION}")
+endif()
+
+target_link_libraries(benchmark_parsing_citm PRIVATE simdjson::simdjson nlohmann_json)
+
+if(TARGET rapidjson)
+    target_link_libraries(benchmark_parsing_citm PRIVATE rapidjson)
+    target_compile_definitions(benchmark_parsing_citm PRIVATE SIMDJSON_COMPETITION_RAPIDJSON)
+endif()
+
+if(TARGET yyjson)
+    target_link_libraries(benchmark_parsing_citm PRIVATE yyjson)
+    target_compile_definitions(benchmark_parsing_citm PRIVATE SIMDJSON_COMPETITION_YYJSON)
+endif()
+
+target_compile_definitions(benchmark_parsing_citm PRIVATE JSON_FILE="${BENCH_CITM_JSON}")

benchmark/static_reflect/citm_catalog_benchmark/benchmark_parsing_citm.cpp

@@ -0,0 +1,563 @@
+#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"
+
+#ifdef SIMDJSON_COMPETITION_RAPIDJSON
+#include "rapidjson_citm_catalog_data.h"
+#endif
+
+#ifdef SIMDJSON_COMPETITION_YYJSON
+#include "yyjson_citm_catalog_data.h"
+#endif
+
+#ifdef SIMDJSON_RUST_VERSION
+#include "../serde-benchmark/serde_benchmark.h"
+
+void bench_rust_parsing(const std::string &json_str) {
+  size_t input_volume = json_str.size();
+  printf("# input volume: %zu bytes\n", input_volume);
+
+  volatile bool result = true;
+  pretty_print(1, input_volume, "bench_rust_parsing",
+               bench([&json_str, &result]() {
+                 serde_benchmark::CitmCatalog *catalog = serde_benchmark::citm_from_str(json_str.c_str(), json_str.size());
+                 result = (catalog != nullptr);
+                 if (catalog) {
+                   serde_benchmark::free_citm(catalog);
+                 }
+                 if (!result) {
+                   printf("parse error\n");
+                 }
+               }));
+}
+#endif
+
+template <class T> void bench_simdjson_static_reflection_parsing(const std::string &json_str) {
+  size_t input_volume = json_str.size();
+  printf("# input volume: %zu bytes\n", input_volume);
+
+  // Pre-allocate padded buffer outside the benchmark loop
+  std::string mutable_json = json_str;
+  simdjson::pad(mutable_json);
+
+  volatile bool result = true;
+  pretty_print(1, input_volume, "bench_simdjson_static_reflection_parsing",
+               bench([&mutable_json, &result]() {
+                 simdjson::ondemand::parser parser;
+                 simdjson::ondemand::document doc;
+                 if(parser.iterate(mutable_json).get(doc)) {
+                   result = false;
+                   return;
+                 }
+                 T my_struct;
+                 if(doc.get<T>().get(my_struct)) {
+                   result = false;
+                 }
+                 if (!result) {
+                   printf("parse error\n");
+                 }
+               }));
+}
+
+#if SIMDJSON_STATIC_REFLECTION
+template <class T> void bench_simdjson_from_parsing(const std::string &json_str) {
+  size_t input_volume = json_str.size();
+  printf("# input volume: %zu bytes\n", input_volume);
+
+  // Pre-allocate padded buffer outside the benchmark loop
+  simdjson::padded_string padded = simdjson::padded_string(json_str);
+
+  volatile bool result = true;
+  pretty_print(1, input_volume, "bench_simdjson_from_parsing",
+               bench([&padded, &result]() {
+                 T my_struct;
+                 auto err = simdjson::from(padded).get(my_struct);
+                  if (err) {
+                    result = false;
+                    printf("parse error: %s\n", simdjson::error_message(err));
+                    return;
+                  }
+               }));
+}
+#endif
+
+// nlohmann::json deserialization functions
+void from_json(const nlohmann::json &j, CITMPrice &p) {
+    j.at("amount").get_to(p.amount);
+    j.at("audienceSubCategoryId").get_to(p.audienceSubCategoryId);
+    j.at("seatCategoryId").get_to(p.seatCategoryId);
+}
+
+void from_json(const nlohmann::json &j, CITMArea &a) {
+    j.at("areaId").get_to(a.areaId);
+    j.at("blockIds").get_to(a.blockIds);
+}
+
+void from_json(const nlohmann::json &j, CITMSeatCategory &s) {
+    j.at("areas").get_to(s.areas);
+    j.at("seatCategoryId").get_to(s.seatCategoryId);
+}
+
+void from_json(const nlohmann::json &j, CITMPerformance &p) {
+    j.at("id").get_to(p.id);
+    j.at("eventId").get_to(p.eventId);
+    if (j.contains("logo") && !j["logo"].is_null()) {
+        p.logo = j["logo"].get<std::string>();
+    }
+    if (j.contains("name") && !j["name"].is_null()) {
+        p.name = j["name"].get<std::string>();
+    }
+    j.at("prices").get_to(p.prices);
+    j.at("seatCategories").get_to(p.seatCategories);
+    if (j.contains("seatMapImage") && !j["seatMapImage"].is_null()) {
+        p.seatMapImage = j["seatMapImage"].get<std::string>();
+    }
+    j.at("start").get_to(p.start);
+    j.at("venueCode").get_to(p.venueCode);
+}
+
+void from_json(const nlohmann::json &j, CITMEvent &e) {
+    j.at("id").get_to(e.id);
+    j.at("name").get_to(e.name);
+    if (j.contains("description") && !j["description"].is_null()) {
+        e.description = j["description"].get<std::string>();
+    }
+    if (j.contains("logo") && !j["logo"].is_null()) {
+        e.logo = j["logo"].get<std::string>();
+    }
+    j.at("subTopicIds").get_to(e.subTopicIds);
+    if (j.contains("subjectCode") && !j["subjectCode"].is_null()) {
+        e.subjectCode = j["subjectCode"].get<std::string>();
+    }
+    if (j.contains("subtitle") && !j["subtitle"].is_null()) {
+        e.subtitle = j["subtitle"].get<std::string>();
+    }
+    j.at("topicIds").get_to(e.topicIds);
+}
+
+void from_json(const nlohmann::json &j, CitmCatalog &c) {
+    j.at("events").get_to(c.events);
+    j.at("performances").get_to(c.performances);
+}
+
+CitmCatalog nlohmann_deserialize(const std::string &json_str) {
+    nlohmann::json j = nlohmann::json::parse(json_str);
+    return j.get<CitmCatalog>();
+}
+
+void bench_nlohmann_parsing(const std::string &json_str) {
+  size_t input_volume = json_str.size();
+  printf("# input volume: %zu bytes\n", input_volume);
+
+  volatile bool result = true;
+  pretty_print(1, input_volume, "bench_nlohmann_parsing",
+               bench([&json_str, &result]() {
+                 try {
+                   CitmCatalog data = nlohmann_deserialize(json_str);
+                   result = true;
+                 } catch (...) {
+                   result = false;
+                   printf("parse error\n");
+                 }
+               }));
+}
+
+#ifdef SIMDJSON_COMPETITION_RAPIDJSON
+CitmCatalog rapidjson_deserialize(const std::string &json_str) {
+    rapidjson::Document doc;
+    doc.Parse(json_str.c_str());
+
+    if (doc.HasParseError()) {
+        throw std::runtime_error("RapidJSON parse error");
+    }
+
+    CitmCatalog catalog;
+
+    // Parse events
+    if (doc.HasMember("events") && doc["events"].IsObject()) {
+        for (auto& m : doc["events"].GetObject()) {
+            CITMEvent event;
+            const auto& e = m.value;
+
+            event.id = e["id"].GetUint64();
+            event.name = e["name"].GetString();
+            if (e.HasMember("description") && !e["description"].IsNull()) {
+                event.description = e["description"].GetString();
+            }
+            if (e.HasMember("logo") && !e["logo"].IsNull()) {
+                event.logo = e["logo"].GetString();
+            }
+
+            event.subTopicIds.clear();
+            for (auto& id : e["subTopicIds"].GetArray()) {
+                event.subTopicIds.push_back(id.GetUint64());
+            }
+
+            if (e.HasMember("subjectCode") && !e["subjectCode"].IsNull()) {
+                event.subjectCode = e["subjectCode"].GetString();
+            }
+            if (e.HasMember("subtitle") && !e["subtitle"].IsNull()) {
+                event.subtitle = e["subtitle"].GetString();
+            }
+
+            event.topicIds.clear();
+            for (auto& id : e["topicIds"].GetArray()) {
+                event.topicIds.push_back(id.GetUint64());
+            }
+
+            catalog.events[m.name.GetString()] = event;
+        }
+    }
+
+    // Parse performances
+    if (doc.HasMember("performances") && doc["performances"].IsArray()) {
+        for (auto& p : doc["performances"].GetArray()) {
+            CITMPerformance perf;
+
+            perf.id = p["id"].GetUint64();
+            perf.eventId = p["eventId"].GetUint64();
+            if (p.HasMember("logo") && !p["logo"].IsNull()) {
+                perf.logo = p["logo"].GetString();
+            }
+            if (p.HasMember("name") && !p["name"].IsNull()) {
+                perf.name = p["name"].GetString();
+            }
+
+            // Parse prices
+            for (auto& price : p["prices"].GetArray()) {
+                CITMPrice pr;
+                pr.amount = price["amount"].GetUint64();
+                pr.audienceSubCategoryId = price["audienceSubCategoryId"].GetUint64();
+                pr.seatCategoryId = price["seatCategoryId"].GetUint64();
+                perf.prices.push_back(pr);
+            }
+
+            // Parse seat categories
+            for (auto& sc : p["seatCategories"].GetArray()) {
+                CITMSeatCategory seatCat;
+                seatCat.seatCategoryId = sc["seatCategoryId"].GetUint64();
+
+                for (auto& area : sc["areas"].GetArray()) {
+                    CITMArea ar;
+                    ar.areaId = area["areaId"].GetUint64();
+                    for (auto& block : area["blockIds"].GetArray()) {
+                        ar.blockIds.push_back(block.GetUint64());
+                    }
+                    seatCat.areas.push_back(ar);
+                }
+                perf.seatCategories.push_back(seatCat);
+            }
+
+            if (p.HasMember("seatMapImage") && !p["seatMapImage"].IsNull()) {
+                perf.seatMapImage = p["seatMapImage"].GetString();
+            }
+            perf.start = p["start"].GetUint64();
+            perf.venueCode = p["venueCode"].GetString();
+
+            catalog.performances.push_back(perf);
+        }
+    }
+
+    return catalog;
+}
+
+void bench_rapidjson_parsing(const std::string &json_str) {
+  size_t input_volume = json_str.size();
+  printf("# input volume: %zu bytes\n", input_volume);
+
+  volatile bool result = true;
+  pretty_print(1, input_volume, "bench_rapidjson_parsing",
+               bench([&json_str, &result]() {
+                 try {
+                   CitmCatalog data = rapidjson_deserialize(json_str);
+                   result = true;
+                 } catch (...) {
+                   result = false;
+                   printf("parse error\n");
+                 }
+               }));
+}
+#endif
+
+#ifdef SIMDJSON_COMPETITION_YYJSON
+CitmCatalog yyjson_deserialize(const std::string &json_str) {
+    yyjson_doc *doc = yyjson_read(json_str.c_str(), json_str.size(), 0);
+    if (!doc) {
+        throw std::runtime_error("YYJson parse error");
+    }
+
+    yyjson_val *root = yyjson_doc_get_root(doc);
+    CitmCatalog catalog;
+
+    // Parse events
+    yyjson_val *events = yyjson_obj_get(root, "events");
+    if (events) {
+        size_t idx, max;
+        yyjson_val *key, *val;
+        yyjson_obj_foreach(events, idx, max, key, val) {
+            CITMEvent event;
+
+            event.id = yyjson_get_uint(yyjson_obj_get(val, "id"));
+            const char* name = yyjson_get_str(yyjson_obj_get(val, "name"));
+            if (name) event.name = name;
+
+            yyjson_val *desc = yyjson_obj_get(val, "description");
+            if (desc && !yyjson_is_null(desc)) {
+                const char* str = yyjson_get_str(desc);
+                if (str) event.description = str;
+            }
+
+            yyjson_val *logo = yyjson_obj_get(val, "logo");
+            if (logo && !yyjson_is_null(logo)) {
+                const char* str = yyjson_get_str(logo);
+                if (str) event.logo = str;
+            }
+
+            yyjson_val *subTopics = yyjson_obj_get(val, "subTopicIds");
+            if (subTopics) {
+                size_t sidx, smax;
+                yyjson_val *sval;
+                yyjson_arr_foreach(subTopics, sidx, smax, sval) {
+                    event.subTopicIds.push_back(yyjson_get_uint(sval));
+                }
+            }
+
+            yyjson_val *subjectCode = yyjson_obj_get(val, "subjectCode");
+            if (subjectCode && !yyjson_is_null(subjectCode)) {
+                const char* str = yyjson_get_str(subjectCode);
+                if (str) event.subjectCode = str;
+            }
+
+            yyjson_val *subtitle = yyjson_obj_get(val, "subtitle");
+            if (subtitle && !yyjson_is_null(subtitle)) {
+                const char* str = yyjson_get_str(subtitle);
+                if (str) event.subtitle = str;
+            }
+
+            yyjson_val *topics = yyjson_obj_get(val, "topicIds");
+            if (topics) {
+                size_t tidx, tmax;
+                yyjson_val *tval;
+                yyjson_arr_foreach(topics, tidx, tmax, tval) {
+                    event.topicIds.push_back(yyjson_get_uint(tval));
+                }
+            }
+
+            const char* keyStr = yyjson_get_str(key);
+            if (keyStr) {
+                catalog.events[keyStr] = event;
+            }
+        }
+    }
+
+    // Parse performances
+    yyjson_val *performances = yyjson_obj_get(root, "performances");
+    if (performances) {
+        size_t idx, max;
+        yyjson_val *val;
+        yyjson_arr_foreach(performances, idx, max, val) {
+            CITMPerformance perf;
+
+            perf.id = yyjson_get_uint(yyjson_obj_get(val, "id"));
+            perf.eventId = yyjson_get_uint(yyjson_obj_get(val, "eventId"));
+
+            yyjson_val *logo = yyjson_obj_get(val, "logo");
+            if (logo && !yyjson_is_null(logo)) {
+                const char* str = yyjson_get_str(logo);
+                if (str) perf.logo = str;
+            }
+
+            yyjson_val *name = yyjson_obj_get(val, "name");
+            if (name && !yyjson_is_null(name)) {
+                const char* str = yyjson_get_str(name);
+                if (str) perf.name = str;
+            }
+
+            // Parse prices
+            yyjson_val *prices = yyjson_obj_get(val, "prices");
+            if (prices) {
+                size_t pidx, pmax;
+                yyjson_val *pval;
+                yyjson_arr_foreach(prices, pidx, pmax, pval) {
+                    CITMPrice price;
+                    price.amount = yyjson_get_uint(yyjson_obj_get(pval, "amount"));
+                    price.audienceSubCategoryId = yyjson_get_uint(yyjson_obj_get(pval, "audienceSubCategoryId"));
+                    price.seatCategoryId = yyjson_get_uint(yyjson_obj_get(pval, "seatCategoryId"));
+                    perf.prices.push_back(price);
+                }
+            }
+
+            // Parse seat categories
+            yyjson_val *seatCats = yyjson_obj_get(val, "seatCategories");
+            if (seatCats) {
+                size_t scidx, scmax;
+                yyjson_val *scval;
+                yyjson_arr_foreach(seatCats, scidx, scmax, scval) {
+                    CITMSeatCategory seatCat;
+                    seatCat.seatCategoryId = yyjson_get_uint(yyjson_obj_get(scval, "seatCategoryId"));
+
+                    yyjson_val *areas = yyjson_obj_get(scval, "areas");
+                    if (areas) {
+                        size_t aidx, amax;
+                        yyjson_val *aval;
+                        yyjson_arr_foreach(areas, aidx, amax, aval) {
+                            CITMArea area;
+                            area.areaId = yyjson_get_uint(yyjson_obj_get(aval, "areaId"));
+
+                            yyjson_val *blocks = yyjson_obj_get(aval, "blockIds");
+                            if (blocks) {
+                                size_t bidx, bmax;
+                                yyjson_val *bval;
+                                yyjson_arr_foreach(blocks, bidx, bmax, bval) {
+                                    area.blockIds.push_back(yyjson_get_uint(bval));
+                                }
+                            }
+                            seatCat.areas.push_back(area);
+                        }
+                    }
+                    perf.seatCategories.push_back(seatCat);
+                }
+            }
+
+            yyjson_val *seatMapImage = yyjson_obj_get(val, "seatMapImage");
+            if (seatMapImage && !yyjson_is_null(seatMapImage)) {
+                const char* str = yyjson_get_str(seatMapImage);
+                if (str) perf.seatMapImage = str;
+            }
+
+            perf.start = yyjson_get_uint(yyjson_obj_get(val, "start"));
+            const char* venueCode = yyjson_get_str(yyjson_obj_get(val, "venueCode"));
+            if (venueCode) perf.venueCode = venueCode;
+
+            catalog.performances.push_back(perf);
+        }
+    }
+
+    yyjson_doc_free(doc);
+    return catalog;
+}
+
+void bench_yyjson_parsing(const std::string &json_str) {
+  size_t input_volume = json_str.size();
+  printf("# input volume: %zu bytes\n", input_volume);
+
+  volatile bool result = true;
+  pretty_print(1, input_volume, "bench_yyjson_parsing",
+               bench([&json_str, &result]() {
+                 try {
+                   CitmCatalog data = yyjson_deserialize(json_str);
+                   result = true;
+                 } catch (...) {
+                   result = false;
+                   printf("parse error\n");
+                 }
+               }));
+}
+#endif
+
+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);
+  stream.exceptions(std::ios_base::badbit);
+
+  if (!stream) {
+    std::cerr << "Error: Failed to open file " << filename << std::endl;
+    exit(EXIT_FAILURE);
+  }
+
+  std::string out;
+  auto buf = std::string(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 matches any of the comma-separated filters
+bool matches_filter(const std::string& benchmark_name, const std::string& filter) {
+  if (filter.empty()) return true;
+
+  // Split filter by comma
+  size_t start = 0;
+  size_t end = filter.find(',');
+  while (end != std::string::npos) {
+    std::string token = filter.substr(start, end - start);
+    if (benchmark_name.find(token) != std::string::npos) {
+      return true;
+    }
+    start = end + 1;
+    end = filter.find(',', start);
+  }
+  // Check last token
+  std::string token = filter.substr(start);
+  return benchmark_name.find(token) != std::string::npos;
+}
+
+int main(int argc, char *argv[]) {
+  // Get the JSON file path from preprocessor or use default
+  std::string filename;
+#ifdef JSON_FILE
+  filename = JSON_FILE;
+#else
+  filename = "jsonexamples/citm_catalog.json";
+#endif
+
+  std::string json_str = read_file(filename);
+
+  // Parse command-line arguments for filter
+  std::string filter;
+  for (int i = 1; i < argc; i++) {
+    std::string arg = argv[i];
+    if (arg == "-f" && i + 1 < argc) {
+      filter = argv[i + 1];
+      printf("# Filter: %s\n", filter.c_str());
+      i++;
+    }
+  }
+
+  // If no filter provided, run all benchmarks
+  if (filter.empty()) {
+    printf("# Running all benchmarks (use -f <filter> to run specific ones)\n");
+  }
+
+  // Benchmarking the parsing
+  if (matches_filter("nlohmann", filter)) {
+    bench_nlohmann_parsing(json_str);
+  }
+#ifdef SIMDJSON_COMPETITION_RAPIDJSON
+  if (matches_filter("rapidjson", filter)) {
+    bench_rapidjson_parsing(json_str);
+  }
+#endif
+#ifdef SIMDJSON_COMPETITION_YYJSON
+  if (matches_filter("yyjson", filter)) {
+    bench_yyjson_parsing(json_str);
+  }
+#endif
+  if (matches_filter("simdjson_static_reflection", filter)) {
+    bench_simdjson_static_reflection_parsing<CitmCatalog>(json_str);
+  }
+#if SIMDJSON_STATIC_REFLECTION
+  if (matches_filter("simdjson_from", filter)) {
+    bench_simdjson_from_parsing<CitmCatalog>(json_str);
+  }
+#endif
+#ifdef SIMDJSON_RUST_VERSION
+  if (matches_filter("rust", filter)) {
+    printf("# Note: Rust/Serde parsing test\n");
+    bench_rust_parsing(json_str);
+  }
+#endif
+  return EXIT_SUCCESS;
+}

benchmark/static_reflect/citm_catalog_benchmark/benchmark_serialization_citm_catalog.cpp

@@ -11,6 +11,10 @@
 #include "nlohmann_citm_catalog_data.h"
 #include "../benchmark_utils/benchmark_helper.h"
 
+#ifdef SIMDJSON_COMPETITION_YYJSON
+#include "yyjson_citm_catalog_data.h"
+#endif
+
 #if SIMDJSON_BENCH_CPP_REFLECT
 #include <rfl.hpp>
 #include <rfl/json.hpp>
@@ -35,20 +39,15 @@ void bench_reflect_cpp(CitmCatalog &data) {
 #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);
+  serde_benchmark::set_citm_data(data);
+  size_t output_volume = serde_benchmark::serialize_citm_to_string();
   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));
+               bench([&measured_volume, &output_volume]() {
+                 measured_volume = serde_benchmark::serialize_citm_to_string();
                }));
-  serde_benchmark::free_str(const_cast<char*>(output));
 }
 #endif // SIMDJSON_RUST_VERSION
 
@@ -68,7 +67,55 @@ void bench_nlohmann(CitmCatalog &data) {
                }));
 }
 
+#ifdef SIMDJSON_COMPETITION_YYJSON
+void bench_yyjson(CitmCatalog &data) {
+  std::string output = yyjson_serialize_citm(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_yyjson",
+               bench([&data, &measured_volume, &output_volume]() {
+                 std::string output = yyjson_serialize_citm(data);
+                 measured_volume = output.size();
+                 if (measured_volume != output_volume) {
+                   printf("mismatch\n");
+                 }
+               }));
+}
+#endif
+
+// Fair allocation variant: allocates fresh buffer each iteration (matches other libraries)
 void bench_simdjson_static_reflection(CitmCatalog &data) {
+  // First run to determine expected size
+  simdjson::builder::string_builder sb_init;
+  simdjson::builder::append(sb_init, data);
+  std::string_view p_init;
+  if(sb_init.view().get(p_init)) {
+    std::cerr << "Error!" << std::endl;
+  }
+  size_t output_volume = p_init.size();
+  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]() {
+                 // Fresh allocation each iteration - fair comparison
+                 simdjson::builder::string_builder sb;
+                 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");
+                 }
+               }));
+}
+
+// Optimized variant: reuses buffer across iterations (shows API potential)
+void bench_simdjson_static_reflection_reuse(CitmCatalog &data) {
   simdjson::builder::string_builder sb;
   simdjson::builder::append(sb, data);
   std::string_view p;
@@ -80,7 +127,7 @@ void bench_simdjson_static_reflection(CitmCatalog &data) {
   printf("# output volume: %zu bytes\n", output_volume);
 
   volatile size_t measured_volume = 0;
-  pretty_print(sizeof(data), output_volume, "bench_simdjson_static_reflection",
+  pretty_print(sizeof(data), output_volume, "bench_simdjson_reuse_buffer",
                bench([&data, &measured_volume, &output_volume, &sb]() {
                  sb.clear();
                  simdjson::builder::append(sb, data);
@@ -95,25 +142,97 @@ void bench_simdjson_static_reflection(CitmCatalog &data) {
                }));
 }
 
-std::string read_file(const std::string &file_path, size_t read_size = 65536) {
+#if SIMDJSON_STATIC_REFLECTION
+// Fair allocation variant: allocates fresh string each iteration
+void bench_simdjson_to(CitmCatalog &data) {
+  // First run to determine size
+  std::string output_init;
+  if (simdjson::error_code err = simdjson::builder::to_json(data, output_init); err) {
+    std::cerr << "Error in to_json initialization!" << simdjson::error_message(err) << std::endl;
+    return;
+  }
+  size_t output_volume = output_init.size();
+  printf("# output volume: %zu bytes\n", output_volume);
+
+  volatile size_t measured_volume = 0;
+  pretty_print(sizeof(data), output_volume, "bench_simdjson_to",
+               bench([&data, &measured_volume, &output_volume]() {
+                 // Fresh allocation each iteration - fair comparison
+                 std::string output;
+                 if (simdjson::error_code err = simdjson::builder::to_json(data, output); err) {
+                   std::cerr << "Error in to_json!" << simdjson::error_message(err) << std::endl;
+                   return;
+                 }
+                 measured_volume = output.size();
+                 if (measured_volume != output_volume) {
+                   printf("mismatch\n");
+                 }
+               }));
+}
+
+// Optimized variant: reuses pre-allocated string
+void bench_simdjson_to_reuse(CitmCatalog &data) {
+  std::string output;
+  if (simdjson::error_code err = simdjson::builder::to_json(data, output); err) {
+    std::cerr << "Error in to_json initialization!" << simdjson::error_message(err) << std::endl;
+    return;
+  }
+  size_t output_volume = output.size();
+  printf("# output volume: %zu bytes\n", output_volume);
+
+  // Pre-allocate string with sufficient capacity to avoid reallocation
+  output.reserve(output_volume * 2);
+
+  volatile size_t measured_volume = 0;
+  pretty_print(sizeof(data), output_volume, "bench_simdjson_to_reuse",
+               bench([&data, &measured_volume, &output_volume, &output]() {
+                 // Reuse the pre-allocated string - avoids allocation
+                 if (simdjson::error_code err = simdjson::builder::to_json(data, output); err) {
+                   std::cerr << "Error in to_json!" << simdjson::error_message(err) << std::endl;
+                   return;
+                 }
+                 measured_volume = output.size();
+                 if (measured_volume != output_volume) {
+                   printf("mismatch\n");
+                 }
+               }));
+}
+#endif
+
+simdjson::padded_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;
+  simdjson::padded_string_builder builder;
   std::string buf(read_size, '\0');
   while (stream.read(&buf[0], read_size)) {
-    out.append(buf, 0, size_t(stream.gcount()));
+    builder.append(buf.data(), size_t(stream.gcount()));
   }
-  out.append(buf, 0, size_t(stream.gcount()));
-  return out;
+  builder.append(buf.data(), size_t(stream.gcount()));
+  return builder.convert();
 }
 
-// Function to check if benchmark name contains filter substring
+// Function to check if benchmark name matches any of the comma-separated filters
 bool matches_filter(const std::string& benchmark_name, const std::string& filter) {
-  return filter.empty() || benchmark_name.find(filter) != std::string::npos;
+  if (filter.empty()) return true;
+
+  // Split filter by comma
+  size_t start = 0;
+  size_t end = filter.find(',');
+  while (end != std::string::npos) {
+    std::string token = filter.substr(start, end - start);
+    if (benchmark_name.find(token) != std::string::npos) {
+      return true;
+    }
+    start = end + 1;
+    end = filter.find(',', start);
+  }
+  // Check last token
+  std::string token = filter.substr(start);
+  return benchmark_name.find(token) != std::string::npos;
 }
 
 int main(int argc, char* argv[]) {
@@ -131,12 +250,12 @@ int main(int argc, char* argv[]) {
       }
   }
   // Testing correctness of round-trip (serialization + deserialization)
-  std::string json_str = read_file(JSON_FILE);
+  simdjson::padded_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)) {
+  if(parser.iterate(json_str).get(doc)) {
     std::cerr << "Error loading the document!" << std::endl;
     return EXIT_FAILURE;
   }
@@ -147,18 +266,37 @@ int main(int argc, char* argv[]) {
   }
 
   // Benchmarking the serialization
+  // Note: simdjson benchmarks include both "fair" (fresh allocation) and "reuse" (buffer reuse) variants
+  // The "fair" variants allocate fresh memory each iteration, matching other libraries' behavior
+  // The "reuse" variants demonstrate the API's potential when buffer reuse is possible
+
   if (matches_filter("nlohmann", filter)) {
     bench_nlohmann(my_struct);
   }
+#ifdef SIMDJSON_COMPETITION_YYJSON
+  if (matches_filter("yyjson", filter)) {
+    bench_yyjson(my_struct);
+  }
+#endif
   if (matches_filter("simdjson_static_reflection", filter)) {
     bench_simdjson_static_reflection(my_struct);
   }
+  if (matches_filter("simdjson_reuse", filter)) {
+    bench_simdjson_static_reflection_reuse(my_struct);
+  }
+#if SIMDJSON_STATIC_REFLECTION
+  if (matches_filter("simdjson_to", filter)) {
+    bench_simdjson_to(my_struct);
+  }
+  if (matches_filter("simdjson_to_reuse", filter)) {
+    bench_simdjson_to_reuse(my_struct);
+  }
+#endif
 #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());
+      serde_benchmark::citm_from_str(json_str.data(), json_str.size());
 
     if (rust_data == nullptr) {
       printf("# Failed to initialize Rust data structure\n");

benchmark/static_reflect/citm_catalog_benchmark/citm_catalog_data.h

@@ -4,79 +4,65 @@
 #include <string>
 #include <vector>
 #include <map>
+#include <optional>
+#include <cstdint>
 
-struct Area {
-  int64_t id;
-  std::string name;
-  int64_t parent;
-  std::vector<int64_t> childAreas;
-  bool operator==(const Area &other) const = default;
+// Price structure - field names must match JSON keys for reflection
+struct CITMPrice {
+    uint64_t amount;
+    uint64_t audienceSubCategoryId;
+    uint64_t seatCategoryId;
+    bool operator==(const CITMPrice&) const = default;
 };
 
-struct AudienceSubCategory {
-  int64_t id;
-  std::string name;
-  int64_t parent;
-  bool operator==(const AudienceSubCategory &other) const = default;
+struct CITMArea {
+    uint64_t areaId;
+    std::vector<uint64_t> blockIds;
+    bool operator==(const CITMArea&) 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 CITMSeatCategory {
+    std::vector<CITMArea> areas;
+    uint64_t seatCategoryId;
+    bool operator==(const CITMSeatCategory&) 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 CITMPerformance {
+    uint64_t id;
+    uint64_t eventId;
+    std::optional<std::string> logo;
+    std::optional<std::string> name;
+    std::vector<CITMPrice> prices;
+    std::vector<CITMSeatCategory> seatCategories;
+    std::optional<std::string> seatMapImage;
+    uint64_t start;
+    std::string venueCode;
+    bool operator==(const CITMPerformance&) 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 CITMEvent {
+    uint64_t id;
+    std::string name;
+    std::optional<std::string> description;
+    std::optional<std::string> logo;
+    std::vector<uint64_t> subTopicIds;
+    std::optional<std::string> subjectCode;
+    std::optional<std::string> subtitle;
+    std::vector<uint64_t> topicIds;
+    bool operator==(const CITMEvent&) 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;
+    std::map<std::string, CITMEvent> events;
+    std::vector<CITMPerformance> performances;
+    bool operator==(const CitmCatalog&) const = default;
 };
 
-#endif
+// Type aliases
+using Event = CITMEvent;
+using Performance = CITMPerformance;
+using Price = CITMPrice;
+using SeatArea = CITMArea;
+using SeatCategoryInfo = CITMSeatCategory;
+
+#endif

benchmark/static_reflect/citm_catalog_benchmark/nlohmann_citm_catalog_data.h

@@ -8,164 +8,72 @@
 
 using json = nlohmann::json;
 
-// ---- Area ----
-inline void to_json(json &j, const Area &a) {
+// ---- CITMPrice ----
+inline void to_json(json &j, const CITMPrice &p) {
     j = json{
-      {"id", a.id},
-      {"name", a.name},
-      {"parent", a.parent},
-      {"childAreas", a.childAreas}
+      {"amount", p.amount},
+      {"audienceSubCategoryId", p.audienceSubCategoryId},
+      {"seatCategoryId", p.seatCategoryId}
     };
 }
-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) {
+// ---- CITMArea ----
+inline void to_json(json &j, const CITMArea &a) {
     j = json{
-      {"id", asc.id},
-      {"name", asc.name},
-      {"parent", asc.parent}
+      {"areaId", a.areaId},
+      {"blockIds", a.blockIds}
     };
 }
-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) {
+// ---- CITMSeatCategory ----
+inline void to_json(json &j, const CITMSeatCategory &s) {
     j = json{
-      {"id", e.id},
-      {"name", e.name},
-      {"description", e.description},
-      {"subTopic", e.subTopic},
-      {"topic", e.topic},
-      {"audience", e.audience}
+      {"areas", s.areas},
+      {"seatCategoryId", s.seatCategoryId}
     };
 }
-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) {
+// ---- CITMPerformance ----
+inline void to_json(json &j, const CITMPerformance &p) {
     j = json{
       {"id", p.id},
+      {"eventId", p.eventId},
+      {"logo", p.logo},
       {"name", p.name},
-      {"event", p.event},
+      {"prices", p.prices},
+      {"seatCategories", p.seatCategories},
+      {"seatMapImage", p.seatMapImage},
       {"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) {
+// ---- CITMEvent ----
+inline void to_json(json &j, const CITMEvent &e) {
     j = json{
-      {"id", sc.id},
-      {"name", sc.name},
-      {"areas", sc.areas}
+      {"id", e.id},
+      {"name", e.name},
+      {"description", e.description},
+      {"logo", e.logo},
+      {"subTopicIds", e.subTopicIds},
+      {"subjectCode", e.subjectCode},
+      {"subtitle", e.subtitle},
+      {"topicIds", e.topicIds}
     };
 }
-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}
+      {"performances", c.performances}
     };
 }
-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
+// Serialization function
 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

benchmark/static_reflect/citm_catalog_benchmark/rapidjson_citm_catalog_data.h

@@ -0,0 +1,189 @@
+#ifndef RAPIDJSON_CITM_CATALOG_DATA_H
+#define RAPIDJSON_CITM_CATALOG_DATA_H
+
+#include "citm_catalog_data.h"
+#include <rapidjson/document.h>
+#include <rapidjson/writer.h>
+#include <rapidjson/stringbuffer.h>
+#include <rapidjson/error/en.h>
+
+using namespace rapidjson;
+
+// RapidJSON deserialization for CITM Catalog data
+CitmCatalog rapidjson_deserialize_citm(const std::string& json_str) {
+    Document doc;
+    doc.Parse(json_str.c_str());
+
+    if (doc.HasParseError()) {
+        throw std::runtime_error("RapidJSON parse error");
+    }
+
+    CitmCatalog catalog;
+
+    // Parse events
+    if (doc.HasMember("events") && doc["events"].IsObject()) {
+        const Value& events = doc["events"];
+        for (auto it = events.MemberBegin(); it != events.MemberEnd(); ++it) {
+            Event event;
+            const Value& ev = it->value;
+
+            if (ev.HasMember("description") && ev["description"].IsString())
+                event.description = ev["description"].GetString();
+            if (ev.HasMember("id") && ev["id"].IsUint64())
+                event.id = ev["id"].GetUint64();
+            if (ev.HasMember("logo") && ev["logo"].IsString())
+                event.logo = ev["logo"].GetString();
+            if (ev.HasMember("name") && ev["name"].IsString())
+                event.name = ev["name"].GetString();
+            if (ev.HasMember("subjectCode") && ev["subjectCode"].IsString())
+                event.subjectCode = ev["subjectCode"].GetString();
+            if (ev.HasMember("subtitle") && ev["subtitle"].IsString())
+                event.subtitle = ev["subtitle"].GetString();
+
+            if (ev.HasMember("topicIds") && ev["topicIds"].IsArray()) {
+                const Value& topics = ev["topicIds"];
+                for (SizeType j = 0; j < topics.Size(); j++) {
+                    if (topics[j].IsUint64())
+                        event.topicIds.push_back(topics[j].GetUint64());
+                }
+            }
+
+            if (ev.HasMember("subTopicIds") && ev["subTopicIds"].IsArray()) {
+                const Value& subtopics = ev["subTopicIds"];
+                for (SizeType j = 0; j < subtopics.Size(); j++) {
+                    if (subtopics[j].IsUint64())
+                        event.subTopicIds.push_back(subtopics[j].GetUint64());
+                }
+            }
+
+            catalog.events[it->name.GetString()] = event;
+        }
+    }
+
+    // Parse performances
+    if (doc.HasMember("performances") && doc["performances"].IsArray()) {
+        const Value& performances = doc["performances"];
+        for (SizeType i = 0; i < performances.Size(); i++) {
+            Performance perf;
+            const Value& p = performances[i];
+
+            if (p.HasMember("id") && p["id"].IsUint64())
+                perf.id = p["id"].GetUint64();
+            if (p.HasMember("eventId") && p["eventId"].IsUint64())
+                perf.eventId = p["eventId"].GetUint64();
+            if (p.HasMember("start") && p["start"].IsUint64())
+                perf.start = p["start"].GetUint64();
+            if (p.HasMember("venueCode") && p["venueCode"].IsString())
+                perf.venueCode = p["venueCode"].GetString();
+            if (p.HasMember("name") && p["name"].IsString())
+                perf.name = p["name"].GetString();
+
+            catalog.performances.push_back(perf);
+        }
+    }
+
+    // Parse other string maps
+    auto parseStringMap = [&doc](const char* key, std::map<std::string, std::string>& target) {
+        if (doc.HasMember(key) && doc[key].IsObject()) {
+            const Value& obj = doc[key];
+            for (auto it = obj.MemberBegin(); it != obj.MemberEnd(); ++it) {
+                if (it->value.IsString()) {
+                    target[it->name.GetString()] = it->value.GetString();
+                }
+            }
+        }
+    };
+
+    return catalog;
+}
+
+// RapidJSON serialization for CITM Catalog data
+std::string rapidjson_serialize_citm(const CitmCatalog& catalog) {
+    Document doc;
+    doc.SetObject();
+    Document::AllocatorType& allocator = doc.GetAllocator();
+
+    // Serialize events
+    Value events_obj(kObjectType);
+    for (const auto& [key, event] : catalog.events) {
+        Value event_obj(kObjectType);
+
+        if (event.description) {
+            Value desc;
+            desc.SetString(event.description->c_str(), allocator);
+            event_obj.AddMember("description", desc, allocator);
+        }
+
+        event_obj.AddMember("id", event.id, allocator);
+
+        if (event.logo) {
+            Value logo;
+            logo.SetString(event.logo->c_str(), allocator);
+            event_obj.AddMember("logo", logo, allocator);
+        }
+
+        Value name;
+        name.SetString(event.name.c_str(), allocator);
+        event_obj.AddMember("name", name, allocator);
+
+        if (event.subjectCode) {
+            Value subject;
+            subject.SetString(event.subjectCode->c_str(), allocator);
+            event_obj.AddMember("subjectCode", subject, allocator);
+        }
+
+        if (event.subtitle) {
+            Value subtitle;
+            subtitle.SetString(event.subtitle->c_str(), allocator);
+            event_obj.AddMember("subtitle", subtitle, allocator);
+        }
+
+        Value topicIds(kArrayType);
+        for (uint64_t id : event.topicIds) {
+            topicIds.PushBack(id, allocator);
+        }
+        event_obj.AddMember("topicIds", topicIds, allocator);
+
+        Value subTopicIds(kArrayType);
+        for (uint64_t id : event.subTopicIds) {
+            subTopicIds.PushBack(id, allocator);
+        }
+        event_obj.AddMember("subTopicIds", subTopicIds, allocator);
+
+        Value key_val;
+        key_val.SetString(key.c_str(), allocator);
+        events_obj.AddMember(key_val, event_obj, allocator);
+    }
+    doc.AddMember("events", events_obj, allocator);
+
+    // Serialize performances
+    Value performances_array(kArrayType);
+    for (const auto& perf : catalog.performances) {
+        Value perf_obj(kObjectType);
+        perf_obj.AddMember("id", perf.id, allocator);
+        perf_obj.AddMember("eventId", perf.eventId, allocator);
+        perf_obj.AddMember("start", perf.start, allocator);
+
+        Value venue;
+        venue.SetString(perf.venueCode.c_str(), allocator);
+        perf_obj.AddMember("venueCode", venue, allocator);
+
+        if (perf.name) {
+            Value name;
+            name.SetString(perf.name->c_str(), allocator);
+            perf_obj.AddMember("name", name, allocator);
+        }
+
+
+        performances_array.PushBack(perf_obj, allocator);
+    }
+    doc.AddMember("performances", performances_array, allocator);
+
+    StringBuffer buffer;
+    Writer<StringBuffer> writer(buffer);
+    doc.Accept(writer);
+
+    return buffer.GetString();
+}
+
+#endif // RAPIDJSON_CITM_CATALOG_DATA_H

benchmark/static_reflect/citm_catalog_benchmark/yyjson_citm_catalog_data.h

@@ -0,0 +1,231 @@
+#ifndef YYJSON_CITM_CATALOG_DATA_H
+#define YYJSON_CITM_CATALOG_DATA_H
+
+#include "citm_catalog_data.h"
+#include <yyjson.h>
+#include <string>
+#include <stdexcept>
+
+// yyjson deserialization for CITM Catalog data
+// Matches C++ CitmCatalog struct (only events + performances)
+CitmCatalog yyjson_deserialize_citm(const std::string &json_str) {
+    CitmCatalog catalog;
+
+    yyjson_doc *doc = yyjson_read(json_str.c_str(), json_str.size(), 0);
+    if (!doc) {
+        throw std::runtime_error("yyjson parse error");
+    }
+
+    yyjson_val *root = yyjson_doc_get_root(doc);
+    if (!root) {
+        yyjson_doc_free(doc);
+        return catalog;
+    }
+
+    // Parse events
+    yyjson_val *events_val = yyjson_obj_get(root, "events");
+    if (events_val && yyjson_is_obj(events_val)) {
+        size_t idx, max;
+        yyjson_val *key, *val;
+        yyjson_obj_foreach(events_val, idx, max, key, val) {
+            CITMEvent event;
+
+            yyjson_val *v;
+            v = yyjson_obj_get(val, "description");
+            if (v && yyjson_is_str(v)) event.description = yyjson_get_str(v);
+
+            v = yyjson_obj_get(val, "id");
+            if (v && yyjson_is_uint(v)) event.id = yyjson_get_uint(v);
+
+            v = yyjson_obj_get(val, "logo");
+            if (v && yyjson_is_str(v)) event.logo = yyjson_get_str(v);
+
+            v = yyjson_obj_get(val, "name");
+            if (v && yyjson_is_str(v)) event.name = yyjson_get_str(v);
+
+            v = yyjson_obj_get(val, "subjectCode");
+            if (v && yyjson_is_str(v)) event.subjectCode = yyjson_get_str(v);
+
+            v = yyjson_obj_get(val, "subtitle");
+            if (v && yyjson_is_str(v)) event.subtitle = yyjson_get_str(v);
+
+            // Parse topicIds array
+            v = yyjson_obj_get(val, "topicIds");
+            if (v && yyjson_is_arr(v)) {
+                size_t arr_idx, arr_max;
+                yyjson_val *arr_val;
+                yyjson_arr_foreach(v, arr_idx, arr_max, arr_val) {
+                    if (yyjson_is_uint(arr_val))
+                        event.topicIds.push_back(yyjson_get_uint(arr_val));
+                }
+            }
+
+            // Parse subTopicIds array
+            v = yyjson_obj_get(val, "subTopicIds");
+            if (v && yyjson_is_arr(v)) {
+                size_t arr_idx, arr_max;
+                yyjson_val *arr_val;
+                yyjson_arr_foreach(v, arr_idx, arr_max, arr_val) {
+                    if (yyjson_is_uint(arr_val))
+                        event.subTopicIds.push_back(yyjson_get_uint(arr_val));
+                }
+            }
+
+            if (yyjson_is_str(key))
+                catalog.events[yyjson_get_str(key)] = event;
+        }
+    }
+
+    // Parse performances (simplified - full parsing would need prices/seatCategories)
+    yyjson_val *performances_val = yyjson_obj_get(root, "performances");
+    if (performances_val && yyjson_is_arr(performances_val)) {
+        size_t idx, max;
+        yyjson_val *perf_val;
+        yyjson_arr_foreach(performances_val, idx, max, perf_val) {
+            CITMPerformance perf;
+
+            yyjson_val *v;
+            v = yyjson_obj_get(perf_val, "id");
+            if (v && yyjson_is_uint(v)) perf.id = yyjson_get_uint(v);
+
+            v = yyjson_obj_get(perf_val, "eventId");
+            if (v && yyjson_is_uint(v)) perf.eventId = yyjson_get_uint(v);
+
+            v = yyjson_obj_get(perf_val, "start");
+            if (v && yyjson_is_uint(v)) perf.start = yyjson_get_uint(v);
+
+            v = yyjson_obj_get(perf_val, "venueCode");
+            if (v && yyjson_is_str(v)) perf.venueCode = yyjson_get_str(v);
+
+            v = yyjson_obj_get(perf_val, "name");
+            if (v && yyjson_is_str(v)) perf.name = yyjson_get_str(v);
+
+            v = yyjson_obj_get(perf_val, "logo");
+            if (v && yyjson_is_str(v)) perf.logo = yyjson_get_str(v);
+
+            v = yyjson_obj_get(perf_val, "seatMapImage");
+            if (v && yyjson_is_str(v)) perf.seatMapImage = yyjson_get_str(v);
+
+            // Note: prices and seatCategories parsing omitted for brevity
+            // The serialization benchmark uses data loaded by simdjson
+
+            catalog.performances.push_back(perf);
+        }
+    }
+
+    yyjson_doc_free(doc);
+    return catalog;
+}
+
+// Helper to add optional string field
+static inline void yyjson_add_optional_str(yyjson_mut_doc *doc, yyjson_mut_val *obj,
+                                           const char *key, const std::optional<std::string> &val) {
+    if (val.has_value()) {
+        yyjson_mut_obj_add_str(doc, obj, key, val->c_str());
+    } else {
+        yyjson_mut_obj_add_null(doc, obj, key);
+    }
+}
+
+// yyjson serialization for CITM Catalog data
+// Matches C++ CitmCatalog struct exactly (only events + performances)
+std::string yyjson_serialize_citm(const CitmCatalog &catalog) {
+    yyjson_mut_doc *doc = yyjson_mut_doc_new(NULL);
+    yyjson_mut_val *root = yyjson_mut_obj(doc);
+    yyjson_mut_doc_set_root(doc, root);
+
+    // Create events object
+    yyjson_mut_val *events_obj = yyjson_mut_obj(doc);
+    for (const auto& [key, event] : catalog.events) {
+        yyjson_mut_val *event_obj = yyjson_mut_obj(doc);
+
+        yyjson_add_optional_str(doc, event_obj, "description", event.description);
+        yyjson_mut_obj_add_uint(doc, event_obj, "id", event.id);
+        yyjson_add_optional_str(doc, event_obj, "logo", event.logo);
+        // name is not optional in CITMEvent
+        yyjson_mut_obj_add_str(doc, event_obj, "name", event.name.c_str());
+
+        // Add subTopicIds array
+        yyjson_mut_val *subtopic_ids = yyjson_mut_arr(doc);
+        for (uint64_t id : event.subTopicIds) {
+            yyjson_mut_arr_add_uint(doc, subtopic_ids, id);
+        }
+        yyjson_mut_obj_add_val(doc, event_obj, "subTopicIds", subtopic_ids);
+
+        yyjson_add_optional_str(doc, event_obj, "subjectCode", event.subjectCode);
+        yyjson_add_optional_str(doc, event_obj, "subtitle", event.subtitle);
+
+        // Add topicIds array
+        yyjson_mut_val *topic_ids = yyjson_mut_arr(doc);
+        for (uint64_t id : event.topicIds) {
+            yyjson_mut_arr_add_uint(doc, topic_ids, id);
+        }
+        yyjson_mut_obj_add_val(doc, event_obj, "topicIds", topic_ids);
+
+        yyjson_mut_obj_add_val(doc, events_obj, key.c_str(), event_obj);
+    }
+    yyjson_mut_obj_add_val(doc, root, "events", events_obj);
+
+    // Create performances array
+    yyjson_mut_val *performances_array = yyjson_mut_arr(doc);
+    for (const auto& perf : catalog.performances) {
+        yyjson_mut_val *perf_obj = yyjson_mut_obj(doc);
+
+        yyjson_mut_obj_add_uint(doc, perf_obj, "eventId", perf.eventId);
+        yyjson_mut_obj_add_uint(doc, perf_obj, "id", perf.id);
+        yyjson_add_optional_str(doc, perf_obj, "logo", perf.logo);
+        yyjson_add_optional_str(doc, perf_obj, "name", perf.name);
+
+        // Add prices array
+        yyjson_mut_val *prices_array = yyjson_mut_arr(doc);
+        for (const auto& price : perf.prices) {
+            yyjson_mut_val *price_obj = yyjson_mut_obj(doc);
+            yyjson_mut_obj_add_uint(doc, price_obj, "amount", price.amount);
+            yyjson_mut_obj_add_uint(doc, price_obj, "audienceSubCategoryId", price.audienceSubCategoryId);
+            yyjson_mut_obj_add_uint(doc, price_obj, "seatCategoryId", price.seatCategoryId);
+            yyjson_mut_arr_append(prices_array, price_obj);
+        }
+        yyjson_mut_obj_add_val(doc, perf_obj, "prices", prices_array);
+
+        // Add seatCategories array
+        yyjson_mut_val *seat_cats_array = yyjson_mut_arr(doc);
+        for (const auto& seatCat : perf.seatCategories) {
+            yyjson_mut_val *seat_cat_obj = yyjson_mut_obj(doc);
+
+            // Add areas array
+            yyjson_mut_val *areas_array = yyjson_mut_arr(doc);
+            for (const auto& area : seatCat.areas) {
+                yyjson_mut_val *area_obj = yyjson_mut_obj(doc);
+                yyjson_mut_obj_add_uint(doc, area_obj, "areaId", area.areaId);
+
+                yyjson_mut_val *block_ids = yyjson_mut_arr(doc);
+                for (uint64_t blockId : area.blockIds) {
+                    yyjson_mut_arr_add_uint(doc, block_ids, blockId);
+                }
+                yyjson_mut_obj_add_val(doc, area_obj, "blockIds", block_ids);
+                yyjson_mut_arr_append(areas_array, area_obj);
+            }
+            yyjson_mut_obj_add_val(doc, seat_cat_obj, "areas", areas_array);
+            yyjson_mut_obj_add_uint(doc, seat_cat_obj, "seatCategoryId", seatCat.seatCategoryId);
+            yyjson_mut_arr_append(seat_cats_array, seat_cat_obj);
+        }
+        yyjson_mut_obj_add_val(doc, perf_obj, "seatCategories", seat_cats_array);
+
+        yyjson_add_optional_str(doc, perf_obj, "seatMapImage", perf.seatMapImage);
+        yyjson_mut_obj_add_uint(doc, perf_obj, "start", perf.start);
+        yyjson_mut_obj_add_str(doc, perf_obj, "venueCode", perf.venueCode.c_str());
+
+        yyjson_mut_arr_append(performances_array, perf_obj);
+    }
+    yyjson_mut_obj_add_val(doc, root, "performances", performances_array);
+
+    // Write to string
+    char *json_output = yyjson_mut_write(doc, 0, NULL);
+    std::string result(json_output);
+    free(json_output);
+    yyjson_mut_doc_free(doc);
+
+    return result;
+}
+
+#endif // YYJSON_CITM_CATALOG_DATA_H

benchmark/static_reflect/serde-benchmark/lib.rs

@@ -5,405 +5,165 @@ 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,
-}
+//==============================================================================
+// Twitter Benchmark Structures
+// These match the C++ TwitterData structures exactly
+//==============================================================================
 
 #[derive(Serialize, Deserialize)]
 pub struct User {
-    id: i64,
-    id_str: String,
+    id: u64,
     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>,
+    followers_count: u64,
+    friends_count: u64,
+    statuses_count: u64,
 }
 
 #[derive(Serialize, Deserialize)]
 pub struct Status {
     created_at: String,
-    id: i64,
+    id: u64,
     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,
-    */
+    retweet_count: u64,
+    favorite_count: u64,
 }
 
 #[derive(Serialize, Deserialize)]
 pub struct TwitterData {
     statuses: Vec<Status>,
 }
+static mut TWITTER_DATA: *mut TwitterData = std::ptr::null_mut();
 
 #[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(),
-  }
+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()
+pub unsafe extern "C" fn set_twitter_data(raw: *mut TwitterData) {
+    TWITTER_DATA = raw;
 }
 
+#[no_mangle]
+pub unsafe extern "C" fn serialize_twitter_to_string() -> usize {
+    if TWITTER_DATA.is_null() {
+        return 0;
+    }
+    let data = &*TWITTER_DATA;
+    serde_json::to_string(data).unwrap().len()
+}
 
 #[no_mangle]
 pub unsafe extern "C" fn free_twitter(raw: *mut TwitterData) {
-  if raw.is_null() {
-    return;
-  }
-
-  drop(Box::from_raw(raw))
+    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
+//==============================================================================
+// CITM Catalog Benchmark Structures
+// These match the C++ CitmCatalog structures EXACTLY for fair comparison
+//==============================================================================
 
-#[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>,
+/// Matches C++ CITMPrice struct exactly
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct CITMPrice {
+    pub amount: u64,
+    #[serde(rename = "audienceSubCategoryId")]
+    pub audience_sub_category_id: u64,
+    #[serde(rename = "seatCategoryId")]
+    pub seat_category_id: u64,
 }
 
-#[derive(Serialize, Deserialize)]
-pub struct AudienceSubCategory {
-    pub id: i64,
-    pub name: Option<String>,  // Changed to Option
-    pub parent: i64,
+/// Matches C++ CITMArea struct exactly
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct CITMArea {
+    #[serde(rename = "areaId")]
+    pub area_id: u64,
+    #[serde(rename = "blockIds")]
+    pub block_ids: Vec<u64>,
 }
 
-#[derive(Serialize, Deserialize, Debug)]
-pub struct Event {
-    #[serde(default)]
-    pub description: Option<String>,
-    pub id: i64,
+/// Matches C++ CITMSeatCategory struct exactly
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct CITMSeatCategory {
+    pub areas: Vec<CITMArea>,
+    #[serde(rename = "seatCategoryId")]
+    pub seat_category_id: u64,
+}
+
+/// Matches C++ CITMPerformance struct exactly
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct CITMPerformance {
+    pub id: u64,
+    #[serde(rename = "eventId")]
+    pub event_id: u64,
     #[serde(default)]
     pub logo: Option<String>,
     #[serde(default)]
     pub name: Option<String>,
+    pub prices: Vec<CITMPrice>,
+    #[serde(rename = "seatCategories")]
+    pub seat_categories: Vec<CITMSeatCategory>,
     #[serde(default)]
-    pub subTopicIds: Vec<i64>,
+    #[serde(rename = "seatMapImage")]
+    pub seat_map_image: Option<String>,
+    pub start: u64,
+    #[serde(rename = "venueCode")]
+    pub venue_code: String,
+}
+
+/// Matches C++ CITMEvent struct exactly
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct CITMEvent {
+    pub id: u64,
     #[serde(default)]
-    pub subjectCode: Option<String>,
+    pub name: Option<String>,
+    #[serde(default)]
+    pub description: Option<String>,
+    #[serde(default)]
+    pub logo: Option<String>,
+    #[serde(default)]
+    #[serde(rename = "subTopicIds")]
+    pub sub_topic_ids: Vec<u64>,
+    #[serde(default)]
+    #[serde(rename = "subjectCode")]
+    pub subject_code: 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)
+    #[serde(rename = "topicIds")]
+    pub topic_ids: Vec<u64>,
 }
 
+/// Matches C++ CitmCatalog struct exactly - ONLY events and performances
+/// This is the key fix: we serialize only what C++ serializes
 #[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>,
+    pub events: HashMap<String, CITMEvent>,
+    pub performances: Vec<CITMPerformance>,
 }
 
+static mut CITM_DATA: *mut CitmCatalog = std::ptr::null_mut();
+
 /// Creates a CitmCatalog from a JSON string (UTF-8 encoded).
+/// Only extracts events and performances to match C++ behavior.
 #[no_mangle]
 pub unsafe extern "C" fn citm_from_str(
     raw_input: *const c_char,
@@ -414,7 +174,6 @@ pub unsafe extern "C" fn citm_from_str(
         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,
@@ -424,12 +183,23 @@ pub unsafe extern "C" fn citm_from_str(
         }
     };
 
-    // Try deserializing the input string into CitmCatalog
-    match serde_json::from_str::<CitmCatalog>(input_str) {
-        Ok(catalog) => Box::into_raw(Box::new(catalog)),
+    // Parse the full JSON to extract only events and performances
+    match serde_json::from_str::<serde_json::Value>(input_str) {
+        Ok(full_json) => {
+            // Extract only the fields we need (matching C++ behavior)
+            let events: HashMap<String, CITMEvent> = full_json.get("events")
+                .and_then(|v| serde_json::from_value(v.clone()).ok())
+                .unwrap_or_default();
+
+            let performances: Vec<CITMPerformance> = full_json.get("performances")
+                .and_then(|v| serde_json::from_value(v.clone()).ok())
+                .unwrap_or_default();
+
+            let catalog = CitmCatalog { events, performances };
+            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()
         }
     }
@@ -437,30 +207,17 @@ pub unsafe extern "C" fn citm_from_str(
 
 /// 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();
-    }
+pub unsafe extern "C" fn set_citm_data(raw: *mut CitmCatalog) {
+    CITM_DATA = raw;
+}
 
-    // 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()
-        }
+#[no_mangle]
+pub unsafe extern "C" fn serialize_citm_to_string() -> usize {
+    if CITM_DATA.is_null() {
+        return 0;
     }
+    let data = &*CITM_DATA;
+    return serde_json::to_string(data).unwrap().len();
 }
 
 /// Frees the CitmCatalog pointer.
@@ -475,8 +232,120 @@ pub unsafe extern "C" fn free_citm(raw_catalog: *mut CitmCatalog) {
 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);
         }
     }
-}
+}
+
+//==============================================================================
+// FFI Overhead Measurement Functions
+// These allow measuring the actual FFI overhead vs pure Rust serialization
+//==============================================================================
+
+/// Result structure for FFI overhead measurement
+#[repr(C)]
+pub struct FfiOverheadResult {
+    /// Time in nanoseconds for pure serde_json::to_string() (no FFI overhead)
+    pub pure_serde_ns: u64,
+    /// Time in nanoseconds for serde + CString conversion
+    pub serde_plus_cstring_ns: u64,
+    /// Number of iterations performed
+    pub iterations: u64,
+    /// Output size in bytes (for verification)
+    pub output_size: u64,
+}
+
+/// Prevents compiler from optimizing away the value
+/// Works on stable Rust (unlike std::hint::black_box which is unstable)
+#[inline(never)]
+fn black_box<T>(dummy: T) -> T {
+    unsafe {
+        let ret = std::ptr::read_volatile(&dummy);
+        std::mem::forget(dummy);
+        ret
+    }
+}
+
+/// Measures FFI overhead for Twitter serialization.
+/// Performs `iterations` serializations entirely in Rust and returns timing data.
+/// This allows comparing against per-call FFI overhead.
+#[no_mangle]
+pub unsafe extern "C" fn measure_twitter_ffi_overhead(
+    raw: *mut TwitterData,
+    iterations: u64
+) -> FfiOverheadResult {
+    use std::time::Instant;
+
+    let twitter_data = &*raw;
+    let output_size: u64;
+
+    // Warm-up run
+    let warmup = serde_json::to_string(&twitter_data).unwrap();
+    output_size = warmup.len() as u64;
+
+    // Measure pure serde_json::to_string() - no CString conversion
+    let start_pure = Instant::now();
+    for _ in 0..iterations {
+        let serialized = serde_json::to_string(&twitter_data).unwrap();
+        // Prevent optimization from eliminating the work
+        black_box(&serialized);
+    }
+    let pure_serde_ns = start_pure.elapsed().as_nanos() as u64;
+
+    // Measure serde + CString conversion (but not FFI return)
+    let start_cstring = Instant::now();
+    for _ in 0..iterations {
+        let serialized = serde_json::to_string(&twitter_data).unwrap();
+        let cstring = CString::new(serialized).unwrap();
+        // Prevent optimization from eliminating the work
+        black_box(&cstring);
+    }
+    let serde_plus_cstring_ns = start_cstring.elapsed().as_nanos() as u64;
+
+    FfiOverheadResult {
+        pure_serde_ns,
+        serde_plus_cstring_ns,
+        iterations,
+        output_size,
+    }
+}
+
+/// Measures FFI overhead for CITM serialization.
+#[no_mangle]
+pub unsafe extern "C" fn measure_citm_ffi_overhead(
+    raw: *mut CitmCatalog,
+    iterations: u64
+) -> FfiOverheadResult {
+    use std::time::Instant;
+
+    let catalog = &*raw;
+    let output_size: u64;
+
+    // Warm-up run
+    let warmup = serde_json::to_string(&catalog).unwrap();
+    output_size = warmup.len() as u64;
+
+    // Measure pure serde_json::to_string() - no CString conversion
+    let start_pure = Instant::now();
+    for _ in 0..iterations {
+        let serialized = serde_json::to_string(&catalog).unwrap();
+        black_box(&serialized);
+    }
+    let pure_serde_ns = start_pure.elapsed().as_nanos() as u64;
+
+    // Measure serde + CString conversion
+    let start_cstring = Instant::now();
+    for _ in 0..iterations {
+        let serialized = serde_json::to_string(&catalog).unwrap();
+        let cstring = CString::new(serialized).unwrap();
+        black_box(&cstring);
+    }
+    let serde_plus_cstring_ns = start_cstring.elapsed().as_nanos() as u64;
+
+    FfiOverheadResult {
+        pure_serde_ns,
+        serde_plus_cstring_ns,
+        iterations,
+        output_size,
+    }
+}

benchmark/static_reflect/serde-benchmark/serde_benchmark.h

@@ -4,6 +4,7 @@
 /* Generated with cbindgen:0.28.0 */
 
 /* Warning, this file is autogenerated by cbindgen. Don't modify this manually. */
+/* Note: FfiOverheadResult and measurement functions added manually */
 
 #include <cstdarg>
 #include <cstdint>
@@ -17,11 +18,25 @@ struct CitmCatalog;
 
 struct TwitterData;
 
+/// Result structure for FFI overhead measurement
+struct FfiOverheadResult {
+    /// Time in nanoseconds for pure serde_json::to_string() (no FFI overhead)
+    uint64_t pure_serde_ns;
+    /// Time in nanoseconds for serde + CString conversion
+    uint64_t serde_plus_cstring_ns;
+    /// Number of iterations performed
+    uint64_t iterations;
+    /// Output size in bytes (for verification)
+    uint64_t output_size;
+};
+
 extern "C" {
 
 TwitterData *twitter_from_str(const char *raw_input, size_t raw_input_length);
 
-const char *str_from_twitter(TwitterData *raw);
+void set_twitter_data(TwitterData *raw);
+
+size_t serialize_twitter_to_string();
 
 void free_twitter(TwitterData *raw);
 
@@ -30,14 +45,22 @@ 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);
+void set_citm_data(CitmCatalog *raw);
+
+size_t serialize_citm_to_string();
 
 /// Frees the CitmCatalog pointer.
 void free_citm(CitmCatalog *raw_catalog);
 
 void free_str(char *ptr);
 
+/// Measures FFI overhead for Twitter serialization.
+/// Performs `iterations` serializations entirely in Rust and returns timing data.
+FfiOverheadResult measure_twitter_ffi_overhead(TwitterData *raw, uint64_t iterations);
+
+/// Measures FFI overhead for CITM serialization.
+FfiOverheadResult measure_citm_ffi_overhead(CitmCatalog *raw, uint64_t iterations);
+
 }  // extern "C"
 
 }  // namespace serde_benchmark

benchmark/static_reflect/serde-benchmark/src/main.rs

@@ -0,0 +1,31 @@
+use std::fs;
+
+// Include the lib.rs content directly
+include!("../lib.rs");
+
+fn main() {
+    // Read the Twitter JSON file
+    let json_str = fs::read_to_string("/Users/random_person/Desktop/simdjson/build/jsonexamples/twitter.json")
+        .expect("Failed to read file");
+
+    // Parse it
+    let data: TwitterData = serde_json::from_str(&json_str)
+        .expect("Failed to parse JSON");
+
+    // Serialize it back
+    let output = serde_json::to_string(&data)
+        .expect("Failed to serialize");
+
+    // Write to file for comparison
+    fs::write("rust_output.json", &output)
+        .expect("Failed to write output");
+
+    println!("Output size: {} bytes", output.len());
+    println!("Written to rust_output.json");
+
+    // Also write pretty version for easier inspection
+    let pretty = serde_json::to_string_pretty(&data)
+        .expect("Failed to serialize pretty");
+    fs::write("rust_output_pretty.json", &pretty)
+        .expect("Failed to write pretty output");
+}

benchmark/static_reflect/serde-benchmark/src/test_output.rs

@@ -0,0 +1,36 @@
+use std::fs;
+
+// Import from the parent lib.rs
+include!("../lib.rs");
+
+fn main() {
+    // Read the Twitter JSON file
+    let json_str = fs::read_to_string("/Users/random_person/Desktop/simdjson/build/jsonexamples/twitter.json")
+        .expect("Failed to read file");
+
+    // Parse it
+    let data: TwitterData = serde_json::from_str(&json_str)
+        .expect("Failed to parse JSON");
+
+    // Serialize it back (compact)
+    let output = serde_json::to_vec(&data)
+        .expect("Failed to serialize");
+    
+    let output_str = String::from_utf8(output.clone()).unwrap();
+
+    // Write to file for comparison
+    fs::write("rust_output_test.json", &output)
+        .expect("Failed to write output");
+
+    println!("Output size: {} bytes", output.len());
+    
+    // Count statuses
+    println!("Number of statuses: {}", data.statuses.len());
+    
+    // Check what fields are in the first status
+    if let Some(first) = data.statuses.first() {
+        // Let's serialize just the first status to see what fields are included
+        let first_json = serde_json::to_string_pretty(first).unwrap();
+        println!("First status (pretty):\n{}", first_json);
+    }
+}

benchmark/static_reflect/twitter_benchmark/CMakeLists.txt

@@ -1,14 +1,32 @@
 
 # Add executable targets
 add_executable(benchmark_serialization_twitter benchmark_serialization_twitter.cpp)
+add_executable(benchmark_parsing_twitter benchmark_parsing_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_link_libraries(benchmark_parsing_twitter PRIVATE serde-benchmark)
     target_compile_definitions(benchmark_serialization_twitter PRIVATE SIMDJSON_RUST_VERSION="${Rust_VERSION}")
+    target_compile_definitions(benchmark_parsing_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}")
+target_link_libraries(benchmark_parsing_twitter PRIVATE simdjson::simdjson nlohmann_json)
+
+if(TARGET rapidjson)
+    target_link_libraries(benchmark_parsing_twitter PRIVATE rapidjson)
+    target_compile_definitions(benchmark_parsing_twitter PRIVATE SIMDJSON_COMPETITION_RAPIDJSON)
+endif()
+
+if(TARGET yyjson)
+    target_link_libraries(benchmark_parsing_twitter PRIVATE yyjson)
+    target_compile_definitions(benchmark_parsing_twitter PRIVATE SIMDJSON_COMPETITION_YYJSON)
+    target_link_libraries(benchmark_serialization_twitter PRIVATE yyjson)
+    target_compile_definitions(benchmark_serialization_twitter PRIVATE SIMDJSON_COMPETITION_YYJSON)
+endif()
+
+target_compile_definitions(benchmark_serialization_twitter PRIVATE JSON_FILE="${EXAMPLE_JSON}")
+target_compile_definitions(benchmark_parsing_twitter PRIVATE JSON_FILE="${EXAMPLE_JSON}")

benchmark/static_reflect/twitter_benchmark/benchmark_parsing_twitter.cpp

@@ -0,0 +1,232 @@
+#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"
+#ifdef SIMDJSON_COMPETITION_RAPIDJSON
+#include "rapidjson_twitter_data.h"
+#endif
+#ifdef SIMDJSON_COMPETITION_YYJSON
+#include "yyjson_twitter_data.h"
+#endif
+
+#ifdef SIMDJSON_RUST_VERSION
+#include "../serde-benchmark/serde_benchmark.h"
+
+void bench_rust_parsing(const std::string &json_str) {
+  size_t input_volume = json_str.size();
+  printf("# input volume: %zu bytes\n", input_volume);
+
+  volatile bool result = true;
+  pretty_print(1, input_volume, "bench_rust_parsing",
+               bench([&json_str, &result]() {
+                 serde_benchmark::TwitterData *td = serde_benchmark::twitter_from_str(json_str.c_str(), json_str.size());
+                 result = (td != nullptr);
+                 if (td) {
+                   serde_benchmark::free_twitter(td);
+                 }
+                 if (!result) {
+                   printf("parse error\n");
+                 }
+               }));
+}
+#endif
+
+// OPTIMIZED VERSION: Reuses parser across iterations
+template <class T>
+void bench_simdjson_static_reflection_parsing(const std::string &json_str) {
+  size_t input_volume = json_str.size();
+  printf("# input volume: %zu bytes\n", input_volume);
+
+  // Pre-allocate padded buffer outside the benchmark loop
+  simdjson::padded_string padded = simdjson::padded_string(json_str);
+
+  // CRITICAL: Create parser OUTSIDE the loop for reuse
+  simdjson::ondemand::parser parser;
+
+  volatile bool result = true;
+  pretty_print(1, input_volume, "bench_simdjson_static_reflection_parsing",
+               bench([&padded, &result, &parser]() {
+                 // Reuse the same parser instance
+                 simdjson::ondemand::document doc;
+                 if(parser.iterate(padded).get(doc)) {
+                   result = false;
+                   return;
+                 }
+                 T my_struct;
+                 if(doc.get<T>().get(my_struct)) {
+                   result = false;
+                 }
+                 if (!result) {
+                   printf("parse error\n");
+                 }
+               }));
+}
+
+#if SIMDJSON_STATIC_REFLECTION
+template <class T>
+void bench_simdjson_from_parsing(const std::string &json_str) {
+  size_t input_volume = json_str.size();
+  printf("# input volume: %zu bytes\n", input_volume);
+
+  // Pre-allocate padded buffer outside the benchmark loop
+  simdjson::padded_string padded = simdjson::padded_string(json_str);
+
+  volatile bool result = true;
+  pretty_print(1, input_volume, "bench_simdjson_from_parsing",
+               bench([&padded, &result]() {
+                 T my_struct;
+                 auto err = simdjson::from(padded).get(my_struct);
+                  if (err) {
+                    result = false;
+                    printf("parse error: %s\n", simdjson::error_message(err));
+                    return;
+                  }
+               }));
+}
+#endif
+
+ void bench_nlohmann_parsing(const std::string &json_str) {
+   size_t input_volume = json_str.size();
+   printf("# input volume: %zu bytes\n", input_volume);
+
+   volatile bool result = true;
+   pretty_print(1, input_volume, "bench_nlohmann_parsing",
+                bench([&json_str, &result]() {
+                  try {
+                    TwitterData data = nlohmann_deserialize(json_str);
+                    result = true;
+                  } catch (...) {
+                    result = false;
+                    printf("parse error\n");
+                  }
+                }));
+}
+
+#ifdef SIMDJSON_COMPETITION_RAPIDJSON
+void bench_rapidjson_parsing(const std::string &json_str) {
+  size_t input_volume = json_str.size();
+  printf("# input volume: %zu bytes\n", input_volume);
+
+  volatile bool result = true;
+  pretty_print(1, input_volume, "bench_rapidjson_parsing",
+               bench([&json_str, &result]() {
+                 try {
+                   TwitterData data = rapidjson_deserialize(json_str);
+                   result = true;
+                 } catch (...) {
+                   result = false;
+                   printf("parse error\n");
+                 }
+               }));
+}
+#endif
+
+#ifdef SIMDJSON_COMPETITION_YYJSON
+void bench_yyjson_parsing(const std::string &json_str) {
+  size_t input_volume = json_str.size();
+  printf("# input volume: %zu bytes\n", input_volume);
+
+  volatile bool result = true;
+  pretty_print(1, input_volume, "bench_yyjson_parsing",
+               bench([&json_str, &result]() {
+                 try {
+                   TwitterData data = yyjson_deserialize(json_str);
+                   result = true;
+                 } catch (...) {
+                   result = false;
+                   printf("parse error\n");
+                 }
+               }));
+}
+#endif
+
+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 matches any of the comma-separated filters
+bool matches_filter(const std::string& benchmark_name, const std::string& filter) {
+  if (filter.empty()) return true;
+
+  // Split filter by comma
+  size_t start = 0;
+  size_t end = filter.find(',');
+  while (end != std::string::npos) {
+    std::string token = filter.substr(start, end - start);
+    if (benchmark_name.find(token) != std::string::npos) {
+      return true;
+    }
+    start = end + 1;
+    end = filter.find(',', start);
+  }
+  // Check last token
+  std::string token = filter.substr(start);
+  return benchmark_name.find(token) != 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;
+          }
+      }
+  }
+
+  // Load the JSON data
+  std::string json_str = read_file(JSON_FILE);
+
+  // Benchmarking the parsing
+  if (matches_filter("nlohmann", filter)) {
+    bench_nlohmann_parsing(json_str);
+  }
+#ifdef SIMDJSON_COMPETITION_RAPIDJSON
+  if (matches_filter("rapidjson", filter)) {
+    bench_rapidjson_parsing(json_str);
+  }
+#endif
+#ifdef SIMDJSON_COMPETITION_YYJSON
+  if (matches_filter("yyjson", filter)) {
+    bench_yyjson_parsing(json_str);
+  }
+#endif
+  if (matches_filter("simdjson_static_reflection", filter)) {
+    bench_simdjson_static_reflection_parsing<TwitterData>(json_str);
+  }
+#if SIMDJSON_STATIC_REFLECTION
+  if (matches_filter("simdjson_from", filter)) {
+    bench_simdjson_from_parsing<TwitterData>(json_str);
+  }
+#endif
+#ifdef SIMDJSON_RUST_VERSION
+  if (matches_filter("rust", filter)) {
+    printf("# Note: Rust/Serde parsing test\n");
+    bench_rust_parsing(json_str);
+  }
+#endif
+  return EXIT_SUCCESS;
+}

benchmark/static_reflect/twitter_benchmark/benchmark_serialization_twitter.cpp

@@ -1,4 +1,5 @@
 #include <cassert>
+#include <chrono>
 #include <cstdlib>
 #include <ctime>
 #include <format>
@@ -10,6 +11,9 @@
 #include "twitter_data.h"
 #include "nlohmann_twitter_data.h"
 #include "../benchmark_utils/benchmark_helper.h"
+#ifdef SIMDJSON_COMPETITION_YYJSON
+#include "yyjson_twitter_data.h"
+#endif
 #if SIMDJSON_BENCH_CPP_REFLECT
 #include <rfl.hpp>
 #include <rfl/json.hpp>
@@ -35,19 +39,49 @@ void bench_reflect_cpp(TwitterData &data) {
 
 
 void bench_rust(serde_benchmark::TwitterData *data) {
-  const char * output = serde_benchmark::str_from_twitter(data);
-  size_t output_volume = strlen(output);
+  serde_benchmark::set_twitter_data(data);
+  size_t output_volume = serde_benchmark::serialize_twitter_to_string();
   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);
+               bench([&measured_volume, &output_volume]() {
+                 measured_volume = serde_benchmark::serialize_twitter_to_string();
                }));
 }
 #endif
 
+// Fair allocation variant: allocates fresh buffer each iteration (matches other libraries)
 template <class T> void bench_simdjson_static_reflection(T &data) {
+  // First run to determine expected size
+  simdjson::builder::string_builder sb_init;
+  simdjson::builder::append(sb_init, data);
+  std::string_view p_init;
+  if(sb_init.view().get(p_init)) {
+    std::cerr << "Error!" << std::endl;
+  }
+  size_t output_volume = p_init.size();
+  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]() {
+                 // Fresh allocation each iteration - fair comparison
+                 simdjson::builder::string_builder sb;
+                 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");
+                 }
+               }));
+}
+
+// Optimized variant: reuses buffer across iterations (shows API potential)
+template <class T> void bench_simdjson_static_reflection_reuse(T &data) {
   simdjson::builder::string_builder sb;
   simdjson::builder::append(sb, data);
   std::string_view p;
@@ -59,7 +93,7 @@ template <class T> void bench_simdjson_static_reflection(T &data) {
   printf("# output volume: %zu bytes\n", output_volume);
 
   volatile size_t measured_volume = 0;
-  pretty_print(sizeof(data), output_volume, "bench_simdjson_static_reflection",
+  pretty_print(sizeof(data), output_volume, "bench_simdjson_reuse_buffer",
                bench([&data, &measured_volume, &output_volume, &sb]() {
                  sb.clear();
                  simdjson::builder::append(sb, data);
@@ -74,6 +108,63 @@ template <class T> void bench_simdjson_static_reflection(T &data) {
                }));
 }
 
+#if SIMDJSON_STATIC_REFLECTION
+// Fair allocation variant: allocates fresh string each iteration
+template <class T> void bench_simdjson_to(T &data) {
+  // First run to determine size
+  std::string output_init;
+  if (simdjson::error_code err = simdjson::builder::to_json(data, output_init); err) {
+    std::cerr << "Error in to_json initialization!" << simdjson::error_message(err) << std::endl;
+    return;
+  }
+  size_t output_volume = output_init.size();
+  printf("# output volume: %zu bytes\n", output_volume);
+
+  volatile size_t measured_volume = 0;
+  pretty_print(sizeof(data), output_volume, "bench_simdjson_to",
+               bench([&data, &measured_volume, &output_volume]() {
+                 // Fresh allocation each iteration - fair comparison
+                 std::string output;
+                 if (simdjson::error_code err = simdjson::builder::to_json(data, output); err) {
+                   std::cerr << "Error in to_json!" << simdjson::error_message(err) << std::endl;
+                   return;
+                 }
+                 measured_volume = output.size();
+                 if (measured_volume != output_volume) {
+                   printf("mismatch\n");
+                 }
+               }));
+}
+
+// Optimized variant: reuses pre-allocated string
+template <class T> void bench_simdjson_to_reuse(T &data) {
+  std::string output;
+  if (simdjson::error_code err = simdjson::builder::to_json(data, output); err) {
+    std::cerr << "Error in to_json initialization!" << simdjson::error_message(err) << std::endl;
+    return;
+  }
+  size_t output_volume = output.size();
+  printf("# output volume: %zu bytes\n", output_volume);
+
+  // Pre-allocate string with sufficient capacity to avoid reallocation
+  output.reserve(output_volume * 2);
+
+  volatile size_t measured_volume = 0;
+  pretty_print(sizeof(data), output_volume, "bench_simdjson_to_reuse",
+               bench([&data, &measured_volume, &output_volume, &output]() {
+                 // Reuse the pre-allocated string - avoids allocation
+                 if (simdjson::error_code err = simdjson::builder::to_json(data, output); err) {
+                   std::cerr << "Error in to_json!" << simdjson::error_message(err) << std::endl;
+                   return;
+                 }
+                 measured_volume = output.size();
+                 if (measured_volume != output_volume) {
+                   printf("mismatch\n");
+                 }
+               }));
+}
+#endif
+
 void bench_nlohmann(TwitterData &data) {
   std::string output = nlohmann_serialize(data);
   size_t output_volume = output.size();
@@ -90,28 +181,61 @@ void bench_nlohmann(TwitterData &data) {
                }));
 }
 
+#ifdef SIMDJSON_COMPETITION_YYJSON
+void bench_yyjson(TwitterData &data) {
+  std::string output = yyjson_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_yyjson",
+               bench([&data, &measured_volume, &output_volume]() {
+                 std::string output = yyjson_serialize(data);
+                 measured_volume = output.size();
+                 if (measured_volume != output_volume) {
+                   printf("mismatch\n");
+                 }
+               }));
+}
+#endif
+
 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) {
+simdjson::padded_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;
+  simdjson::padded_string_builder builder;
   std::string buf(read_size, '\0');
   while (stream.read(&buf[0], read_size)) {
-    out.append(buf, 0, size_t(stream.gcount()));
+    builder.append(buf.data(), size_t(stream.gcount()));
   }
-  out.append(buf, 0, size_t(stream.gcount()));
-  return out;
+  builder.append(buf.data(), size_t(stream.gcount()));
+  return builder.convert();
 }
 
-// Function to check if benchmark name contains filter substring
+// Function to check if benchmark name matches any of the comma-separated filters
 bool matches_filter(const std::string& benchmark_name, const std::string& filter) {
-  return filter.empty() || benchmark_name.find(filter) != std::string::npos;
+  if (filter.empty()) return true;
+
+  // Split filter by comma
+  size_t start = 0;
+  size_t end = filter.find(',');
+  while (end != std::string::npos) {
+    std::string token = filter.substr(start, end - start);
+    if (benchmark_name.find(token) != std::string::npos) {
+      return true;
+    }
+    start = end + 1;
+    end = filter.find(',', start);
+  }
+  // Check last token
+  std::string token = filter.substr(start);
+  return benchmark_name.find(token) != std::string::npos;
 }
 
 int main(int argc, char* argv[]) {
@@ -129,12 +253,12 @@ int main(int argc, char* argv[]) {
       }
   }
   // Testing correctness of round-trip (serialization + deserialization)
-  std::string json_str = read_file(JSON_FILE);
+  simdjson::padded_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)) {
+  if(parser.iterate(json_str).get(doc)) {
     std::cerr << "Error loading the document!" << std::endl;
     return EXIT_FAILURE;
   }
@@ -145,18 +269,41 @@ int main(int argc, char* argv[]) {
   }
 
   // Benchmarking the serialization
+  // Note: simdjson benchmarks include both "fair" (fresh allocation) and "reuse" (buffer reuse) variants
+  // The "fair" variants allocate fresh memory each iteration, matching other libraries' behavior
+  // The "reuse" variants demonstrate the API's potential when buffer reuse is possible
+
   if (matches_filter("nlohmann", filter)) {
     bench_nlohmann(my_struct);
   }
+#ifdef SIMDJSON_COMPETITION_YYJSON
+  if (matches_filter("yyjson", filter)) {
+    bench_yyjson(my_struct);
+  }
+#endif
   if (matches_filter("simdjson_static_reflection", filter)) {
     bench_simdjson_static_reflection(my_struct);
   }
+  if (matches_filter("simdjson_reuse", filter)) {
+    bench_simdjson_static_reflection_reuse(my_struct);
+  }
+#if SIMDJSON_STATIC_REFLECTION
+  if (matches_filter("simdjson_to", filter)) {
+    bench_simdjson_to(my_struct);
+  }
+  if (matches_filter("simdjson_to_reuse", filter)) {
+    bench_simdjson_to_reuse(my_struct);
+  }
+#endif
 #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);
+    serde_benchmark::TwitterData * td = serde_benchmark::twitter_from_str(json_str.data(), json_str.size());
+    if (td == nullptr) {
+      printf("# Failed to parse Twitter data for Rust benchmark\n");
+    } else {
+      bench_rust(td);
+      serde_benchmark::free_twitter(td);
+    }
   }
 #endif
 #if SIMDJSON_BENCH_CPP_REFLECT

benchmark/static_reflect/twitter_benchmark/nlohmann_twitter_data.h

@@ -4,6 +4,7 @@
 #include "twitter_data.h"
 #include <nlohmann/json.hpp>
 
+// Serialization functions for nlohmann
 void to_json(nlohmann::json &j, const User &u) {
   j = nlohmann::json{{"id", u.id},
                      {"name", u.name},
@@ -16,101 +17,54 @@ void to_json(nlohmann::json &j, const User &u) {
                      {"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();
+                     {"favorite_count", s.favorite_count}};
 }
 
 void to_json(nlohmann::json &j, const TwitterData &t) {
   j = nlohmann::json{{"statuses", t.statuses}};
 }
 
+// Deserialization functions for nlohmann
+void from_json(const nlohmann::json &j, User &u) {
+  j.at("id").get_to(u.id);
+  j.at("name").get_to(u.name);
+  j.at("screen_name").get_to(u.screen_name);
+  j.at("location").get_to(u.location);
+  j.at("description").get_to(u.description);
+  j.at("verified").get_to(u.verified);
+  j.at("followers_count").get_to(u.followers_count);
+  j.at("friends_count").get_to(u.friends_count);
+  j.at("statuses_count").get_to(u.statuses_count);
+}
+
+void from_json(const nlohmann::json &j, Status &s) {
+  j.at("created_at").get_to(s.created_at);
+  j.at("id").get_to(s.id);
+  j.at("text").get_to(s.text);
+  j.at("user").get_to(s.user);
+  j.at("retweet_count").get_to(s.retweet_count);
+  j.at("favorite_count").get_to(s.favorite_count);
+}
+
+void from_json(const nlohmann::json &j, TwitterData &t) {
+  j.at("statuses").get_to(t.statuses);
+}
+
+// Helper functions for benchmarking
 std::string nlohmann_serialize(const TwitterData &data) {
-  return nlohmann_serialize(data.statuses);
+  nlohmann::json j = data;
+  return j.dump();
+}
+
+TwitterData nlohmann_deserialize(const std::string &json_str) {
+  nlohmann::json j = nlohmann::json::parse(json_str);
+  return j.get<TwitterData>();
 }
 
 #endif // NLOHMANN_TWITTER_DATA_H

benchmark/static_reflect/twitter_benchmark/rapidjson_twitter_data.h

@@ -0,0 +1,142 @@
+#ifndef RAPIDJSON_TWITTER_DATA_H
+#define RAPIDJSON_TWITTER_DATA_H
+
+#include "twitter_data.h"
+#include <rapidjson/document.h>
+#include <rapidjson/writer.h>
+#include <rapidjson/stringbuffer.h>
+#include <rapidjson/error/en.h>
+
+using namespace rapidjson;
+
+// RapidJSON deserialization for simplified Twitter data
+TwitterData rapidjson_deserialize(const std::string& json_str) {
+    Document doc;
+    doc.Parse(json_str.c_str());
+
+    if (doc.HasParseError()) {
+        throw std::runtime_error("RapidJSON parse error");
+    }
+
+    TwitterData data;
+
+    if (!doc.HasMember("statuses") || !doc["statuses"].IsArray()) {
+        return data;
+    }
+
+    const Value& statuses = doc["statuses"];
+    data.statuses.reserve(statuses.Size());
+
+    for (SizeType i = 0; i < statuses.Size(); i++) {
+        const Value& status_json = statuses[i];
+        Status status;
+
+        // Parse status fields
+        if (status_json.HasMember("created_at") && status_json["created_at"].IsString())
+            status.created_at = status_json["created_at"].GetString();
+        if (status_json.HasMember("id") && status_json["id"].IsUint64())
+            status.id = status_json["id"].GetUint64();
+        if (status_json.HasMember("text") && status_json["text"].IsString())
+            status.text = status_json["text"].GetString();
+        if (status_json.HasMember("retweet_count") && status_json["retweet_count"].IsUint64())
+            status.retweet_count = status_json["retweet_count"].GetUint64();
+        if (status_json.HasMember("favorite_count") && status_json["favorite_count"].IsUint64())
+            status.favorite_count = status_json["favorite_count"].GetUint64();
+
+        // Parse user
+        if (status_json.HasMember("user") && status_json["user"].IsObject()) {
+            const Value& user_json = status_json["user"];
+            User user;
+
+            if (user_json.HasMember("id") && user_json["id"].IsUint64())
+                user.id = user_json["id"].GetUint64();
+            if (user_json.HasMember("name") && user_json["name"].IsString())
+                user.name = user_json["name"].GetString();
+            if (user_json.HasMember("screen_name") && user_json["screen_name"].IsString())
+                user.screen_name = user_json["screen_name"].GetString();
+            if (user_json.HasMember("location") && user_json["location"].IsString())
+                user.location = user_json["location"].GetString();
+            if (user_json.HasMember("description") && user_json["description"].IsString())
+                user.description = user_json["description"].GetString();
+            if (user_json.HasMember("verified") && user_json["verified"].IsBool())
+                user.verified = user_json["verified"].GetBool();
+            if (user_json.HasMember("followers_count") && user_json["followers_count"].IsUint64())
+                user.followers_count = user_json["followers_count"].GetUint64();
+            if (user_json.HasMember("friends_count") && user_json["friends_count"].IsUint64())
+                user.friends_count = user_json["friends_count"].GetUint64();
+            if (user_json.HasMember("statuses_count") && user_json["statuses_count"].IsUint64())
+                user.statuses_count = user_json["statuses_count"].GetUint64();
+
+            status.user = user;
+        }
+
+        data.statuses.push_back(status);
+    }
+
+    return data;
+}
+
+// RapidJSON serialization for simplified Twitter data
+std::string rapidjson_serialize(const TwitterData& data) {
+    Document doc;
+    doc.SetObject();
+    Document::AllocatorType& allocator = doc.GetAllocator();
+
+    Value statuses_array(kArrayType);
+
+    for (const auto& status : data.statuses) {
+        Value status_obj(kObjectType);
+
+        Value created_at;
+        created_at.SetString(status.created_at.c_str(), allocator);
+        status_obj.AddMember("created_at", created_at, allocator);
+
+        status_obj.AddMember("id", status.id, allocator);
+
+        Value text;
+        text.SetString(status.text.c_str(), allocator);
+        status_obj.AddMember("text", text, allocator);
+
+        // Add user
+        Value user_obj(kObjectType);
+        user_obj.AddMember("id", status.user.id, allocator);
+
+        Value name;
+        name.SetString(status.user.name.c_str(), allocator);
+        user_obj.AddMember("name", name, allocator);
+
+        Value screen_name;
+        screen_name.SetString(status.user.screen_name.c_str(), allocator);
+        user_obj.AddMember("screen_name", screen_name, allocator);
+
+        Value location;
+        location.SetString(status.user.location.c_str(), allocator);
+        user_obj.AddMember("location", location, allocator);
+
+        Value description;
+        description.SetString(status.user.description.c_str(), allocator);
+        user_obj.AddMember("description", description, allocator);
+
+        user_obj.AddMember("verified", status.user.verified, allocator);
+        user_obj.AddMember("followers_count", status.user.followers_count, allocator);
+        user_obj.AddMember("friends_count", status.user.friends_count, allocator);
+        user_obj.AddMember("statuses_count", status.user.statuses_count, allocator);
+
+        status_obj.AddMember("user", user_obj, allocator);
+
+        status_obj.AddMember("retweet_count", status.retweet_count, allocator);
+        status_obj.AddMember("favorite_count", status.favorite_count, allocator);
+
+        statuses_array.PushBack(status_obj, allocator);
+    }
+
+    doc.AddMember("statuses", statuses_array, allocator);
+
+    StringBuffer buffer;
+    Writer<StringBuffer> writer(buffer);
+    doc.Accept(writer);
+
+    return buffer.GetString();
+}
+
+#endif // RAPIDJSON_TWITTER_DATA_H

benchmark/static_reflect/twitter_benchmark/twitter_data.h

@@ -4,68 +4,31 @@
 #include <string>
 #include <vector>
 
+// Simplified Twitter structures for benchmarking
+
 struct User {
-  int64_t id;
-  std::string id_str;
+  uint64_t id;
   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;
+  uint64_t followers_count;
+  uint64_t friends_count;
+  uint64_t statuses_count;
 };
 
 struct Status {
   std::string created_at;
-  int64_t id;
+  uint64_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;
+  uint64_t retweet_count;
+  uint64_t favorite_count;
 };
 
 struct TwitterData {
   std::vector<Status> statuses;
-  bool operator==(const TwitterData &other) const = default;
 };
 
-#endif
+#endif // TWITTER_DATA_H

benchmark/static_reflect/twitter_benchmark/yyjson_twitter_data.h

@@ -0,0 +1,145 @@
+#ifndef YYJSON_TWITTER_DATA_H
+#define YYJSON_TWITTER_DATA_H
+
+#include "twitter_data.h"
+#include <yyjson.h>
+#include <string>
+#include <stdexcept>
+
+// yyjson deserialization for simplified Twitter data
+TwitterData yyjson_deserialize(const std::string &json_str) {
+    TwitterData data;
+
+    yyjson_doc *doc = yyjson_read(json_str.c_str(), json_str.size(), 0);
+    if (!doc) {
+        throw std::runtime_error("yyjson parse error");
+    }
+
+    yyjson_val *root = yyjson_doc_get_root(doc);
+    if (!root) {
+        yyjson_doc_free(doc);
+        return data;
+    }
+
+    // Get statuses array
+    yyjson_val *statuses_val = yyjson_obj_get(root, "statuses");
+    if (!statuses_val || !yyjson_is_arr(statuses_val)) {
+        yyjson_doc_free(doc);
+        return data;
+    }
+
+    size_t idx, max;
+    yyjson_val *status_val;
+    yyjson_arr_foreach(statuses_val, idx, max, status_val) {
+        Status status;
+
+        // Parse status fields
+        yyjson_val *val;
+
+        val = yyjson_obj_get(status_val, "created_at");
+        if (val && yyjson_is_str(val)) status.created_at = yyjson_get_str(val);
+
+        val = yyjson_obj_get(status_val, "id");
+        if (val && yyjson_is_uint(val)) status.id = yyjson_get_uint(val);
+
+        val = yyjson_obj_get(status_val, "text");
+        if (val && yyjson_is_str(val)) status.text = yyjson_get_str(val);
+
+        val = yyjson_obj_get(status_val, "retweet_count");
+        if (val && yyjson_is_uint(val)) status.retweet_count = yyjson_get_uint(val);
+
+        val = yyjson_obj_get(status_val, "favorite_count");
+        if (val && yyjson_is_uint(val)) status.favorite_count = yyjson_get_uint(val);
+
+        // Parse user
+        yyjson_val *user_val = yyjson_obj_get(status_val, "user");
+        if (user_val && yyjson_is_obj(user_val)) {
+            User user;
+
+            val = yyjson_obj_get(user_val, "id");
+            if (val && yyjson_is_uint(val)) user.id = yyjson_get_uint(val);
+
+            val = yyjson_obj_get(user_val, "name");
+            if (val && yyjson_is_str(val)) user.name = yyjson_get_str(val);
+
+            val = yyjson_obj_get(user_val, "screen_name");
+            if (val && yyjson_is_str(val)) user.screen_name = yyjson_get_str(val);
+
+            val = yyjson_obj_get(user_val, "location");
+            if (val && yyjson_is_str(val)) user.location = yyjson_get_str(val);
+
+            val = yyjson_obj_get(user_val, "description");
+            if (val && yyjson_is_str(val)) user.description = yyjson_get_str(val);
+
+            val = yyjson_obj_get(user_val, "verified");
+            if (val && yyjson_is_bool(val)) user.verified = yyjson_get_bool(val);
+
+            val = yyjson_obj_get(user_val, "followers_count");
+            if (val && yyjson_is_uint(val)) user.followers_count = yyjson_get_uint(val);
+
+            val = yyjson_obj_get(user_val, "friends_count");
+            if (val && yyjson_is_uint(val)) user.friends_count = yyjson_get_uint(val);
+
+            val = yyjson_obj_get(user_val, "statuses_count");
+            if (val && yyjson_is_uint(val)) user.statuses_count = yyjson_get_uint(val);
+
+            status.user = user;
+        }
+
+        data.statuses.push_back(status);
+    }
+
+    yyjson_doc_free(doc);
+    return data;
+}
+
+// yyjson serialization for simplified Twitter data
+std::string yyjson_serialize(const TwitterData &data) {
+    yyjson_mut_doc *doc = yyjson_mut_doc_new(NULL);
+    yyjson_mut_val *root = yyjson_mut_obj(doc);
+    yyjson_mut_doc_set_root(doc, root);
+
+    // Create statuses array
+    yyjson_mut_val *statuses_array = yyjson_mut_arr(doc);
+
+    for (const auto& status : data.statuses) {
+        yyjson_mut_val *status_obj = yyjson_mut_obj(doc);
+
+        // Add status fields
+        yyjson_mut_obj_add_str(doc, status_obj, "created_at", status.created_at.c_str());
+        yyjson_mut_obj_add_uint(doc, status_obj, "id", status.id);
+        yyjson_mut_obj_add_str(doc, status_obj, "text", status.text.c_str());
+
+        // User object
+        yyjson_mut_val *user_obj = yyjson_mut_obj(doc);
+        yyjson_mut_obj_add_uint(doc, user_obj, "id", status.user.id);
+        yyjson_mut_obj_add_str(doc, user_obj, "name", status.user.name.c_str());
+        yyjson_mut_obj_add_str(doc, user_obj, "screen_name", status.user.screen_name.c_str());
+        yyjson_mut_obj_add_str(doc, user_obj, "location", status.user.location.c_str());
+        yyjson_mut_obj_add_str(doc, user_obj, "description", status.user.description.c_str());
+        yyjson_mut_obj_add_bool(doc, user_obj, "verified", status.user.verified);
+        yyjson_mut_obj_add_uint(doc, user_obj, "followers_count", status.user.followers_count);
+        yyjson_mut_obj_add_uint(doc, user_obj, "friends_count", status.user.friends_count);
+        yyjson_mut_obj_add_uint(doc, user_obj, "statuses_count", status.user.statuses_count);
+        yyjson_mut_obj_add_val(doc, status_obj, "user", user_obj);
+
+        // Other fields
+        yyjson_mut_obj_add_uint(doc, status_obj, "retweet_count", status.retweet_count);
+        yyjson_mut_obj_add_uint(doc, status_obj, "favorite_count", status.favorite_count);
+
+        yyjson_mut_arr_append(statuses_array, status_obj);
+    }
+
+    // Add statuses array to root
+    yyjson_mut_obj_add_val(doc, root, "statuses", statuses_array);
+
+    // Write to string
+    char *json_output = yyjson_mut_write(doc, 0, NULL);
+    std::string result(json_output);
+    free(json_output);
+    yyjson_mut_doc_free(doc);
+
+    return result;
+}
+
+#endif // YYJSON_TWITTER_DATA_H

dependencies/CMakeLists.txt

@@ -12,7 +12,7 @@ cmake_dependent_option(SIMDJSON_GOOGLE_BENCHMARKS "compile the Google Benchmark
 if(SIMDJSON_GOOGLE_BENCHMARKS)
   CPMAddPackage(
         NAME google_benchmarks
-        URL https://github.com/google/benchmark/archive/refs/tags/v1.9.4.zip
+        URL https://github.com/google/benchmark/archive/refs/tags/v1.9.5.zip
         OPTIONS
         "BENCHMARK_ENABLE_TESTING OFF"
         "BENCHMARK_ENABLE_INSTALL OFF"

doc/basics.md

@@ -28,6 +28,8 @@ separate document](https://github.com/simdjson/simdjson/blob/master/doc/builder.
 - [UTF-8 validation (alone)](#utf-8-validation-alone)
 - [JSON Pointer](#json-pointer)
 - [JSONPath](#jsonpath)
+  * [Using `for_each_at_path_with_wildcard` for JSONPath Queries (On-Demand)](#using-for_each_at_path_with_wildcard-for-jsonpath-queries-on-demand)
+    + [Example Usage](#example-usage)
 - [Compile-Time JSONPath and JSON Pointer (C++26 Reflection)](#compile-time-jsonpath-and-json-pointer-c26-reflection)
 - [Error handling](#error-handling)
   * [Error handling examples without exceptions](#error-handling-examples-without-exceptions)
@@ -271,6 +273,21 @@ 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.
 
+
+**Advanced feature:**
+On non-Windows systems, you can use memory-file mapping to create a `simdjson::padded_string_view`
+from a file on disk.
+
+```cpp
+// If the macro _WIN32 is defined, this will not work since we do not support memory-file mapping
+// under Windows at this time.
+simdjson::padded_memory_map map(myfilename);
+if (!map.is_valid()) { /* handle error */ }
+simdjson::padded_string_view view = map.view(); // view is usable while padded_memory_map is in scope
+ondemand::document doc = parser.iterate(view); // parse the JSON
+```
+
+
 Documents are iterators
 -----------------------
 
@@ -374,6 +391,10 @@ builds to disable additional runtime testing and get the best performance. We
 disable these checks on a best-effort basis but the C++ standard does not provide
 a direct way to check for a release build.
 
+
+Warnign: Mixing debug and release simdjson code is unsafe: you either build all your code
+using simdjson in release mode or all of it in debug mode.
+
 Using the parsed JSON
 ---------------------
 
@@ -417,7 +438,7 @@ support for users who avoid exceptions. See [the simdjson error handling documen
 * **Extracting Values:** You can cast a JSON element to a native type:
   `double(element)`. This works for `std::string_view`, double, uint64_t, int64_t, bool,
   ondemand::object and ondemand::array. We also have explicit methods such as `get_string()`, `get_double()`,
-  `get_uint64()`, `get_int64()`, `get_bool()`, `get_object()` and `get_array()`. After a cast or an explicit method,
+  `get_uint64()`, `get_int64()`, `get_uint32()`, `get_int32()`, `get_bool()`, `get_object()` and `get_array()`. After a cast or an explicit method,
   the number, string or boolean will be parsed, or the initial `{` or `[` will be verified for `ondemand::object` and `ondemand::array`. An exception may be thrown if
   the cast is not possible: the error code is `simdjson::INCORRECT_TYPE` (see [Error handling](#error-handling)). Importantly, when getting an ondemand::object or ondemand::array instance, its content is
   not validated: you are only guaranteed that the corresponding initial character (`{` or `[`) is present. Thus,
@@ -427,8 +448,8 @@ support for users who avoid exceptions. See [the simdjson error handling documen
   pass `true` (`get_string(true)`) as a parameter to get replacement characters where errors
   occur. If you somehow need to access non-UTF-8 strings in a lossless manner
   (e.g., if you strings contain unpaired surrogates), you may use the `get_wobbly_string()` function to get a string in the [WTF-8 format](https://simonsapin.github.io/wtf-8).
-  When calling `get_uint64()` and `get_int64()`, if the number does not fit in a corresponding
-  64-bit integer type, it is also considered an error. When parsing numbers or other scalar values, the library checks
+  When calling `get_uint64()`, `get_int64()`, `get_uint32()` or `get_int32()`, if the number does not fit in the
+  corresponding integer type, it is also considered an error (`NUMBER_OUT_OF_RANGE`). When parsing numbers or other scalar values, the library checks
   that the value is followed by an expected character, thus you *may* get a number parsing error when accessing the digits
   as an integer in the following strings: `{"number":12332a`, `{"number":12332\0`, `{"number":12332` (the digits appear at the end). We always abide by the [RFC 8259](https://www.tbray.org/ongoing/When/201x/2017/12/14/rfc8259.html) JSON specification so that, for example, numbers prefixed by the `+` sign are in error.
 
@@ -469,7 +490,7 @@ support for users who avoid exceptions. See [the simdjson error handling documen
   out of the array, you may use an array access (e.g., `array[1]`). You should never reset an array as you are iterating through it. The following is an anti-pattern: `for(auto value: myarray) {myarray.reset()}`.
 * **Field Access:** To get the value of the "foo" field in an object, use `object["foo"]`. This will
   scan through the object looking for the field with the matching string, doing a character-by-character
-  comparison. It may generate the error `simdjson::NO_SUCH_FIELD` if there is no such key in the object, it may throw an exception (see [Error handling](#error-handling)). For efficiency reason, you should avoid looking up the same field repeatedly: e.g., do
+  comparison. It may generate the error `simdjson::NO_SUCH_FIELD` if there is no such key in the object, it may throw an exception (see [Error handling](#error-handling)). The returned value is only valid so long as you do not access another field: normally, you should therefore grab the value right after accessing a key (i.e., convert it to number, string, object, array...). For efficiency reason, you should avoid looking up the same field repeatedly: e.g., do
   not do `object["foo"]` followed by `object["foo"]` with the same `object` instance. Generally, you should not mix and match iterating through an object (`for(auto field : object) {...}`) and key accesses (`object["foo"]`): if you need to iterate through an object after a key access, you need to call `reset()` on the object. Whenever you call `reset()`, you need to keep in mind that though you can iterate over the array repeatedly, values should be consumedonly once (e.g., repeatedly calling `unescaped_key()` on the same  key is forbidden). Keep in mind that On-Demand does not buffer or save the result of the parsing: if you repeatedly access `object["foo"]`, then it must repeatedly seek the key and parse the content. The library does not provide a distinct function to check if a key is present, instead we recommend you attempt to access the key: e.g., by doing `ondemand::value val{}; if (!object["foo"].get(val)) {...}`, you have that `val` contains the requested value inside the if clause.  It is your responsibility as a user to temporarily keep a reference to the value (`auto v = object["foo"]`), or to consume the content and store it in your own data structures. If you consume an
   object twice: `std::string_view(object["foo"]` followed by `std::string_view(object["foo"]` then your code
   is in error. Furthermore, you can only consume one field at a time, on the same object. The
@@ -1771,15 +1792,15 @@ int64_t x = obj.at_path("$.c.foo.a[1]"); // 20
 x = obj.at_path("$.d.foo2.a.2"); // 30
 ```
 
-## Using `at_path_with_wildcard` for JSONPath Queries (On-Demand)
+## Using `for_each_at_path_with_wildcard` for JSONPath Queries (On-Demand)
 
-The `at_path_with_wildcard` function in simdjson extends the JSONPath querying capabilities by supporting wildcard expressions (`*`) in JSON paths. This allows users to retrieve multiple elements from a JSON document in a single query. For example, you can use `$.address.*` to fetch all fields within the `address` object or `$.phoneNumbers[*].numbers[*]` to retrieve all phone numbers across multiple objects in an array.
+The `for_each_at_path_with_wildcard` function in simdjson extends the JSONPath querying capabilities by supporting wildcard expressions (`*`) in JSON paths. It calls a user-provided callback for each matching element, avoiding the need to materialize all results into a vector. For example, you can use `$.address.*` to fetch all fields within the `address` object or `$.phoneNumbers[*].numbers[*]` to retrieve all phone numbers across multiple objects in an array.
 
-The `*` wildcard matches all elements at a specific level. For instance, `$.address.*` retrieves all key-value pairs in the `address` object, while `$.*.streetAddress` fetches all `streetAddress` fields across objects at the root level. You can combine wildcards with array indexing. For example, `$.phoneNumbers[*].numbers[1]` retrieves the second number from each `numbers` array in the `phoneNumbers` array. If no elements match the wildcard query, the function returns an empty result. For instance, querying `$.empty_object.*` or `$.empty_array.*` will yield an empty set.
+The `*` wildcard matches all elements at a specific level. For instance, `$.address.*` retrieves all key-value pairs in the `address` object, while `$.*.streetAddress` fetches all `streetAddress` fields across objects at the root level. You can combine wildcards with array indexing. For example, `$.phoneNumbers[*].numbers[1]` retrieves the second number from each `numbers` array in the `phoneNumbers` array. If no elements match the wildcard query, the callback is simply never called. For instance, querying `$.empty_object.*` or `$.empty_array.*` will yield no callbacks.
 
 ### Example Usage
 
-Here is an example demonstrating the use of `at_path_with_wildcard`:
+Here is an example demonstrating the use of `for_each_at_path_with_wildcard`:
 
 ```cpp
 simdjson::padded_string json_string = R"(
@@ -1808,27 +1829,22 @@ ondemand::parser parser;
 ondemand::document doc = parser.iterate(json_string);
 
 // Fetch all fields in the address object
-std::vector<ondemand::value> values;
-auto error = doc.at_path_with_wildcard("$.address.*").get(values);
-if (!error) {
-  for (auto value : values) {
-    std::string_view field;
-    if (value.get(field) == SUCCESS) {
-      std::cout << field << std::endl;
-    }
-  }
-}
+auto error = doc.for_each_at_path_with_wildcard("$.address.*",
+    [](ondemand::value value) {
+      std::string_view field;
+      if (value.get(field) == SUCCESS) {
+        std::cout << field << std::endl;
+      }
+    });
 
 // Fetch all phone numbers
-error = doc.at_path_with_wildcard("$.phoneNumbers[*].numbers[*]").get(values);
-if (!error) {
-  for (auto value : values) {
-    std::string_view number;
-    if (value.get(number) == SUCCESS) {
-      std::cout << number << std::endl;
-    }
-  }
-}
+doc.for_each_at_path_with_wildcard("$.phoneNumbers[*].numbers[*]",
+    [](ondemand::value value) {
+      std::string_view number;
+      if (value.get(number) == SUCCESS) {
+        std::cout << number << std::endl;
+      }
+    });
 ```
 
 This function is particularly useful for extracting data from complex JSON structures with nested arrays and objects. By leveraging wildcards, you can simplify your queries and reduce the need for multiple iterations.

doc/dom.md

@@ -125,6 +125,22 @@ 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.
 
+
+**Advanced feature:**
+On non-Windows systems, you can use memory-file mapping to create a `simdjson::padded_string_view`
+from a file on disk.
+
+```cpp
+// if the macro _WIN32 is defined, this will not work since we do not support Windows
+simdjson::padded_memory_map map(TWITTER_JSON);
+if (!map.is_valid()) { /* handle error */ }
+simdjson::padded_string_view view = map.view(); // view is usable while padded_memory_map is in scope
+ondemand::document doc = parser.iterate(view); // parse the JSON
+```
+
+Using memory-file mapping requires some care. The file should not be modified while you are
+accessing it.
+
 Using the Parsed JSON
 ---------------------
 
@@ -152,6 +168,23 @@ Once you have an element, you can navigate it with idiomatic C++ iterators, oper
   `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`.
+* **Big Integer Support (opt-in):** By default, integers that exceed the 64-bit range cause parsing to fail with `BIGINT_ERROR`. You can opt in to big integer support so that these numbers are stored as raw digit strings on the tape instead:
+  ```cpp
+  simdjson::dom::parser parser;
+  parser.number_as_string(true); // opt-in, default false
+  simdjson::dom::element doc;
+  auto error = parser.parse("[1, 123456789012345678901]"_padded).get(doc);
+  if (error) { std::cerr << error << std::endl; return EXIT_FAILURE; }
+  for (simdjson::dom::element elem : doc) {
+    if (elem.is_bigint()) {
+      std::string_view digits;
+      error = elem.get_bigint().get(digits);
+      if (error) { std::cerr << error << std::endl; return EXIT_FAILURE; }
+      std::cout << "big integer: " << digits << std::endl;
+    }
+  }
+  ```
+  When enabled, big integers have type `element_type::BIGINT`. Calling `get_int64()`, `get_uint64()`, or `get_double()` on a big integer returns `INCORRECT_TYPE`. Normal numbers (int64, uint64, double) are unaffected.
 * **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) { ... }`
@@ -164,7 +197,7 @@ Once you have an element, you can navigate it with idiomatic C++ iterators, oper
 * **Array and Object size** Given an array or an object, you can get its size (number of elements or keys)
   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`.
+  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`, `simdjson::dom::element_type::NULL_VALUE` or, `simdjson::dom::element_type::BIGINT` (when big integer support is enabled).
 * **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

doc/implementation-selection.md

@@ -33,6 +33,9 @@ compiles *all* the implementations into the executable. On Intel, it will includ
 (icelake, haswell, westmere and fallback), on 64-bit ARM it will include just one since running dispatching is  unnecessary, and on PPC
 it will include 2 (ppc64 and fallback).
 
+On Loongson processors, LASX runtime dispatching is only enabled on GCC 15+, not on LLVM or older versions of GCC.
+Thus unless you compile specifically for LASX or use GCC 15+, you will not benefit from LASX support.
+
 If you know more about where you're going to run and want to save the space, you can disable any of
 these implementations at compile time with `-DSIMDJSON_IMPLEMENTATION_X=0` (where X is ICELAKE, HASWELL,
 WESTMERE, ARM64, PPC64, LSX, LASX and FALLBACK).

doc/iterate_many.md

@@ -154,6 +154,20 @@ for (auto doc : docs) {
 
 See [basics.md](basics.md#newline-delimited-json-ndjson-and-json-lines) for an overview of the API.
 
+
+**Advanced feature:**
+On non-Windows systems, you can use memory-file mapping to create a `simdjson::padded_string_view`
+from a file on disk.
+
+```cpp
+// If the macro _WIN32 is defined, this will not work since we do not support memory-file mapping
+// under Windows at this time.
+simdjson::padded_memory_map map(myfilename);
+if (!map.is_valid()) { /* handle error */ }
+simdjson::padded_string_view view = map.view(); // view is usable while padded_memory_map is in scope
+ondemand::document doc = parser.iterate(view); // parse the JSON
+```
+
 ## Use cases
 
 From [jsonlines.org](http://jsonlines.org/examples/):

doc/parse_many.md

@@ -217,6 +217,20 @@ got full document at 29
 ```
 
 
+
+**Advanced feature:**
+On non-Windows systems, you can use memory-file mapping to create a `simdjson::padded_string_view`
+from a file on disk.
+
+```cpp
+// If the macro _WIN32 is defined, this will not work since we do not support memory-file mapping
+// under Windows at this time.
+simdjson::padded_memory_map map(myfilename);
+if (!map.is_valid()) { /* handle error */ }
+simdjson::padded_string_view view = map.view(); // view is usable while padded_memory_map is in scope
+ondemand::document doc = parser.iterate(view); // parse the JSON
+```
+
 Incomplete streams
 -----------
 

doc/tape.md

@@ -93,6 +93,14 @@ Float values are represented as two 64-bit tape elements:
 
 Performance consideration: We store numbers of the main tape because we believe that locality of reference is helpful for performance.
 
+## Big Integers
+
+When a JSON integer exceeds the 64-bit range (both signed and unsigned), it is classified as a big integer. By default, parsing returns `BIGINT_ERROR`. When `parser.number_as_string(true)` is set, the raw digits are stored on the string tape using the same format as strings (4-byte little-endian length prefix, followed by the UTF-8 digit bytes, followed by a null terminator).
+
+A big integer is represented on the main tape as the 64-bit tape element `('Z' << 56) + x` where the payload `x` is the location on the string tape of the null-terminated digit string.
+
+For example, the JSON value `99999999999999999999` would be stored as the string `"99999999999999999999"` on the string tape, with a `'Z'` tag on the main tape. Negative big integers include the leading minus sign.
+
 ## Root node
 
 Each JSON document will have two special 64-bit tape elements representing a root node, one at the beginning and one at the end.

fuzz/fuzz_dump.cpp

@@ -54,6 +54,9 @@ static void print_json(std::ostream& os, simdjson::dom::element element) noexcep
   case simdjson::dom::element_type::NULL_VALUE:
     os << "null" << endl;
     break;
+  case simdjson::dom::element_type::BIGINT:
+    os << element.get_bigint().value_unsafe() << endl;
+    break;
   }
 }
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {

include/simdjson/arm64/simd.h

@@ -428,6 +428,7 @@ namespace {
     static constexpr int NUM_CHUNKS = 64 / sizeof(simd8<T>);
     static_assert(NUM_CHUNKS == 4, "ARM kernel should use four registers per 64-byte block.");
     const simd8<T> chunks[NUM_CHUNKS];
+    template<int idx> simd8<uint8_t> get() const { return idx < NUM_CHUNKS ? chunks[idx] : simd8<T>(); }
 
     simd8x64(const simd8x64<T>& o) = delete; // no copy allowed
     simd8x64<T>& operator=(const simd8<T>& other) = delete; // no assignment allowed

include/simdjson/arm64/stringparsing_defs.h

@@ -17,7 +17,6 @@ using namespace simd;
 struct backslash_and_quote {
 public:
   static constexpr uint32_t BYTES_PROCESSED = 32;
-  // We only copy if dst is non-null.
   simdjson_inline backslash_and_quote copy_and_find(const uint8_t *src, uint8_t *dst);
 
   simdjson_inline bool has_quote_first() { return ((bs_bits - 1) & quote_bits) != 0; }
@@ -35,10 +34,8 @@ simdjson_inline backslash_and_quote backslash_and_quote::copy_and_find(const uin
   static_assert(SIMDJSON_PADDING >= (BYTES_PROCESSED - 1), "backslash and quote finder must process fewer than SIMDJSON_PADDING bytes");
   simd8<uint8_t> v0(src);
   simd8<uint8_t> v1(src + sizeof(v0));
-  if(dst != nullptr) {
-    v0.store(dst);
-    v1.store(dst + sizeof(v0));
-  }
+  v0.store(dst);
+  v1.store(dst + sizeof(v0));
 
   // Getting a 64-bit bitmask is much cheaper than multiple 16-bit bitmasks on ARM; therefore, we
   // smash them together into a 64-byte mask and get the bitmask from there.

include/simdjson/builtin.h

@@ -24,6 +24,8 @@
 #include "simdjson/lasx.h"
 #elif SIMDJSON_BUILTIN_IMPLEMENTATION_IS(lsx)
 #include "simdjson/lsx.h"
+#elif SIMDJSON_BUILTIN_IMPLEMENTATION_IS(rvv_vls)
+#include "simdjson/rvv-vls.h"
 #else
 #error Unknown SIMDJSON_BUILTIN_IMPLEMENTATION
 #endif

include/simdjson/builtin/base.h

@@ -21,6 +21,8 @@ namespace simdjson {
   namespace lsx {}
 #elif SIMDJSON_BUILTIN_IMPLEMENTATION_IS(lasx)
   namespace lasx {}
+#elif SIMDJSON_BUILTIN_IMPLEMENTATION_IS(rvv_vls)
+  namespace rvv_vls {}
 #else
 #error Unknown SIMDJSON_BUILTIN_IMPLEMENTATION
 #endif

include/simdjson/builtin/builder.h

@@ -24,6 +24,8 @@
 #include "simdjson/lsx/builder.h"
 #elif SIMDJSON_BUILTIN_IMPLEMENTATION_IS(lasx)
 #include "simdjson/lasx/builder.h"
+#elif SIMDJSON_BUILTIN_IMPLEMENTATION_IS(rvv_vls)
+#include "simdjson/rvv-vls/builder.h"
 #else
 #error Unknown SIMDJSON_BUILTIN_IMPLEMENTATION
 #endif
@@ -37,4 +39,4 @@ namespace simdjson {
   namespace builder = SIMDJSON_BUILTIN_IMPLEMENTATION::builder;
 } // namespace simdjson
 
-#endif // SIMDJSON_BUILTIN_BUILDER_H
+#endif // SIMDJSON_BUILTIN_BUILDER_H

include/simdjson/builtin/implementation.h

@@ -23,6 +23,8 @@
 #include "simdjson/lsx/implementation.h"
 #elif SIMDJSON_BUILTIN_IMPLEMENTATION_IS(lasx)
 #include "simdjson/lasx/implementation.h"
+#elif SIMDJSON_BUILTIN_IMPLEMENTATION_IS(rvv_vls)
+#include "simdjson/rvv-vls/implementation.h"
 #else
 #error Unknown SIMDJSON_BUILTIN_IMPLEMENTATION
 #endif
@@ -39,4 +41,4 @@ namespace simdjson {
   const implementation * builtin_implementation();
 } // namespace simdjson
 
-#endif // SIMDJSON_BUILTIN_IMPLEMENTATION_H
+#endif // SIMDJSON_BUILTIN_IMPLEMENTATION_H

include/simdjson/builtin/ondemand.h

@@ -24,6 +24,8 @@
 #include "simdjson/lsx/ondemand.h"
 #elif SIMDJSON_BUILTIN_IMPLEMENTATION_IS(lasx)
 #include "simdjson/lasx/ondemand.h"
+#elif SIMDJSON_BUILTIN_IMPLEMENTATION_IS(rvv_vls)
+#include "simdjson/rvv-vls/ondemand.h"
 #else
 #error Unknown SIMDJSON_BUILTIN_IMPLEMENTATION
 #endif
@@ -37,4 +39,4 @@ namespace simdjson {
   namespace ondemand = SIMDJSON_BUILTIN_IMPLEMENTATION::ondemand;
 } // namespace simdjson
 
-#endif // SIMDJSON_BUILTIN_ONDEMAND_H
+#endif // SIMDJSON_BUILTIN_ONDEMAND_H

include/simdjson/compiler_check.h

@@ -119,5 +119,4 @@
 #define SIMDJSON_CONSTEVAL 0
 #endif // defined(__cpp_consteval) && __cpp_consteval >= 201811L && defined(__cpp_lib_constexpr_string) && __cpp_lib_constexpr_string >= 201907L
 #endif // !defined(SIMDJSON_CONSTEVAL)
-
 #endif // SIMDJSON_COMPILER_CHECK_H

include/simdjson/dom/document-inl.h

@@ -141,6 +141,15 @@ inline bool document::dump_raw_tape(std::ostream &os) const noexcept {
     case 'r': // we start and end with the root node
       // should we be hitting the root node?
       return false;
+    case 'Z': // we have a big integer
+      os << "bigint ";
+      std::memcpy(&string_length, string_buf.get() + payload, sizeof(uint32_t));
+      os << std::string_view(
+        reinterpret_cast<const char *>(string_buf.get() + payload + sizeof(uint32_t)),
+        string_length
+      );
+      os << '\n';
+      break;
     default:
       return false;
     }

include/simdjson/dom/element-inl.h

@@ -81,6 +81,10 @@ simdjson_inline simdjson_result<bool> simdjson_result<dom::element>::get_bool()
   if (error()) { return error(); }
   return first.get_bool();
 }
+simdjson_inline simdjson_result<std::string_view> simdjson_result<dom::element>::get_bigint() const noexcept {
+  if (error()) { return error(); }
+  return first.get_bigint();
+}
 
 simdjson_inline bool simdjson_result<dom::element>::is_array() const noexcept {
   return !error() && first.is_array();
@@ -110,6 +114,9 @@ simdjson_inline bool simdjson_result<dom::element>::is_bool() const noexcept {
 simdjson_inline bool simdjson_result<dom::element>::is_null() const noexcept {
   return !error() && first.is_null();
 }
+simdjson_inline bool simdjson_result<dom::element>::is_bigint() const noexcept {
+  return !error() && first.is_bigint();
+}
 
 simdjson_inline simdjson_result<dom::element> simdjson_result<dom::element>::operator[](std::string_view key) const noexcept {
   if (error()) { return error(); }
@@ -218,6 +225,15 @@ inline simdjson_result<bool> element::get_bool() const noexcept {
   }
   return INCORRECT_TYPE;
 }
+inline simdjson_result<std::string_view> element::get_bigint() const noexcept {
+  SIMDJSON_DEVELOPMENT_ASSERT(tape.usable());
+  switch (tape.tape_ref_type()) {
+    case internal::tape_type::BIGINT:
+      return tape.get_string_view();
+    default:
+      return INCORRECT_TYPE;
+  }
+}
 inline simdjson_result<const char *> element::get_c_str() const noexcept {
   SIMDJSON_DEVELOPMENT_ASSERT(tape.usable()); // https://github.com/simdjson/simdjson/issues/1914
   switch (tape.tape_ref_type()) {
@@ -360,6 +376,10 @@ inline bool element::is_null() const noexcept {
   return tape.is_null_on_tape();
 }
 
+inline bool element::is_bigint() const noexcept {
+  return tape.tape_ref_type() == internal::tape_type::BIGINT;
+}
+
 #if SIMDJSON_EXCEPTIONS
 
 inline element::operator bool() const noexcept(false) { return get<bool>(); }
@@ -492,6 +512,8 @@ inline std::ostream& operator<<(std::ostream& out, element_type type) {
       return out << "bool";
     case element_type::NULL_VALUE:
       return out << "null";
+    case element_type::BIGINT:
+      return out << "bigint";
     default:
       return out << "unexpected content!!!"; // abort() usage is forbidden in the library
   }

include/simdjson/dom/element.h

@@ -21,7 +21,8 @@ enum class element_type {
   DOUBLE = 'd',    ///< double: Any number with a "." or "e" that fits in double.
   STRING = '"',    ///< std::string_view
   BOOL = 't',      ///< bool
-  NULL_VALUE = 'n' ///< null
+  NULL_VALUE = 'n', ///< null
+  BIGINT = 'Z'     ///< std::string_view: big integer stored as raw digit string
 };
 
 /**
@@ -120,6 +121,14 @@ public:
    */
   inline simdjson_result<bool> get_bool() const noexcept;
 
+  /**
+   * Read this element as a big integer (raw digit string).
+   *
+   * @returns A string_view of the raw digits, or:
+   *          INCORRECT_TYPE if the JSON element is not a big integer.
+   */
+  inline simdjson_result<std::string_view> get_bigint() const noexcept;
+
   /**
    * Whether this element is a json array.
    *
@@ -175,6 +184,11 @@ public:
    */
   inline bool is_null() const noexcept;
 
+  /**
+   * Whether this element is a big integer (number exceeding 64-bit range).
+   */
+  inline bool is_bigint() const noexcept;
+
   /**
    * Tell whether the value can be cast to provided type (T).
    *
@@ -533,6 +547,7 @@ public:
   simdjson_inline simdjson_result<uint64_t> get_uint64() const noexcept;
   simdjson_inline simdjson_result<double> get_double() const noexcept;
   simdjson_inline simdjson_result<bool> get_bool() const noexcept;
+  simdjson_inline simdjson_result<std::string_view> get_bigint() const noexcept;
 
   simdjson_inline bool is_array() const noexcept;
   simdjson_inline bool is_object() const noexcept;
@@ -543,6 +558,7 @@ public:
   simdjson_inline bool is_number() const noexcept;
   simdjson_inline bool is_bool() const noexcept;
   simdjson_inline bool is_null() const noexcept;
+  simdjson_inline bool is_bigint() const noexcept;
 
   simdjson_inline simdjson_result<dom::element> operator[](std::string_view key) const noexcept;
   simdjson_inline simdjson_result<dom::element> operator[](const char *key) const noexcept;

include/simdjson/dom/parser-inl.h

@@ -36,10 +36,11 @@ inline bool parser::dump_raw_tape(std::ostream &os) const noexcept {
 }
 
 inline simdjson_result<size_t> parser::read_file(std::string_view path) noexcept {
+  const std::string path_copy(path);
   // Open the file
   SIMDJSON_PUSH_DISABLE_WARNINGS
   SIMDJSON_DISABLE_DEPRECATED_WARNING // Disable CRT_SECURE warning on MSVC: manually verified this is safe
-  std::FILE *fp = std::fopen(path.data(), "rb");
+  std::FILE *fp = std::fopen(path_copy.c_str(), "rb");
   SIMDJSON_POP_DISABLE_WARNINGS
 
   if (fp == nullptr) {
@@ -132,6 +133,7 @@ inline simdjson_result<element> parser::parse_into_document(document& provided_d
     buf += 3;
     len -= 3;
   }
+  implementation->_number_as_string = _number_as_string;
   _error = implementation->parse(buf, len, provided_doc);
 
   if (_error) { return _error; }

include/simdjson/dom/parser.h

@@ -610,6 +610,13 @@ public:
   inline bool dump_raw_tape(std::ostream &os) const noexcept;
 
 
+  /**
+   * When enabled, big integers (exceeding uint64 range) are stored as strings
+   * in the tape instead of returning BIGINT_ERROR. Default: false.
+   */
+  inline void number_as_string(bool enabled) noexcept { _number_as_string = enabled; }
+  inline bool number_as_string() const noexcept { return _number_as_string; }
+
 private:
   /**
    * The maximum document length this parser will automatically support.
@@ -618,6 +625,9 @@ private:
    */
   size_t _max_capacity;
 
+  /** Whether to store big integers as strings instead of returning BIGINT_ERROR */
+  bool _number_as_string{false};
+
   /**
    * The loaded buffer (reused each time load() is called)
    */

include/simdjson/dom/serialization-inl.h

@@ -460,6 +460,12 @@ inline void string_builder<serializer>::append(simdjson::dom::element value) {
     case tape_type::STRING:
       format.string(iter.get_string_view());
       break;
+    case tape_type::BIGINT: {
+      // Big integer stored as string — output raw digits (no quotes)
+      auto sv = iter.get_string_view();
+      format.chars(sv.data(), sv.data() + sv.size());
+      break;
+    }
     case tape_type::INT64:
       format.number(iter.next_tape_value<int64_t>());
       iter.json_index++; // numbers take up 2 spots, so we need to increment

include/simdjson/fallback/bitmanipulation.h

@@ -41,6 +41,19 @@ simdjson_inline int leading_zeroes(uint64_t input_num) {
 #endif// _MSC_VER
 }
 
+simdjson_inline int trailing_zeroes(uint64_t input_num) {
+#ifdef _MSC_VER
+  unsigned long trailing_zero = 0;
+  // Search the mask data from least significant bit (LSB)
+  // to most significant bit (MSB) for a set bit (1).
+  if (_BitScanForward64(&trailing_zero, input_num))
+    return (int)trailing_zero;
+  else    return 64;
+#else
+  return __builtin_ctzll(input_num);
+#endif// _MSC_VER
+}
+
 } // unnamed namespace
 } // namespace fallback
 } // namespace simdjson

include/simdjson/fallback/stringparsing_defs.h

@@ -13,7 +13,6 @@ namespace {
 struct backslash_and_quote {
 public:
   static constexpr uint32_t BYTES_PROCESSED = 1;
-  // We only copy if dst is non-null.
   simdjson_inline backslash_and_quote copy_and_find(const uint8_t *src, uint8_t *dst);
 
   simdjson_inline bool has_quote_first() { return c == '"'; }
@@ -26,9 +25,7 @@ public:
 
 simdjson_inline backslash_and_quote backslash_and_quote::copy_and_find(const uint8_t *src, uint8_t *dst) {
   // store to dest unconditionally - we can overwrite the bits we don't like later
-  if(dst != nullptr) {
-    dst[0] = src[0];
-  }
+  dst[0] = src[0];
   return { src[0] };
 }
 

include/simdjson/generic/base.h

@@ -21,6 +21,8 @@
 #include "simdjson/lasx/begin.h"
 #elif SIMDJSON_IMPLEMENTATION_LSX
 #include "simdjson/lsx/begin.h"
+#elif SIMDJSON_IMPLEMENTATION_RVV_VLS
+#include "simdjson/rvv-vls/begin.h"
 #elif SIMDJSON_IMPLEMENTATION_FALLBACK
 #include "simdjson/fallback/begin.h"
 #else
@@ -48,4 +50,4 @@ enum class number_type {
 } // namespace SIMDJSON_IMPLEMENTATION
 } // namespace simdjson
 
-#endif // SIMDJSON_GENERIC_BASE_H
+#endif // SIMDJSON_GENERIC_BASE_H

include/simdjson/generic/builder/json_builder.h

@@ -275,7 +275,7 @@ simdjson_warn_unused simdjson_result<std::string> to_json_string(const Z &z, siz
 }
 
 template <class Z>
-simdjson_warn_unused simdjson_error to_json(const Z &z, std::string &s, size_t initial_capacity = string_builder::DEFAULT_INITIAL_CAPACITY) {
+simdjson_warn_unused error_code to_json(const Z &z, std::string &s, size_t initial_capacity = string_builder::DEFAULT_INITIAL_CAPACITY) {
   string_builder b(initial_capacity);
   append(b, z);
   std::string_view view;
@@ -352,7 +352,7 @@ simdjson_warn_unused simdjson_result<std::string> to_json(const Z &z, size_t ini
   return std::string(s);
 }
 template <class Z>
-simdjson_warn_unused simdjson_error to_json(const Z &z, std::string &s, size_t initial_capacity = SIMDJSON_IMPLEMENTATION::builder::string_builder::DEFAULT_INITIAL_CAPACITY) {
+simdjson_warn_unused error_code to_json(const Z &z, std::string &s, size_t initial_capacity = SIMDJSON_IMPLEMENTATION::builder::string_builder::DEFAULT_INITIAL_CAPACITY) {
   SIMDJSON_IMPLEMENTATION::builder::string_builder b(initial_capacity);
   SIMDJSON_IMPLEMENTATION::builder::append(b, z);
   std::string_view view;

include/simdjson/generic/builder/json_string_builder-inl.h

@@ -27,12 +27,50 @@
 #define SIMDJSON_EXPERIMENTAL_HAS_NEON 1
 #endif
 #endif
+#if defined(__loongarch_sx)
+#ifndef SIMDJSON_EXPERIMENTAL_HAS_LSX
+#define SIMDJSON_EXPERIMENTAL_HAS_LSX 1
+#endif
+#endif
+#if defined(__riscv_v_intrinsic) && __riscv_v_intrinsic >= 11000 &&            \
+    defined(__riscv_vector)
+#ifndef SIMDJSON_EXPERIMENTAL_HAS_RVV
+#define SIMDJSON_EXPERIMENTAL_HAS_RVV 1
+#endif
+#endif
+#if (defined(__PPC64__) || defined(_M_PPC64)) && defined(__ALTIVEC__)
+#ifndef SIMDJSON_EXPERIMENTAL_HAS_PPC64
+#define SIMDJSON_EXPERIMENTAL_HAS_PPC64 1
+#endif
+#endif
 #if SIMDJSON_EXPERIMENTAL_HAS_NEON
 #include <arm_neon.h>
+#ifdef _MSC_VER
+#include <intrin.h>
+#endif
 #endif
 #if SIMDJSON_EXPERIMENTAL_HAS_SSE2
 #include <emmintrin.h>
+#ifdef _MSC_VER
+#include <intrin.h>
 #endif
+#endif
+#if SIMDJSON_EXPERIMENTAL_HAS_LSX
+#include <lsxintrin.h>
+#endif
+#if SIMDJSON_EXPERIMENTAL_HAS_RVV
+#include <riscv_vector.h>
+#endif
+#if SIMDJSON_EXPERIMENTAL_HAS_PPC64
+#include <altivec.h>
+#ifdef bool
+#undef bool
+#endif
+#ifdef vector
+#undef vector
+#endif
+#endif
+
 
 namespace simdjson {
 namespace SIMDJSON_IMPLEMENTATION {
@@ -133,16 +171,45 @@ simdjson_inline bool fast_needs_escaping(std::string_view view) {
   }
   return _mm_movemask_epi8(running) != 0;
 }
+#elif SIMDJSON_EXPERIMENTAL_HAS_PPC64
+simdjson_inline bool fast_needs_escaping(std::string_view view) {
+  if (view.size() < 16) {
+    return simple_needs_escaping(view);
+  }
+  size_t i = 0;
+  __vector unsigned char running = vec_splats((unsigned char)0);
+  __vector unsigned char v34 = vec_splats((unsigned char)34);
+  __vector unsigned char v92 = vec_splats((unsigned char)92);
+  __vector unsigned char v32 = vec_splats((unsigned char)32);
+
+  for (; i + 15 < view.size(); i += 16) {
+    __vector unsigned char word =
+        vec_vsx_ld(0, reinterpret_cast<const unsigned char *>(view.data() + i));
+    running = vec_or(running, (__vector unsigned char)vec_cmpeq(word, v34));
+    running = vec_or(running, (__vector unsigned char)vec_cmpeq(word, v92));
+    running = vec_or(running,
+        (__vector unsigned char)vec_cmplt(word, v32));
+  }
+  if (i < view.size()) {
+    __vector unsigned char word = vec_vsx_ld(
+        0, reinterpret_cast<const unsigned char *>(view.data() + view.length() - 16));
+    running = vec_or(running, (__vector unsigned char)vec_cmpeq(word, v34));
+    running = vec_or(running, (__vector unsigned char)vec_cmpeq(word, v92));
+    running = vec_or(running,
+        (__vector unsigned char)vec_cmplt(word, v32));
+  }
+  return !vec_all_eq(running, vec_splats((unsigned char)0));
+}
 #else
 simdjson_inline bool fast_needs_escaping(std::string_view view) {
   return simple_needs_escaping(view);
 }
 #endif
 
-SIMDJSON_CONSTEXPR_LAMBDA inline size_t
-find_next_json_quotable_character(const std::string_view view,
-                                  size_t location) noexcept {
-
+// Scalar fallback for finding next quotable character
+SIMDJSON_CONSTEXPR_LAMBDA simdjson_inline size_t
+find_next_json_quotable_character_scalar(const std::string_view view,
+                                         size_t location) noexcept {
   for (auto pos = view.begin() + location; pos != view.end(); ++pos) {
     if (json_quotable_character[static_cast<uint8_t>(*pos)]) {
       return pos - view.begin();
@@ -151,6 +218,213 @@ find_next_json_quotable_character(const std::string_view view,
   return size_t(view.size());
 }
 
+// SIMD-accelerated position finding that directly locates the first quotable
+// character, combining detection and position extraction in a single pass to
+// minimize redundant work.
+#if SIMDJSON_EXPERIMENTAL_HAS_NEON
+simdjson_inline size_t
+find_next_json_quotable_character(const std::string_view view,
+                                  size_t location) noexcept {
+  const size_t len = view.size();
+  const uint8_t *ptr =
+      reinterpret_cast<const uint8_t *>(view.data()) + location;
+  size_t remaining = len - location;
+
+  // SIMD constants for characters requiring escape
+  uint8x16_t v34 = vdupq_n_u8(34);  // '"'
+  uint8x16_t v92 = vdupq_n_u8(92);  // '\\'
+  uint8x16_t v32 = vdupq_n_u8(32);  // control char threshold
+
+  while (remaining >= 16) {
+    uint8x16_t word = vld1q_u8(ptr);
+
+    // Check for quotable characters: '"', '\\', or control chars (< 32)
+    uint8x16_t needs_escape = vceqq_u8(word, v34);
+    needs_escape = vorrq_u8(needs_escape, vceqq_u8(word, v92));
+    needs_escape = vorrq_u8(needs_escape, vcltq_u8(word, v32));
+
+    const uint8x8_t res = vshrn_n_u16(vreinterpretq_u16_u8(needs_escape), 4);
+    const uint64_t mask = vget_lane_u64(vreinterpret_u64_u8(res), 0);
+    if(mask != 0) {
+      size_t offset = ptr - reinterpret_cast<const uint8_t *>(view.data());
+      auto trailing_zero = trailing_zeroes(mask);
+      return offset + (trailing_zero >> 2);
+    }
+    ptr += 16;
+    remaining -= 16;
+  }
+
+  // Scalar fallback for remaining bytes
+  size_t current = len - remaining;
+  return find_next_json_quotable_character_scalar(view, current);
+}
+#elif SIMDJSON_EXPERIMENTAL_HAS_SSE2
+simdjson_inline size_t
+find_next_json_quotable_character(const std::string_view view,
+                                  size_t location) noexcept {
+  const size_t len = view.size();
+  const uint8_t *ptr =
+      reinterpret_cast<const uint8_t *>(view.data()) + location;
+  size_t remaining = len - location;
+
+  // SIMD constants
+  __m128i v34 = _mm_set1_epi8(34);  // '"'
+  __m128i v92 = _mm_set1_epi8(92);  // '\\'
+  __m128i v31 = _mm_set1_epi8(31);  // for control char detection
+
+  while (remaining >= 16) {
+    __m128i word = _mm_loadu_si128(reinterpret_cast<const __m128i *>(ptr));
+
+    // Check for quotable characters
+    __m128i needs_escape = _mm_cmpeq_epi8(word, v34);
+    needs_escape = _mm_or_si128(needs_escape, _mm_cmpeq_epi8(word, v92));
+    needs_escape = _mm_or_si128(
+        needs_escape,
+        _mm_cmpeq_epi8(_mm_subs_epu8(word, v31), _mm_setzero_si128()));
+
+    int mask = _mm_movemask_epi8(needs_escape);
+    if (mask != 0) {
+      // Found quotable character - use trailing zero count to find position
+      size_t offset = ptr - reinterpret_cast<const uint8_t *>(view.data());
+      return offset + trailing_zeroes(mask);
+    }
+    ptr += 16;
+    remaining -= 16;
+  }
+
+  // Scalar fallback for remaining bytes
+  size_t current = len - remaining;
+  return find_next_json_quotable_character_scalar(view, current);
+}
+#elif SIMDJSON_EXPERIMENTAL_HAS_LSX
+simdjson_inline size_t
+find_next_json_quotable_character(const std::string_view view,
+                                  size_t location) noexcept {
+  const size_t len = view.size();
+  const uint8_t *ptr =
+      reinterpret_cast<const uint8_t *>(view.data()) + location;
+  size_t remaining = len - location;
+
+  //SIMD constants for characters requiring escape
+  __m128i v34 = __lsx_vreplgr2vr_b(34);  // '"'
+  __m128i v92 = __lsx_vreplgr2vr_b(92);  // '\\'
+  __m128i v32 = __lsx_vreplgr2vr_b(32);  // control char threshold
+
+  while (remaining >= 16){
+    __m128i word = __lsx_vld(ptr, 0);
+
+    //Check for the quotable characters: '"', '\\', or control char (<32)
+    __m128i needs_escape = __lsx_vseq_b(word, v34);
+    needs_escape = __lsx_vor_v(needs_escape, __lsx_vseq_b(word, v92));
+    needs_escape = __lsx_vor_v(needs_escape, __lsx_vslt_bu(word, v32));
+
+    if (!__lsx_bz_v(needs_escape)){
+
+      //Found quotable character - extract exact byte position
+      uint64_t lo = __lsx_vpickve2gr_du(needs_escape,0);
+      uint64_t hi = __lsx_vpickve2gr_du(needs_escape,1);
+      size_t offset = ptr - reinterpret_cast<const uint8_t *>(view.data());
+      if ( lo != 0) {
+        return offset + trailing_zeroes(lo) / 8;
+      } else {
+        return offset + 8 + trailing_zeroes(hi) / 8;
+      }
+    }
+    ptr += 16;
+    remaining -= 16;
+  }
+  size_t current = len - remaining;
+  return find_next_json_quotable_character_scalar(view, current);
+}
+#elif SIMDJSON_EXPERIMENTAL_HAS_RVV
+simdjson_inline size_t
+find_next_json_quotable_character(const std::string_view view,
+                                  size_t location) noexcept {
+  const size_t len = view.size();
+  const uint8_t *ptr =
+      reinterpret_cast<const uint8_t *>(view.data()) + location;
+  size_t remaining = len - location;
+
+  while (remaining > 0) {
+    size_t vl = __riscv_vsetvl_e8m1(remaining);
+    vuint8m1_t word = __riscv_vle8_v_u8m1(ptr, vl);
+
+    // Check for quotable characters: '"', '\\', or control chars (< 32)
+    vbool8_t needs_escape = __riscv_vmseq(word, (uint8_t)34, vl);
+    needs_escape = __riscv_vmor(needs_escape,
+        __riscv_vmseq(word, (uint8_t)92, vl), vl);
+    needs_escape = __riscv_vmor(needs_escape,
+        __riscv_vmsltu(word, (uint8_t)32, vl), vl);
+
+    long first = __riscv_vfirst(needs_escape, vl);
+    if (first >= 0) {
+      size_t offset = ptr - reinterpret_cast<const uint8_t *>(view.data());
+      return offset + first;
+    }
+    ptr += vl;
+    remaining -= vl;
+  }
+
+  return len;
+}
+#elif SIMDJSON_EXPERIMENTAL_HAS_PPC64
+simdjson_inline size_t
+find_next_json_quotable_character(const std::string_view view,
+                                  size_t location) noexcept {
+  const size_t len = view.size();
+  const uint8_t *ptr =
+      reinterpret_cast<const uint8_t *>(view.data()) + location;
+  size_t remaining = len - location;
+
+  // SIMD constants for characters requiring escape
+  __vector unsigned char v34 = vec_splats((unsigned char)34);  // '"'
+  __vector unsigned char v92 = vec_splats((unsigned char)92);  // '\\'
+  __vector unsigned char v32 = vec_splats((unsigned char)32);  // control char threshold
+
+  // Bitmask for vec_vbpermq to extract one bit per byte
+  const __vector unsigned char perm_mask = {0x78, 0x70, 0x68, 0x60, 0x58, 0x50,
+                                            0x48, 0x40, 0x38, 0x30, 0x28, 0x20,
+                                            0x18, 0x10, 0x08, 0x00};
+
+  while (remaining >= 16) {
+    __vector unsigned char word =
+        vec_vsx_ld(0, reinterpret_cast<const unsigned char *>(ptr));
+
+    // Check for quotable characters: '"', '\\', or control chars (< 32)
+    __vector unsigned char needs_escape =
+        (__vector unsigned char)vec_cmpeq(word, v34);
+    needs_escape = vec_or(needs_escape,
+        (__vector unsigned char)vec_cmpeq(word, v92));
+    needs_escape = vec_or(needs_escape,
+        (__vector unsigned char)vec_cmplt(word, v32));
+
+    __vector unsigned long long result =
+        (__vector unsigned long long)vec_vbpermq(needs_escape, perm_mask);
+#ifdef __LITTLE_ENDIAN__
+    unsigned int mask = static_cast<unsigned int>(result[1]);
+#else
+    unsigned int mask = static_cast<unsigned int>(result[0]);
+#endif
+    if (mask != 0) {
+      size_t offset = ptr - reinterpret_cast<const uint8_t *>(view.data());
+      return offset + __builtin_ctz(mask);
+    }
+    ptr += 16;
+    remaining -= 16;
+  }
+
+  // Scalar fallback for remaining bytes
+  size_t current = len - remaining;
+  return find_next_json_quotable_character_scalar(view, current);
+}
+#else
+SIMDJSON_CONSTEXPR_LAMBDA simdjson_inline size_t
+find_next_json_quotable_character(const std::string_view view,
+                                  size_t location) noexcept {
+  return find_next_json_quotable_character_scalar(view, location);
+}
+#endif
+
 SIMDJSON_CONSTEXPR_LAMBDA static std::string_view control_chars[] = {
     "\\u0000", "\\u0001", "\\u0002", "\\u0003", "\\u0004", "\\u0005", "\\u0006",
     "\\u0007", "\\b",     "\\t",     "\\n",     "\\u000b", "\\f",     "\\r",
@@ -163,7 +437,7 @@ SIMDJSON_CONSTEXPR_LAMBDA static std::string_view control_chars[] = {
 // control characters (U+0000 through U+001F). There are two-character sequence
 // escape representations of some popular characters:
 // \", \\, \b, \f, \n, \r, \t.
-SIMDJSON_CONSTEXPR_LAMBDA void escape_json_char(char c, char *&out) {
+SIMDJSON_CONSTEXPR_LAMBDA simdjson_inline void escape_json_char(char c, char *&out) {
   if (c == '"') {
     memcpy(out, "\\\"", 2);
     out += 2;
@@ -177,14 +451,20 @@ SIMDJSON_CONSTEXPR_LAMBDA void escape_json_char(char c, char *&out) {
   }
 }
 
+// Writes the escaped version of input to out, returning the number of bytes
+// written. Uses SIMD position finding to locate quotable characters efficiently.
 inline size_t write_string_escaped(const std::string_view input, char *out) {
   size_t mysize = input.size();
-  if (!fast_needs_escaping(input)) { // fast path!
+
+  // Use SIMD position finder directly - it returns mysize if no escape needed
+  size_t location = find_next_json_quotable_character(input, 0);
+  if (location == mysize) {
+    // Fast path: no escaping needed
     memcpy(out, input.data(), input.size());
     return input.size();
   }
+
   const char *const initout = out;
-  size_t location = find_next_json_quotable_character(input, 0);
   memcpy(out, input.data(), location);
   out += location;
   escape_json_char(input[location], out);
@@ -216,7 +496,7 @@ simdjson_inline bool string_builder::capacity_check(size_t upcoming_bytes) {
     return true;
   }
   // check for overflow, most of the time there is no overflow
-  if (simdjson_likely(position + upcoming_bytes < position)) {
+  if (simdjson_unlikely(position + upcoming_bytes < position)) {
     return false;
   }
   // We will rarely get here.
@@ -383,12 +663,29 @@ simdjson_inline void string_builder::append(number_type v) noexcept {
     }
   }
   else SIMDJSON_IF_CONSTEXPR(std::is_unsigned<number_type>::value) {
+    // Process 4 digits at a time instead of 2, reducing store operations
+    // and divisions by approximately half for large numbers.
     constexpr size_t max_number_size = 20;
     if (capacity_check(max_number_size)) {
       using unsigned_type = typename std::make_unsigned<number_type>::type;
       unsigned_type pv = static_cast<unsigned_type>(v);
       size_t dc = internal::digit_count(pv);
       char *write_pointer = buffer.get() + position + dc - 1;
+
+      // Process 4 digits per iteration for large numbers
+      while (pv >= 10000) {
+        unsigned_type q = pv / 10000;
+        unsigned_type r = pv % 10000;
+        unsigned_type r_hi = r / 100;  // High 2 digits of remainder
+        unsigned_type r_lo = r % 100;  // Low 2 digits of remainder
+        // Write low 2 digits first (rightmost), then high 2 digits
+        memcpy(write_pointer - 1, &internal::decimal_table[r_lo * 2], 2);
+        memcpy(write_pointer - 3, &internal::decimal_table[r_hi * 2], 2);
+        write_pointer -= 4;
+        pv = q;
+      }
+
+      // Handle remaining 1-4 digits with original 2-digit loop
       while (pv >= 100) {
         memcpy(write_pointer - 1, &internal::decimal_table[(pv % 100) * 2], 2);
         write_pointer -= 2;
@@ -403,6 +700,7 @@ simdjson_inline void string_builder::append(number_type v) noexcept {
     }
   }
   else SIMDJSON_IF_CONSTEXPR(std::is_integral<number_type>::value) {
+    // Same 4-digit batching as unsigned path for signed integers
     constexpr size_t max_number_size = 20;
     if (capacity_check(max_number_size)) {
       using unsigned_type = typename std::make_unsigned<number_type>::type;
@@ -416,6 +714,20 @@ simdjson_inline void string_builder::append(number_type v) noexcept {
       buffer.get()[position] = '-';
       position += negative ? 1 : 0;
       char *write_pointer = buffer.get() + position + dc - 1;
+
+      // Process 4 digits per iteration for large numbers
+      while (pv >= 10000) {
+        unsigned_type q = pv / 10000;
+        unsigned_type r = pv % 10000;
+        unsigned_type r_hi = r / 100;
+        unsigned_type r_lo = r % 100;
+        memcpy(write_pointer - 1, &internal::decimal_table[r_lo * 2], 2);
+        memcpy(write_pointer - 3, &internal::decimal_table[r_hi * 2], 2);
+        write_pointer -= 4;
+        pv = q;
+      }
+
+      // Handle remaining 1-4 digits
       while (pv >= 100) {
         memcpy(write_pointer - 1, &internal::decimal_table[(pv % 100) * 2], 2);
         write_pointer -= 2;

include/simdjson/generic/builder/json_string_builder.h

@@ -280,7 +280,7 @@ simdjson_warn_unused simdjson_result<std::string> to_json(const Z &z, size_t ini
   return std::string(s);
 }
 template <class Z>
-simdjson_warn_unused simdjson_error to_json(const Z &z, std::string &s, size_t initial_capacity = simdjson::SIMDJSON_IMPLEMENTATION::builder::string_builder::DEFAULT_INITIAL_CAPACITY) {
+simdjson_warn_unused error_code to_json(const Z &z, std::string &s, size_t initial_capacity = simdjson::SIMDJSON_IMPLEMENTATION::builder::string_builder::DEFAULT_INITIAL_CAPACITY) {
   simdjson::SIMDJSON_IMPLEMENTATION::builder::string_builder b(initial_capacity);
   b.append(z);
   std::string_view sv;

include/simdjson/generic/dom_parser_implementation.h

@@ -40,7 +40,6 @@ public:
   simdjson_warn_unused error_code stage1(const uint8_t *buf, size_t len, stage1_mode partial) noexcept final;
   simdjson_warn_unused error_code stage2(dom::document &doc) noexcept final;
   simdjson_warn_unused error_code stage2_next(dom::document &doc) noexcept final;
-  simdjson_warn_unused std::pair<const uint8_t *,bool> parse_string_if_needed(const uint8_t *src, uint8_t *dst, bool allow_replacement) const noexcept final;
   simdjson_warn_unused uint8_t *parse_string(const uint8_t *src, uint8_t *dst, bool allow_replacement) const noexcept final;
   simdjson_warn_unused uint8_t *parse_wobbly_string(const uint8_t *src, uint8_t *dst) const noexcept final;
   inline simdjson_warn_unused error_code set_capacity(size_t capacity) noexcept final;

include/simdjson/generic/ondemand/array-inl.h

@@ -170,46 +170,34 @@ inline simdjson_result<value> array::at_path(std::string_view json_path) noexcep
   return at_pointer(json_pointer);
 }
 
-inline simdjson_result<std::vector<value>> array::at_path_with_wildcard(std::string_view json_path) noexcept {
-  std::vector<value> result;
-
+#if SIMDJSON_SUPPORTS_CONCEPTS
+template <typename Func>
+  requires std::invocable<Func, value>
+#else
+template <typename Func>
+#endif
+inline error_code array::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept {
   auto result_pair = get_next_key_and_json_path(json_path);
   std::string_view key = result_pair.first;
   std::string_view remaining_path = result_pair.second;
   // Wildcard case
-  if(key=="*"){
-    for(auto element: *this){
-
-      if(element.error()){
-        return element.error();
-      }
-
-      if(remaining_path.empty()){
-        // Use value_unsafe() because we've already checked for errors above.
-        // The 'element' is a simdjson_result<value> wrapper, and we need to extract
-        // the underlying value. value_unsafe() is safe here because error() returned false.
-        result.push_back(std::move(element).value_unsafe());
-
-      }else{
-        auto nested_result = element.at_path_with_wildcard(remaining_path);
-
-        if(nested_result.error()){
-          return nested_result.error();
-        }
-        // Same logic as above.
-        std::vector<value> nested_matches = std::move(nested_result).value_unsafe();
-
-        result.insert(result.end(),
-                      std::make_move_iterator(nested_matches.begin()),
-                      std::make_move_iterator(nested_matches.end()));
+  if (key=="*"){
+    for(auto element: *this) {
+      value val;
+        SIMDJSON_TRY(element.get(val));
+      if (remaining_path.empty()) {
+        callback(val);
+      } else {
+        error_code err = element.for_each_at_path_with_wildcard(remaining_path, callback);
+        if(err) { return err; }
       }
     }
-    return result;
-  }else{
+    return SUCCESS;
+  } else {
     // Specific index case in which we access the element at the given index
-    size_t idx=0;
+    size_t idx = 0;
 
-    for(char c:key){
+    for (char c : key) {
       if(c < '0' || c > '9'){
         return INVALID_JSON_POINTER;
       }
@@ -217,16 +205,13 @@ inline simdjson_result<std::vector<value>> array::at_path_with_wildcard(std::str
     }
 
     auto element = at(idx);
-
-    if(element.error()){
-      return element.error();
-    }
-
-    if(remaining_path.empty()){
-      result.push_back(std::move(element).value_unsafe());
-      return result;
-    }else{
-      return element.at_path_with_wildcard(remaining_path);
+    value val;
+    SIMDJSON_TRY(element.get(val));
+    if (remaining_path.empty()){
+      callback(val);
+      return SUCCESS;
+    } else {
+      return element.for_each_at_path_with_wildcard(remaining_path, callback);
     }
   }
 }
@@ -289,9 +274,15 @@ simdjson_inline  simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> simdj
   if (error()) { return error(); }
   return first.at_path(json_path);
 }
-simdjson_inline simdjson_result<std::vector<SIMDJSON_IMPLEMENTATION::ondemand::value>> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::array>::at_path_with_wildcard(std::string_view json_path) noexcept {
+#if SIMDJSON_SUPPORTS_CONCEPTS
+template <typename Func>
+  requires std::invocable<Func, SIMDJSON_IMPLEMENTATION::ondemand::value>
+#else
+template <typename Func>
+#endif
+simdjson_inline error_code simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::array>::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept {
   if (error()) { return error(); }
-  return first.at_path_with_wildcard(json_path);
+  return first.for_each_at_path_with_wildcard(json_path, std::forward<Func>(callback));
 }
 simdjson_inline  simdjson_result<std::string_view> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::array>::raw_json() noexcept {
   if (error()) { return error(); }

include/simdjson/generic/ondemand/array.h

@@ -119,13 +119,21 @@ public:
   inline simdjson_result<value> at_path(std::string_view json_path) noexcept;
 
   /**
-   * Get all values matching the given JSONPath expression with wildcard support.
+   * Call the provided callback for each value matching the given JSONPath
+   * expression with wildcard support.
    * Supports wildcard patterns like "[*]" to match all array elements.
    *
    * @param json_path JSONPath expression with wildcards
-   * @return Vector of values matching the wildcard pattern
+   * @param callback Function called for each matching value
+   * @return error_code indicating success or failure
   */
-  inline simdjson_result<std::vector<value>> at_path_with_wildcard(std::string_view json_path) noexcept;
+#if SIMDJSON_SUPPORTS_CONCEPTS
+  template <typename Func>
+    requires std::invocable<Func, value>
+#else
+  template <typename Func>
+#endif
+  inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept;
 
   /**
    * Consumes the array and returns a string_view instance corresponding to the
@@ -249,7 +257,13 @@ public:
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> at(size_t index) noexcept;
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> at_pointer(std::string_view json_pointer) noexcept;
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> at_path(std::string_view json_path) noexcept;
-  simdjson_inline simdjson_result<std::vector<SIMDJSON_IMPLEMENTATION::ondemand::value>> at_path_with_wildcard(std::string_view json_path) noexcept;
+#if SIMDJSON_SUPPORTS_CONCEPTS
+  template <typename Func>
+    requires std::invocable<Func, SIMDJSON_IMPLEMENTATION::ondemand::value>
+#else
+  template <typename Func>
+#endif
+  simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept;
   simdjson_inline simdjson_result<std::string_view> raw_json() noexcept;
 #if SIMDJSON_SUPPORTS_CONCEPTS
   // TODO: move this code into object-inl.h

include/simdjson/generic/ondemand/document-inl.h

@@ -16,6 +16,8 @@
 #include "simdjson/generic/ondemand/deserialize.h"
 #endif // SIMDJSON_CONDITIONAL_INCLUDE
 
+#include <limits>
+
 namespace simdjson {
 namespace SIMDJSON_IMPLEMENTATION {
 namespace ondemand {
@@ -131,6 +133,18 @@ simdjson_inline simdjson_result<int64_t> document::get_int64() noexcept {
 simdjson_inline simdjson_result<int64_t> document::get_int64_in_string() noexcept {
   return get_root_value_iterator().get_root_int64_in_string(true);
 }
+simdjson_inline simdjson_result<uint32_t> document::get_uint32() noexcept {
+  uint64_t result;
+  SIMDJSON_TRY(get_uint64().get(result));
+  if (result > (std::numeric_limits<uint32_t>::max)()) { return NUMBER_OUT_OF_RANGE; }
+  return static_cast<uint32_t>(result);
+}
+simdjson_inline simdjson_result<int32_t> document::get_int32() noexcept {
+  int64_t result;
+  SIMDJSON_TRY(get_int64().get(result));
+  if (result > (std::numeric_limits<int32_t>::max)() || result < (std::numeric_limits<int32_t>::min)()) { return NUMBER_OUT_OF_RANGE; }
+  return static_cast<int32_t>(result);
+}
 simdjson_inline simdjson_result<double> document::get_double() noexcept {
   return get_root_value_iterator().get_root_double(true);
 }
@@ -164,6 +178,8 @@ template<> simdjson_inline simdjson_result<std::string_view> document::get() & n
 template<> simdjson_inline simdjson_result<double> document::get() & noexcept { return get_double(); }
 template<> simdjson_inline simdjson_result<uint64_t> document::get() & noexcept { return get_uint64(); }
 template<> simdjson_inline simdjson_result<int64_t> document::get() & noexcept { return get_int64(); }
+template<> simdjson_inline simdjson_result<uint32_t> document::get() & noexcept { return get_uint32(); }
+template<> simdjson_inline simdjson_result<int32_t> document::get() & noexcept { return get_int32(); }
 template<> simdjson_inline simdjson_result<bool> document::get() & noexcept { return get_bool(); }
 template<> simdjson_inline simdjson_result<value> document::get() & noexcept { return get_value(); }
 
@@ -174,6 +190,8 @@ template<> simdjson_warn_unused simdjson_inline error_code document::get(std::st
 template<> simdjson_warn_unused simdjson_inline error_code document::get(double& out) & noexcept { return get_double().get(out); }
 template<> simdjson_warn_unused simdjson_inline error_code document::get(uint64_t& out) & noexcept { return get_uint64().get(out); }
 template<> simdjson_warn_unused simdjson_inline error_code document::get(int64_t& out) & noexcept { return get_int64().get(out); }
+template<> simdjson_warn_unused simdjson_inline error_code document::get(uint32_t& out) & noexcept { return get_uint32().get(out); }
+template<> simdjson_warn_unused simdjson_inline error_code document::get(int32_t& out) & noexcept { return get_int32().get(out); }
 template<> simdjson_warn_unused simdjson_inline error_code document::get(bool& out) & noexcept { return get_bool().get(out); }
 template<> simdjson_warn_unused simdjson_inline error_code document::get(value& out) & noexcept { return get_value().get(out); }
 
@@ -347,8 +365,14 @@ simdjson_inline simdjson_result<value> document::at_path(std::string_view json_p
   }
 }
 
-simdjson_inline simdjson_result<std::vector<value>> document::at_path_with_wildcard(std::string_view json_path) noexcept {
-  rewind(); // Rewind the document each time at_path_with_wildcard is called
+#if SIMDJSON_SUPPORTS_CONCEPTS
+template <typename Func>
+  requires std::invocable<Func, value>
+#else
+template <typename Func>
+#endif
+simdjson_inline error_code document::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept {
+  rewind(); // Rewind the document each time for_each_at_path_with_wildcard is called
   if (json_path.empty()) {
       return INVALID_JSON_POINTER;
   }
@@ -356,9 +380,9 @@ simdjson_inline simdjson_result<std::vector<value>> document::at_path_with_wildc
   SIMDJSON_TRY(type().get(t));
   switch (t) {
   case json_type::array:
-      return (*this).get_array().at_path_with_wildcard(json_path);
+      return (*this).get_array().for_each_at_path_with_wildcard(json_path, std::forward<Func>(callback));
   case json_type::object:
-      return (*this).get_object().at_path_with_wildcard(json_path);
+      return (*this).get_object().for_each_at_path_with_wildcard(json_path, std::forward<Func>(callback));
   default:
       return INVALID_JSON_POINTER;
   }
@@ -504,6 +528,14 @@ simdjson_inline simdjson_result<int64_t> simdjson_result<SIMDJSON_IMPLEMENTATION
   if (error()) { return error(); }
   return first.get_int64_in_string();
 }
+simdjson_inline simdjson_result<uint32_t> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::get_uint32() noexcept {
+  if (error()) { return error(); }
+  return first.get_uint32();
+}
+simdjson_inline simdjson_result<int32_t> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::get_int32() noexcept {
+  if (error()) { return error(); }
+  return first.get_int32();
+}
 simdjson_inline simdjson_result<double> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::get_double() noexcept {
   if (error()) { return error(); }
   return first.get_double();
@@ -687,9 +719,15 @@ simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> simdjs
   return first.at_path(json_path);
 }
 
-simdjson_inline simdjson_result<std::vector<SIMDJSON_IMPLEMENTATION::ondemand::value>> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::at_path_with_wildcard(std::string_view json_path) noexcept {
+#if SIMDJSON_SUPPORTS_CONCEPTS
+template <typename Func>
+  requires std::invocable<Func, SIMDJSON_IMPLEMENTATION::ondemand::value>
+#else
+template <typename Func>
+#endif
+simdjson_inline error_code simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept {
   if (error()) { return error(); }
-  return first.at_path_with_wildcard(json_path);
+  return first.for_each_at_path_with_wildcard(json_path, std::forward<Func>(callback));
 }
 
 #if SIMDJSON_STATIC_REFLECTION
@@ -731,6 +769,18 @@ simdjson_inline simdjson_result<uint64_t> document_reference::get_uint64() noexc
 simdjson_inline simdjson_result<uint64_t> document_reference::get_uint64_in_string() noexcept { return doc->get_root_value_iterator().get_root_uint64_in_string(false); }
 simdjson_inline simdjson_result<int64_t> document_reference::get_int64() noexcept { return doc->get_root_value_iterator().get_root_int64(false); }
 simdjson_inline simdjson_result<int64_t> document_reference::get_int64_in_string() noexcept { return doc->get_root_value_iterator().get_root_int64_in_string(false); }
+simdjson_inline simdjson_result<uint32_t> document_reference::get_uint32() noexcept {
+  uint64_t result;
+  SIMDJSON_TRY(doc->get_root_value_iterator().get_root_uint64(false).get(result));
+  if (result > (std::numeric_limits<uint32_t>::max)()) { return NUMBER_OUT_OF_RANGE; }
+  return static_cast<uint32_t>(result);
+}
+simdjson_inline simdjson_result<int32_t> document_reference::get_int32() noexcept {
+  int64_t result;
+  SIMDJSON_TRY(doc->get_root_value_iterator().get_root_int64(false).get(result));
+  if (result > (std::numeric_limits<int32_t>::max)() || result < (std::numeric_limits<int32_t>::min)()) { return NUMBER_OUT_OF_RANGE; }
+  return static_cast<int32_t>(result);
+}
 simdjson_inline simdjson_result<double> document_reference::get_double() noexcept { return doc->get_root_value_iterator().get_root_double(false); }
 simdjson_inline simdjson_result<double> document_reference::get_double_in_string() noexcept { return doc->get_root_value_iterator().get_root_double(false); }
 simdjson_inline simdjson_result<std::string_view> document_reference::get_string(bool allow_replacement) noexcept { return doc->get_root_value_iterator().get_root_string(false, allow_replacement); }
@@ -748,6 +798,8 @@ template<> simdjson_inline simdjson_result<std::string_view> document_reference:
 template<> simdjson_inline simdjson_result<double> document_reference::get() & noexcept { return get_double(); }
 template<> simdjson_inline simdjson_result<uint64_t> document_reference::get() & noexcept { return get_uint64(); }
 template<> simdjson_inline simdjson_result<int64_t> document_reference::get() & noexcept { return get_int64(); }
+template<> simdjson_inline simdjson_result<uint32_t> document_reference::get() & noexcept { return get_uint32(); }
+template<> simdjson_inline simdjson_result<int32_t> document_reference::get() & noexcept { return get_int32(); }
 template<> simdjson_inline simdjson_result<bool> document_reference::get() & noexcept { return get_bool(); }
 template<> simdjson_inline simdjson_result<value> document_reference::get() & noexcept { return get_value(); }
 #if SIMDJSON_EXCEPTIONS
@@ -786,7 +838,13 @@ simdjson_inline simdjson_result<number> document_reference::get_number() noexcep
 simdjson_inline simdjson_result<std::string_view> document_reference::raw_json_token() noexcept { return doc->raw_json_token(); }
 simdjson_inline simdjson_result<value> document_reference::at_pointer(std::string_view json_pointer) noexcept { return doc->at_pointer(json_pointer); }
 simdjson_inline simdjson_result<value> document_reference::at_path(std::string_view json_path) noexcept { return doc->at_path(json_path); }
-simdjson_inline simdjson_result<std::vector<value>> document_reference::at_path_with_wildcard(std::string_view json_path) noexcept { return doc->at_path_with_wildcard(json_path); }
+#if SIMDJSON_SUPPORTS_CONCEPTS
+template <typename Func>
+  requires std::invocable<Func, value>
+#else
+template <typename Func>
+#endif
+simdjson_inline error_code document_reference::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { return doc->for_each_at_path_with_wildcard(json_path, std::forward<Func>(callback)); }
 simdjson_inline simdjson_result<std::string_view> document_reference::raw_json() noexcept { return doc->raw_json();}
 simdjson_inline document_reference::operator document&() const noexcept { return *doc; }
 #if SIMDJSON_SUPPORTS_CONCEPTS && SIMDJSON_STATIC_REFLECTION
@@ -879,6 +937,14 @@ simdjson_inline simdjson_result<int64_t> simdjson_result<SIMDJSON_IMPLEMENTATION
   if (error()) { return error(); }
   return first.get_int64_in_string();
 }
+simdjson_inline simdjson_result<uint32_t> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::get_uint32() noexcept {
+  if (error()) { return error(); }
+  return first.get_uint32();
+}
+simdjson_inline simdjson_result<int32_t> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::get_int32() noexcept {
+  if (error()) { return error(); }
+  return first.get_int32();
+}
 simdjson_inline simdjson_result<double> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::get_double() noexcept {
   if (error()) { return error(); }
   return first.get_double();
@@ -1043,11 +1109,17 @@ simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> simdjs
   }
   return first.at_path(json_path);
 }
-simdjson_inline simdjson_result<std::vector<SIMDJSON_IMPLEMENTATION::ondemand::value>> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::at_path_with_wildcard(std::string_view json_path) noexcept {
+#if SIMDJSON_SUPPORTS_CONCEPTS
+template <typename Func>
+  requires std::invocable<Func, SIMDJSON_IMPLEMENTATION::ondemand::value>
+#else
+template <typename Func>
+#endif
+simdjson_inline error_code simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept {
   if (error()) {
       return error();
   }
-  return first.at_path_with_wildcard(json_path);
+  return first.for_each_at_path_with_wildcard(json_path, std::forward<Func>(callback));
 }
 #if SIMDJSON_STATIC_REFLECTION
 template<constevalutil::fixed_string... FieldNames, typename T>

include/simdjson/generic/ondemand/document.h

@@ -76,6 +76,26 @@ public:
    * @returns INCORRECT_TYPE If the JSON value is not a 64-bit integer.
    */
   simdjson_inline simdjson_result<int64_t> get_int64_in_string() noexcept;
+  /**
+   * Cast this JSON value to a 32-bit unsigned integer.
+   *
+   * Calls get_uint64() and checks that the result fits in a uint32_t.
+   *
+   * @returns A 32-bit unsigned integer.
+   * @returns INCORRECT_TYPE If the JSON value is not an unsigned integer.
+   * @returns NUMBER_OUT_OF_RANGE If the value does not fit in a uint32_t.
+   */
+  simdjson_inline simdjson_result<uint32_t> get_uint32() noexcept;
+  /**
+   * Cast this JSON value to a 32-bit signed integer.
+   *
+   * Calls get_int64() and checks that the result fits in an int32_t.
+   *
+   * @returns A 32-bit signed integer.
+   * @returns INCORRECT_TYPE If the JSON value is not an integer.
+   * @returns NUMBER_OUT_OF_RANGE If the value does not fit in an int32_t.
+   */
+  simdjson_inline simdjson_result<int32_t> get_int32() noexcept;
   /**
    * Cast this JSON value to a double.
    *
@@ -724,21 +744,24 @@ public:
   simdjson_inline simdjson_result<value> at_path(std::string_view json_path) noexcept;
 
   /**
-   * Get all values matching the given JSONPath expression with wildcard support.
+   * Call the provided callback for each value matching the given JSONPath
+   * expression with wildcard support.
    *
    * Supports wildcard patterns like "$.array[*]" or "$.object.*" to match multiple elements.
    *
-   * This method materializes all matching values into a vector.
    * The document will be consumed after this call.
    *
    * @param json_path JSONPath expression with wildcards
-   * @return Vector of values matching the wildcard pattern, or:
-   *         - INVALID_JSON_POINTER if the JSONPath cannot be parsed
-   *         - NO_SUCH_FIELD if a field does not exist
-   *         - INDEX_OUT_OF_BOUNDS if an array index is out of bounds
-   *         - INCORRECT_TYPE if path traversal encounters wrong type
+   * @param callback Function called for each matching value
+   * @return error_code indicating success or failure
    */
-  simdjson_inline simdjson_result<std::vector<value>> at_path_with_wildcard(std::string_view json_path) noexcept;
+#if SIMDJSON_SUPPORTS_CONCEPTS
+  template <typename Func>
+    requires std::invocable<Func, value>
+#else
+  template <typename Func>
+#endif
+  simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept;
 
   /**
    * Consumes the document and returns a string_view instance corresponding to the
@@ -829,6 +852,8 @@ public:
   simdjson_inline simdjson_result<uint64_t> get_uint64_in_string() noexcept;
   simdjson_inline simdjson_result<int64_t> get_int64() noexcept;
   simdjson_inline simdjson_result<int64_t> get_int64_in_string() noexcept;
+  simdjson_inline simdjson_result<uint32_t> get_uint32() noexcept;
+  simdjson_inline simdjson_result<int32_t> get_int32() noexcept;
   simdjson_inline simdjson_result<double> get_double() noexcept;
   simdjson_inline simdjson_result<double> get_double_in_string() noexcept;
   simdjson_inline simdjson_result<std::string_view> get_string(bool allow_replacement = false) noexcept;
@@ -957,7 +982,13 @@ public:
   simdjson_inline simdjson_result<std::string_view> raw_json_token() noexcept;
   simdjson_inline simdjson_result<value> at_pointer(std::string_view json_pointer) noexcept;
   simdjson_inline simdjson_result<value> at_path(std::string_view json_path) noexcept;
-  simdjson_inline simdjson_result<std::vector<value>> at_path_with_wildcard(std::string_view json_path) noexcept;
+#if SIMDJSON_SUPPORTS_CONCEPTS
+  template <typename Func>
+    requires std::invocable<Func, value>
+#else
+  template <typename Func>
+#endif
+  simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept;
 
 private:
   document *doc{nullptr};
@@ -982,6 +1013,8 @@ public:
   simdjson_inline simdjson_result<uint64_t> get_uint64_in_string() noexcept;
   simdjson_inline simdjson_result<int64_t> get_int64() noexcept;
   simdjson_inline simdjson_result<int64_t> get_int64_in_string() noexcept;
+  simdjson_inline simdjson_result<uint32_t> get_uint32() noexcept;
+  simdjson_inline simdjson_result<int32_t> get_int32() noexcept;
   simdjson_inline simdjson_result<double> get_double() noexcept;
   simdjson_inline simdjson_result<double> get_double_in_string() noexcept;
   simdjson_inline simdjson_result<std::string_view> get_string(bool allow_replacement = false) noexcept;
@@ -1041,7 +1074,13 @@ public:
 
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> at_pointer(std::string_view json_pointer) noexcept;
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> at_path(std::string_view json_path) noexcept;
-  simdjson_inline simdjson_result<std::vector<SIMDJSON_IMPLEMENTATION::ondemand::value>> at_path_with_wildcard(std::string_view json_path) noexcept;
+#if SIMDJSON_SUPPORTS_CONCEPTS
+  template <typename Func>
+    requires std::invocable<Func, SIMDJSON_IMPLEMENTATION::ondemand::value>
+#else
+  template <typename Func>
+#endif
+  simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept;
 #if SIMDJSON_STATIC_REFLECTION
   template<constevalutil::fixed_string... FieldNames, typename T>
     requires(std::is_class_v<T> && (sizeof...(FieldNames) > 0))
@@ -1069,6 +1108,8 @@ public:
   simdjson_inline simdjson_result<uint64_t> get_uint64_in_string() noexcept;
   simdjson_inline simdjson_result<int64_t> get_int64() noexcept;
   simdjson_inline simdjson_result<int64_t> get_int64_in_string() noexcept;
+  simdjson_inline simdjson_result<uint32_t> get_uint32() noexcept;
+  simdjson_inline simdjson_result<int32_t> get_int32() noexcept;
   simdjson_inline simdjson_result<double> get_double() noexcept;
   simdjson_inline simdjson_result<double> get_double_in_string() noexcept;
   simdjson_inline simdjson_result<std::string_view> get_string(bool allow_replacement = false) noexcept;
@@ -1124,7 +1165,13 @@ public:
 
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> at_pointer(std::string_view json_pointer) noexcept;
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> at_path(std::string_view json_path) noexcept;
-  simdjson_inline simdjson_result<std::vector<SIMDJSON_IMPLEMENTATION::ondemand::value>> at_path_with_wildcard(std::string_view json_path) noexcept;
+#if SIMDJSON_SUPPORTS_CONCEPTS
+  template <typename Func>
+    requires std::invocable<Func, SIMDJSON_IMPLEMENTATION::ondemand::value>
+#else
+  template <typename Func>
+#endif
+  simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept;
 #if SIMDJSON_STATIC_REFLECTION
   template<constevalutil::fixed_string... FieldNames, typename T>
     requires(std::is_class_v<T> && (sizeof...(FieldNames) > 0))

include/simdjson/generic/ondemand/json_iterator-inl.h

@@ -364,7 +364,7 @@ simdjson_inline simdjson_result<std::string_view> json_iterator::unescape(raw_js
 #endif // !defined(SIMDJSON_VISUAL_STUDIO) && !defined(SIMDJSON_CLANG_VISUAL_STUDIO)
   return result;
 #else
-  return parser->unescape_maybe(in, _string_buf_loc, allow_replacement);
+  return parser->unescape(in, _string_buf_loc, allow_replacement);
 #endif
 }
 

include/simdjson/generic/ondemand/object-inl.h

@@ -177,9 +177,13 @@ inline simdjson_result<value> object::at_path(std::string_view json_path) noexce
   return at_pointer(json_pointer);
 }
 
-inline simdjson_result<std::vector<value>> object::at_path_with_wildcard(std::string_view json_path) noexcept {
-  std::vector<value> result;
-
+#if SIMDJSON_SUPPORTS_CONCEPTS
+template <typename Func>
+  requires std::invocable<Func, value>
+#else
+template <typename Func>
+#endif
+inline error_code object::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept {
   auto result_pair = get_next_key_and_json_path(json_path);
   std::string_view key = result_pair.first;
   std::string_view remaining_path = result_pair.second;
@@ -189,34 +193,22 @@ inline simdjson_result<std::vector<value>> object::at_path_with_wildcard(std::st
     for (auto field : *this) {
       value val;
       SIMDJSON_TRY(field.value().get(val));
-
       if (remaining_path.empty()) {
-        result.push_back(std::move(val));
+        callback(val);
       } else {
-        auto nested_result = val.at_path_with_wildcard(remaining_path);
-
-        if (nested_result.error()) {
-          return nested_result.error();
-        }
-        // Extract and append all nested matches to our result
-        std::vector<value> nested_vec;
-        SIMDJSON_TRY(std::move(nested_result).get(nested_vec));
-
-        result.insert(result.end(),
-                     std::make_move_iterator(nested_vec.begin()),
-                     std::make_move_iterator(nested_vec.end()));
+        SIMDJSON_TRY(val.for_each_at_path_with_wildcard(remaining_path, callback));
       }
     }
-    return result;
+    return SUCCESS;
   } else {
     value val;
     SIMDJSON_TRY(find_field(key).get(val));
 
     if (remaining_path.empty()) {
-      result.push_back(std::move(val));
-      return result;
+      callback(val);
+      return SUCCESS;
     } else {
-      return val.at_path_with_wildcard(remaining_path);
+      return val.for_each_at_path_with_wildcard(remaining_path, callback);
     }
   }
 }
@@ -347,9 +339,15 @@ simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> simdjs
   return first.at_path(json_path);
 }
 
-simdjson_inline simdjson_result<std::vector<SIMDJSON_IMPLEMENTATION::ondemand::value>> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::object>::at_path_with_wildcard(std::string_view json_path) noexcept {
+#if SIMDJSON_SUPPORTS_CONCEPTS
+template <typename Func>
+  requires std::invocable<Func, SIMDJSON_IMPLEMENTATION::ondemand::value>
+#else
+template <typename Func>
+#endif
+simdjson_inline error_code simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::object>::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept {
   if (error()) { return error(); }
-  return first.at_path_with_wildcard(json_path);
+  return first.for_each_at_path_with_wildcard(json_path, std::forward<Func>(callback));
 }
 
 inline simdjson_result<bool> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::object>::reset() noexcept {

include/simdjson/generic/ondemand/object.h

@@ -172,13 +172,21 @@ public:
   inline simdjson_result<value> at_path(std::string_view json_path) noexcept;
 
   /**
-   * Get all values matching the given JSONPath expression with wildcard support.
+   * Call the provided callback for each value matching the given JSONPath
+   * expression with wildcard support.
    * Supports wildcard patterns like ".*" to match all object fields.
    *
    * @param json_path JSONPath expression with wildcards
-   * @return Vector of values matching the wildcard pattern
+   * @param callback Function called for each matching value
+   * @return error_code indicating success or failure
   */
-  inline simdjson_result<std::vector<value>> at_path_with_wildcard(std::string_view json_path) noexcept;
+#if SIMDJSON_SUPPORTS_CONCEPTS
+  template <typename Func>
+    requires std::invocable<Func, value>
+#else
+  template <typename Func>
+#endif
+  inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept;
 
   /**
    * Reset the iterator so that we are pointing back at the
@@ -328,7 +336,13 @@ public:
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> operator[](std::string_view key) && noexcept;
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> at_pointer(std::string_view json_pointer) noexcept;
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> at_path(std::string_view json_path) noexcept;
-  simdjson_inline simdjson_result<std::vector<SIMDJSON_IMPLEMENTATION::ondemand::value>> at_path_with_wildcard(std::string_view json_path) noexcept;
+#if SIMDJSON_SUPPORTS_CONCEPTS
+  template <typename Func>
+    requires std::invocable<Func, SIMDJSON_IMPLEMENTATION::ondemand::value>
+#else
+  template <typename Func>
+#endif
+  simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept;
   inline simdjson_result<bool> reset() noexcept;
   inline simdjson_result<bool> is_empty() noexcept;
   inline simdjson_result<size_t> count_fields() & noexcept;

include/simdjson/generic/ondemand/parser-inl.h

@@ -172,27 +172,13 @@ simdjson_pure simdjson_inline size_t parser::max_depth() const noexcept {
 }
 
 simdjson_inline void parser::set_max_capacity(size_t max_capacity) noexcept {
-  if(max_capacity < dom::MINIMAL_DOCUMENT_CAPACITY) {
+  if(max_capacity > dom::MINIMAL_DOCUMENT_CAPACITY) {
     _max_capacity = max_capacity;
   } else {
     _max_capacity = dom::MINIMAL_DOCUMENT_CAPACITY;
   }
 }
 
-simdjson_inline simdjson_warn_unused simdjson_result<std::string_view> parser::unescape_maybe(raw_json_string in, uint8_t *&dst, bool allow_replacement) const noexcept {
-  std::pair<const uint8_t *, bool> result = implementation->parse_string_if_needed(in.buf, dst, allow_replacement);
-  const uint8_t *end = result.first;
-  bool copied = result.second;
-  if (!end) { return STRING_ERROR; }
-  if(copied) {
-    std::string_view strresult(reinterpret_cast<const char *>(dst), end-dst);
-    dst = const_cast<uint8_t *>(end);
-    return strresult;
-  }
-  // fast path, no copy was made!!!
-  return std::string_view(reinterpret_cast<const char *>(in.buf), end-in.buf);
-}
-
 simdjson_inline simdjson_warn_unused simdjson_result<std::string_view> parser::unescape(raw_json_string in, uint8_t *&dst, bool allow_replacement) const noexcept {
   uint8_t *end = implementation->parse_string(in.buf, dst, allow_replacement);
   if (!end) { return STRING_ERROR; }

include/simdjson/generic/ondemand/parser.h

@@ -334,32 +334,6 @@ public:
    */
   simdjson_inline simdjson_result<std::string_view> unescape(raw_json_string in, uint8_t *&dst, bool allow_replacement = false) const noexcept;
 
-  /**
-   * Unescape this JSON string, replacing \\ with \, \n with newline, etc. to a user-provided buffer if
-   * needed. If no escaping is done, the string is returned as is and dst is not not changed.
-   * The result must be valid UTF-8.
-   * The provided pointer is advanced to the end of the string by reference if a copy is needed,
-    * and a string_view instance
-   * is returned. You can ensure that your buffer is large enough by allocating a block of memory at least
-   * as large as the input JSON plus SIMDJSON_PADDING and then unescape all strings to this one buffer.
-   *
-   * This unescape_maybe function is a low-level function. If you want a more user-friendly approach, you should
-   * avoid raw_json_string instances (e.g., by calling unescaped_key() instead of key() or get_string()
-   * instead of get_raw_json_string()).
-   *
-   * ## IMPORTANT: string_view lifetime
-   *
-   * The string_view is only valid as long as the bytes in dst.
-   *
-   * @param raw_json_string input
-   * @param dst A pointer to a buffer at least large enough to write this string as well as
-   *            an additional SIMDJSON_PADDING bytes.
-   * @param allow_replacement Whether we allow a replacement if the input string contains unmatched surrogate pairs.
-   * @return A string_view pointing at the unescaped string in dst
-   * @error STRING_ERROR if escapes are incorrect.
-   */
-  simdjson_inline simdjson_result<std::string_view> unescape_maybe(raw_json_string in, uint8_t *&dst, bool allow_replacement = false) const noexcept;
-
   /**
    * Unescape this JSON string, replacing \\ with \, \n with newline, etc. to a user-provided buffer.
    * The result may not be valid UTF-8. See https://simonsapin.github.io/wtf-8/

include/simdjson/generic/ondemand/value-inl.h

@@ -12,6 +12,8 @@
 #include "simdjson/generic/ondemand/value.h"
 #endif // SIMDJSON_CONDITIONAL_INCLUDE
 
+#include <limits>
+
 namespace simdjson {
 namespace SIMDJSON_IMPLEMENTATION {
 namespace ondemand {
@@ -72,6 +74,18 @@ simdjson_inline simdjson_result<int64_t> value::get_int64() noexcept {
 simdjson_inline simdjson_result<int64_t> value::get_int64_in_string() noexcept {
   return iter.get_int64_in_string();
 }
+simdjson_inline simdjson_result<uint32_t> value::get_uint32() noexcept {
+  uint64_t result;
+  SIMDJSON_TRY(get_uint64().get(result));
+  if (result > (std::numeric_limits<uint32_t>::max)()) { return NUMBER_OUT_OF_RANGE; }
+  return static_cast<uint32_t>(result);
+}
+simdjson_inline simdjson_result<int32_t> value::get_int32() noexcept {
+  int64_t result;
+  SIMDJSON_TRY(get_int64().get(result));
+  if (result > (std::numeric_limits<int32_t>::max)() || result < (std::numeric_limits<int32_t>::min)()) { return NUMBER_OUT_OF_RANGE; }
+  return static_cast<int32_t>(result);
+}
 simdjson_inline simdjson_result<bool> value::get_bool() noexcept {
   return iter.get_bool();
 }
@@ -87,6 +101,8 @@ template<> simdjson_inline simdjson_result<number> value::get() noexcept { retur
 template<> simdjson_inline simdjson_result<double> value::get() noexcept { return get_double(); }
 template<> simdjson_inline simdjson_result<uint64_t> value::get() noexcept { return get_uint64(); }
 template<> simdjson_inline simdjson_result<int64_t> value::get() noexcept { return get_int64(); }
+template<> simdjson_inline simdjson_result<uint32_t> value::get() noexcept { return get_uint32(); }
+template<> simdjson_inline simdjson_result<int32_t> value::get() noexcept { return get_int32(); }
 template<> simdjson_inline simdjson_result<bool> value::get() noexcept { return get_bool(); }
 
 
@@ -98,6 +114,8 @@ template<> simdjson_warn_unused simdjson_inline error_code value::get(number& ou
 template<> simdjson_warn_unused simdjson_inline error_code value::get(double& out) noexcept { return get_double().get(out); }
 template<> simdjson_warn_unused simdjson_inline error_code value::get(uint64_t& out) noexcept { return get_uint64().get(out); }
 template<> simdjson_warn_unused simdjson_inline error_code value::get(int64_t& out) noexcept { return get_int64().get(out); }
+template<> simdjson_warn_unused simdjson_inline error_code value::get(uint32_t& out) noexcept { return get_uint32().get(out); }
+template<> simdjson_warn_unused simdjson_inline error_code value::get(int32_t& out) noexcept { return get_int32().get(out); }
 template<>  simdjson_warn_unused simdjson_inline error_code value::get(bool& out) noexcept { return get_bool().get(out); }
 
 #if SIMDJSON_EXCEPTIONS
@@ -296,14 +314,20 @@ simdjson_inline simdjson_result<value> value::at_path(std::string_view json_path
   }
 }
 
-inline simdjson_result<std::vector<value>> value::at_path_with_wildcard(std::string_view json_path) noexcept {
+#if SIMDJSON_SUPPORTS_CONCEPTS
+template <typename Func>
+  requires std::invocable<Func, value>
+#else
+template <typename Func>
+#endif
+inline error_code value::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept {
   json_type t;
   SIMDJSON_TRY(type().get(t));
   switch (t) {
   case json_type::array:
-      return (*this).get_array().at_path_with_wildcard(json_path);
+      return (*this).get_array().for_each_at_path_with_wildcard(json_path, std::forward<Func>(callback));
   case json_type::object:
-      return (*this).get_object().at_path_with_wildcard(json_path);
+      return (*this).get_object().for_each_at_path_with_wildcard(json_path, std::forward<Func>(callback));
   default:
       return INVALID_JSON_POINTER;
   }
@@ -401,6 +425,14 @@ simdjson_inline simdjson_result<int64_t> simdjson_result<SIMDJSON_IMPLEMENTATION
   if (error()) { return error(); }
   return first.get_int64_in_string();
 }
+simdjson_inline simdjson_result<uint32_t> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value>::get_uint32() noexcept {
+  if (error()) { return error(); }
+  return first.get_uint32();
+}
+simdjson_inline simdjson_result<int32_t> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value>::get_int32() noexcept {
+  if (error()) { return error(); }
+  return first.get_int32();
+}
 simdjson_inline simdjson_result<double> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value>::get_double() noexcept {
   if (error()) { return error(); }
   return first.get_double();
@@ -559,12 +591,18 @@ simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> simdjs
   return first.at_path(json_path);
 }
 
-inline simdjson_result<std::vector<SIMDJSON_IMPLEMENTATION::ondemand::value>> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value>::at_path_with_wildcard(
-      std::string_view json_path) noexcept {
+#if SIMDJSON_SUPPORTS_CONCEPTS
+template <typename Func>
+  requires std::invocable<Func, SIMDJSON_IMPLEMENTATION::ondemand::value>
+#else
+template <typename Func>
+#endif
+inline error_code simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value>::for_each_at_path_with_wildcard(
+      std::string_view json_path, Func&& callback) noexcept {
   if (error()) {
     return error();
   }
-  return first.at_path_with_wildcard(json_path);
+  return first.for_each_at_path_with_wildcard(json_path, std::forward<Func>(callback));
 }
 
 } // namespace simdjson

include/simdjson/generic/ondemand/value.h

@@ -161,6 +161,28 @@ public:
    */
   simdjson_inline simdjson_result<int64_t> get_int64_in_string() noexcept;
 
+  /**
+   * Cast this JSON value to a 32-bit unsigned integer.
+   *
+   * Calls get_uint64() and checks that the result fits in a uint32_t.
+   *
+   * @returns A 32-bit unsigned integer.
+   * @returns INCORRECT_TYPE If the JSON value is not an unsigned integer.
+   * @returns NUMBER_OUT_OF_RANGE If the value does not fit in a uint32_t.
+   */
+  simdjson_inline simdjson_result<uint32_t> get_uint32() noexcept;
+
+  /**
+   * Cast this JSON value to a 32-bit signed integer.
+   *
+   * Calls get_int64() and checks that the result fits in an int32_t.
+   *
+   * @returns A 32-bit signed integer.
+   * @returns INCORRECT_TYPE If the JSON value is not an integer.
+   * @returns NUMBER_OUT_OF_RANGE If the value does not fit in an int32_t.
+   */
+  simdjson_inline simdjson_result<int32_t> get_int32() noexcept;
+
   /**
    * Cast this JSON value to a double.
    *
@@ -676,13 +698,21 @@ public:
   simdjson_inline simdjson_result<value> at_path(std::string_view at_path) noexcept;
 
   /**
-   * Get all values matching the given JSONPath expression with wildcard support.
+   * Call the provided callback for each value matching the given JSONPath
+   * expression with wildcard support.
    * Supports wildcard character (*) for arrays or ".*" for objects.
    *
    * @param json_path JSONPath expression with wildcards
-   * @return Vector of values matching the wildcard pattern
+   * @param callback Function called for each matching value
+   * @return error_code indicating success or failure
    */
-  simdjson_inline simdjson_result<std::vector<value>> at_path_with_wildcard(std::string_view json_path) noexcept;
+#if SIMDJSON_SUPPORTS_CONCEPTS
+  template <typename Func>
+    requires std::invocable<Func, value>
+#else
+  template <typename Func>
+#endif
+  simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept;
 
 protected:
   /**
@@ -746,6 +776,8 @@ public:
   simdjson_inline simdjson_result<uint64_t> get_uint64_in_string() noexcept;
   simdjson_inline simdjson_result<int64_t> get_int64() noexcept;
   simdjson_inline simdjson_result<int64_t> get_int64_in_string() noexcept;
+  simdjson_inline simdjson_result<uint32_t> get_uint32() noexcept;
+  simdjson_inline simdjson_result<int32_t> get_int32() noexcept;
   simdjson_inline simdjson_result<double> get_double() noexcept;
   simdjson_inline simdjson_result<double> get_double_in_string() noexcept;
   simdjson_inline simdjson_result<std::string_view> get_string(bool allow_replacement = false) noexcept;
@@ -873,9 +905,23 @@ public:
   simdjson_inline simdjson_result<int32_t> current_depth() const noexcept;
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> at_pointer(std::string_view json_pointer) noexcept;
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> at_path(std::string_view json_path) noexcept;
-  simdjson_inline simdjson_result<std::vector<SIMDJSON_IMPLEMENTATION::ondemand::value>> at_path_with_wildcard(std::string_view json_path) noexcept;
+#if SIMDJSON_SUPPORTS_CONCEPTS
+  template <typename Func>
+    requires std::invocable<Func, SIMDJSON_IMPLEMENTATION::ondemand::value>
+#else
+  template <typename Func>
+#endif
+  simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept;
 };
 
+// Forward-declare explicit specializations so MSVC /permissive- sees them before
+// any template instantiation that would resolve element.get(val) to the primary.
+template<> simdjson_inline error_code
+simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value>::get<SIMDJSON_IMPLEMENTATION::ondemand::value>(
+    SIMDJSON_IMPLEMENTATION::ondemand::value &out) noexcept;
+template<> simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value>
+simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value>::get<SIMDJSON_IMPLEMENTATION::ondemand::value>() noexcept;
+
 } // namespace simdjson
 
 #endif // SIMDJSON_GENERIC_ONDEMAND_VALUE_H

include/simdjson/generic/ondemand/value_iterator-inl.h

@@ -515,9 +515,13 @@ simdjson_warn_unused simdjson_inline simdjson_result<std::string_view> value_ite
 template <typename string_type>
 simdjson_warn_unused simdjson_inline error_code value_iterator::get_string(string_type& receiver, bool allow_replacement) noexcept {
   std::string_view content;
+  // Save the string buffer location so that we can restore it after get_string
+  auto saved_string_buf_loc = _json_iter->string_buf_loc();
   auto err = get_string(allow_replacement).get(content);
   if (err) { return err; }
   receiver = content;
+  // Restore the string buffer location, effectively discarding any temporary string storage
+  _json_iter->string_buf_loc() = saved_string_buf_loc;
   return SUCCESS;
 }
 simdjson_warn_unused simdjson_inline simdjson_result<std::string_view> value_iterator::get_wobbly_string() noexcept {
@@ -657,9 +661,13 @@ simdjson_warn_unused simdjson_inline simdjson_result<std::string_view> value_ite
 template <typename string_type>
 simdjson_warn_unused simdjson_inline error_code value_iterator::get_root_string(string_type& receiver, bool check_trailing, bool allow_replacement) noexcept {
   std::string_view content;
+  // Save the string buffer location so that we can restore it after get_string
+  auto saved_string_buf_loc = _json_iter->string_buf_loc();
   auto err = get_root_string(check_trailing, allow_replacement).get(content);
   if (err) { return err; }
   receiver = content;
+  // Restore the string buffer location, effectively discarding any temporary string storage
+  _json_iter->string_buf_loc() = saved_string_buf_loc;
   return SUCCESS;
 }
 simdjson_warn_unused simdjson_inline simdjson_result<std::string_view> value_iterator::get_root_wobbly_string(bool check_trailing) noexcept {

include/simdjson/haswell/simd.h

@@ -300,6 +300,7 @@ namespace simd {
     static constexpr int NUM_CHUNKS = 64 / sizeof(simd8<T>);
     static_assert(NUM_CHUNKS == 2, "Haswell kernel should use two registers per 64-byte block.");
     const simd8<T> chunks[NUM_CHUNKS];
+    template<int idx> simd8<uint8_t> get() const { return idx < NUM_CHUNKS ? chunks[idx] : simd8<T>(); }
 
     simd8x64(const simd8x64<T>& o) = delete; // no copy allowed
     simd8x64<T>& operator=(const simd8<T>& other) = delete; // no assignment allowed

include/simdjson/haswell/stringparsing_defs.h

@@ -17,7 +17,6 @@ using namespace simd;
 struct backslash_and_quote {
 public:
   static constexpr uint32_t BYTES_PROCESSED = 32;
-  // We only copy if dst is non-null.
   simdjson_inline backslash_and_quote copy_and_find(const uint8_t *src, uint8_t *dst);
 
   simdjson_inline bool has_quote_first() { return ((bs_bits - 1) & quote_bits) != 0; }
@@ -35,9 +34,7 @@ simdjson_inline backslash_and_quote backslash_and_quote::copy_and_find(const uin
   static_assert(SIMDJSON_PADDING >= (BYTES_PROCESSED - 1), "backslash and quote finder must process fewer than SIMDJSON_PADDING bytes");
   simd8<uint8_t> v(src);
   // store to dest unconditionally - we can overwrite the bits we don't like later
-  if(dst != nullptr) {
-    v.store(dst);
-  }
+  v.store(dst);
   return {
       static_cast<uint32_t>((v == '\\').to_bitmask()),     // bs_bits
       static_cast<uint32_t>((v == '"').to_bitmask()), // quote_bits

include/simdjson/icelake/simd.h

@@ -322,6 +322,7 @@ namespace simd {
     static constexpr int NUM_CHUNKS = 64 / sizeof(simd8<T>);
     static_assert(NUM_CHUNKS == 1, "Icelake kernel should use one register per 64-byte block.");
     const simd8<T> chunks[NUM_CHUNKS];
+    template<int idx> simd8<uint8_t> get() const { return idx < NUM_CHUNKS ? chunks[idx] : simd8<T>(); }
 
     simd8x64(const simd8x64<T>& o) = delete; // no copy allowed
     simd8x64<T>& operator=(const simd8<T>& other) = delete; // no assignment allowed

include/simdjson/icelake/stringparsing_defs.h

@@ -17,7 +17,6 @@ using namespace simd;
 struct backslash_and_quote {
 public:
   static constexpr uint32_t BYTES_PROCESSED = 64;
-  // We only copy if dst is non-null.
   simdjson_inline backslash_and_quote copy_and_find(const uint8_t *src, uint8_t *dst);
 
   simdjson_inline bool has_quote_first() { return ((bs_bits - 1) & quote_bits) != 0; }
@@ -35,9 +34,7 @@ simdjson_inline backslash_and_quote backslash_and_quote::copy_and_find(const uin
   static_assert(SIMDJSON_PADDING >= (BYTES_PROCESSED - 1), "backslash and quote finder must process fewer than SIMDJSON_PADDING bytes");
   simd8<uint8_t> v(src);
   // store to dest unconditionally - we can overwrite the bits we don't like later
-  if(dst != nullptr) {
-    v.store(dst);
-  }
+  v.store(dst);
   return {
       static_cast<uint64_t>(v == '\\'), // bs_bits
       static_cast<uint64_t>(v == '"'), // quote_bits

include/simdjson/implementation_detection.h

@@ -12,6 +12,8 @@
 #define SIMDJSON_IMPLEMENTATION_ID_westmere 6
 #define SIMDJSON_IMPLEMENTATION_ID_lsx 7
 #define SIMDJSON_IMPLEMENTATION_ID_lasx 8
+//#define SIMDJSON_IMPLEMENTATION_ID_rvv 9
+#define SIMDJSON_IMPLEMENTATION_ID_rvv_vls 10
 
 #define SIMDJSON_IMPLEMENTATION_ID_FOR(IMPL) SIMDJSON_CAT(SIMDJSON_IMPLEMENTATION_ID_, IMPL)
 #define SIMDJSON_IMPLEMENTATION_ID SIMDJSON_IMPLEMENTATION_ID_FOR(SIMDJSON_IMPLEMENTATION)
@@ -126,9 +128,14 @@
 #endif
 #define SIMDJSON_CAN_ALWAYS_RUN_LSX (SIMDJSON_IMPLEMENTATION_LSX)
 
+#define SIMDJSON_CAN_ALWAYS_RUN_RVV_VLS SIMDJSON_IS_RVV_VLS
+#ifndef SIMDJSON_IMPLEMENTATION_RVV_VLS
+#define SIMDJSON_IMPLEMENTATION_RVV_VLS SIMDJSON_CAN_ALWAYS_RUN_RVV_VLS
+#endif
+
 // Default Fallback to on unless a builtin implementation has already been selected.
 #ifndef SIMDJSON_IMPLEMENTATION_FALLBACK
-#if SIMDJSON_CAN_ALWAYS_RUN_ARM64 || SIMDJSON_CAN_ALWAYS_RUN_ICELAKE || SIMDJSON_CAN_ALWAYS_RUN_HASWELL || SIMDJSON_CAN_ALWAYS_RUN_WESTMERE || SIMDJSON_CAN_ALWAYS_RUN_PPC64 || SIMDJSON_CAN_ALWAYS_RUN_LSX || SIMDJSON_CAN_ALWAYS_RUN_LASX
+#if SIMDJSON_CAN_ALWAYS_RUN_ARM64 || SIMDJSON_CAN_ALWAYS_RUN_ICELAKE || SIMDJSON_CAN_ALWAYS_RUN_HASWELL || SIMDJSON_CAN_ALWAYS_RUN_WESTMERE || SIMDJSON_CAN_ALWAYS_RUN_PPC64 || SIMDJSON_CAN_ALWAYS_RUN_LSX || SIMDJSON_CAN_ALWAYS_RUN_LASX || SIMDJSON_CAN_ALWAYS_RUN_RVV_VLS
 // if anything at all except fallback can always run, then disable fallback.
 #define SIMDJSON_IMPLEMENTATION_FALLBACK 0
 #else
@@ -154,6 +161,8 @@
 #define SIMDJSON_BUILTIN_IMPLEMENTATION lsx
 #elif SIMDJSON_CAN_ALWAYS_RUN_LASX
 #define SIMDJSON_BUILTIN_IMPLEMENTATION lasx
+#elif SIMDJSON_CAN_ALWAYS_RUN_RVV_VLS
+#define SIMDJSON_BUILTIN_IMPLEMENTATION rvv_vls
 #elif SIMDJSON_CAN_ALWAYS_RUN_FALLBACK
 #define SIMDJSON_BUILTIN_IMPLEMENTATION fallback
 #else

include/simdjson/internal/dom_parser_implementation.h

@@ -4,7 +4,6 @@
 #include "simdjson/base.h"
 #include "simdjson/error.h"
 #include <memory>
-#include <utility>
 
 namespace simdjson {
 
@@ -103,24 +102,6 @@ public:
    */
   simdjson_warn_unused virtual error_code stage2_next(dom::document &doc) noexcept = 0;
 
-  /**
-   * Unescape a valid UTF-8 string from src to dst, stopping at a final unescaped quote. There
-   * must be an unescaped quote terminating the string. It returns the final output
-   * position as pointer. In case of error (e.g., the string has bad escaped codes),
-   * then null_ptr is returned. If no escaping was required, then no copy is made.
-   * It is assumed that the output buffer is large
-   * enough to store the unescapedstring + SIMDJSON_PADDING bytes.
-   *
-   * Overridden by each implementation.
-   *
-   * @param str pointer to the beginning of a valid UTF-8 JSON string, must end with an unescaped quote.
-   * @param dst pointer to a destination buffer, it must point a region in memory of sufficient size.
-   * @param allow_replacement whether we allow a replacement character when the UTF-8 contains unmatched surrogate pairs.
-   * @return end of the of the written region (exclusive) or nullptr in case of error coupled with a Boolean telling you if a copy was made
-   */
-  simdjson_warn_unused virtual std::pair<const uint8_t *,bool> parse_string_if_needed(const uint8_t *src, uint8_t *dst, bool allow_replacement) const noexcept = 0;
-
-
   /**
    * Unescape a valid UTF-8 string from src to dst, stopping at a final unescaped quote. There
    * must be an unescaped quote terminating the string. It returns the final output
@@ -231,6 +212,12 @@ protected:
    */
   size_t _max_depth{0};
 
+public:
+  /** Whether to store big integers as strings instead of returning BIGINT_ERROR */
+  bool _number_as_string{false};
+
+protected:
+
   // Declaring these so that subclasses can use them to implement their constructors.
   simdjson_inline dom_parser_implementation() noexcept;
   simdjson_inline dom_parser_implementation(dom_parser_implementation &&other) noexcept;

include/simdjson/internal/instruction_set.h

@@ -69,6 +69,8 @@ enum instruction_set {
   AVX512VBMI2 = 0x10000,
   LSX = 0x20000,
   LASX = 0x40000,
+  //RVV = 0x80000,
+  RVV_VLS = 0x100000,
 };
 
 } // namespace internal

include/simdjson/internal/tape_type.h

@@ -19,7 +19,8 @@ enum class tape_type {
   DOUBLE = 'd',
   TRUE_VALUE = 't',
   FALSE_VALUE = 'f',
-  NULL_VALUE = 'n'
+  NULL_VALUE = 'n',
+  BIGINT = 'Z'  // Big integer stored as string in string buffer
 }; // enum class tape_type
 
 } // namespace internal

include/simdjson/lasx/simd.h

@@ -303,6 +303,7 @@ namespace simd {
     static constexpr int NUM_CHUNKS = 64 / sizeof(simd8<T>);
     static_assert(NUM_CHUNKS == 2, "LASX kernel should use two registers per 64-byte block.");
     const simd8<T> chunks[NUM_CHUNKS];
+    template<int idx> simd8<uint8_t> get() const { return idx < NUM_CHUNKS ? chunks[idx] : simd8<T>(); }
 
     simd8x64(const simd8x64<T>& o) = delete; // no copy allowed
     simd8x64<T>& operator=(const simd8<T>& other) = delete; // no assignment allowed

include/simdjson/lasx/stringparsing_defs.h

@@ -17,7 +17,6 @@ using namespace simd;
 struct backslash_and_quote {
 public:
   static constexpr uint32_t BYTES_PROCESSED = 32;
-  // We only copy if dst is non-null.
   simdjson_inline backslash_and_quote copy_and_find(const uint8_t *src, uint8_t *dst);
 
   simdjson_inline bool has_quote_first() { return ((bs_bits - 1) & quote_bits) != 0; }
@@ -34,9 +33,7 @@ simdjson_inline backslash_and_quote backslash_and_quote::copy_and_find(const uin
   // SIMDJSON_PADDING of padding
   static_assert(SIMDJSON_PADDING >= (BYTES_PROCESSED - 1), "backslash and quote finder must process fewer than SIMDJSON_PADDING bytes");
   simd8<uint8_t> v(src);
-  if(dst != nullptr) {
-    v.store(dst);
-  }
+  v.store(dst);
   return {
       static_cast<uint32_t>((v == '\\').to_bitmask()),     // bs_bits
       static_cast<uint32_t>((v == '"').to_bitmask()), // quote_bits

include/simdjson/lsx/simd.h

@@ -260,6 +260,7 @@ namespace simd {
     static constexpr int NUM_CHUNKS = 64 / sizeof(simd8<T>);
     static_assert(NUM_CHUNKS == 4, "LSX kernel should use four registers per 64-byte block.");
     const simd8<T> chunks[NUM_CHUNKS];
+    template<int idx> simd8<uint8_t> get() const { return idx < NUM_CHUNKS ? chunks[idx] : simd8<T>(); }
 
     simd8x64(const simd8x64<T>& o) = delete; // no copy allowed
     simd8x64<T>& operator=(const simd8<T>& other) = delete; // no assignment allowed

include/simdjson/lsx/stringparsing_defs.h

@@ -17,7 +17,6 @@ using namespace simd;
 struct backslash_and_quote {
 public:
   static constexpr uint32_t BYTES_PROCESSED = 32;
-  // We only copy if dst is non-null.
   simdjson_inline backslash_and_quote copy_and_find(const uint8_t *src, uint8_t *dst);
 
   simdjson_inline bool has_quote_first() { return ((bs_bits - 1) & quote_bits) != 0; }
@@ -35,10 +34,8 @@ simdjson_inline backslash_and_quote backslash_and_quote::copy_and_find(const uin
   static_assert(SIMDJSON_PADDING >= (BYTES_PROCESSED - 1), "backslash and quote finder must process fewer than SIMDJSON_PADDING bytes");
   simd8<uint8_t> v0(src);
   simd8<uint8_t> v1(src + sizeof(v0));
-  if(dst != nullptr) {
-    v0.store(dst);
-    v1.store(dst + sizeof(v0));
-  }
+  v0.store(dst);
+  v1.store(dst + sizeof(v0));
 
   // Getting a 64-bit bitmask is much cheaper than multiple 16-bit bitmasks on LSX; therefore, we
   // smash them together into a 64-byte mask and get the bitmask from there.

include/simdjson/padded_string-inl.h

@@ -10,6 +10,14 @@
 #include <climits>
 #include <cwchar>
 
+#ifndef _WIN32
+#include <fcntl.h>
+#include <stdio.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#endif
+
 namespace simdjson {
 namespace internal {
 
@@ -160,10 +168,13 @@ inline padded_string::operator padded_string_view() const noexcept simdjson_life
 }
 
 inline simdjson_result<padded_string> padded_string::load(std::string_view filename) noexcept {
+  // std::string_view is not guaranteed to be null-terminated, but std::fopen requires
+  // a null-terminated C string. Construct a temporary std::string to ensure null-termination.
+  const std::string null_terminated_filename(filename);
   // Open the file
   SIMDJSON_PUSH_DISABLE_WARNINGS
   SIMDJSON_DISABLE_DEPRECATED_WARNING // Disable CRT_SECURE warning on MSVC: manually verified this is safe
-  std::FILE *fp = std::fopen(filename.data(), "rb");
+  std::FILE *fp = std::fopen(null_terminated_filename.c_str(), "rb");
   SIMDJSON_POP_DISABLE_WARNINGS
 
   if (fp == nullptr) {
@@ -215,10 +226,13 @@ inline simdjson_result<padded_string> padded_string::load(std::string_view filen
 
 #if defined(_WIN32) && SIMDJSON_CPLUSPLUS17
 inline simdjson_result<padded_string> padded_string::load(std::wstring_view filename) noexcept {
+  // std::wstring_view is not guaranteed to be null-terminated, but _wfopen requires
+  // a null-terminated wide C string. Construct a temporary std::wstring to ensure null-termination.
+  const std::wstring null_terminated_filename(filename);
   // Open the file using the wide characters
   SIMDJSON_PUSH_DISABLE_WARNINGS
   SIMDJSON_DISABLE_DEPRECATED_WARNING // Disable CRT_SECURE warning on MSVC: manually verified this is safe
-  std::FILE *fp = _wfopen(filename.data(), L"rb");
+  std::FILE *fp = _wfopen(null_terminated_filename.c_str(), L"rb");
   SIMDJSON_POP_DISABLE_WARNINGS
 
   if (fp == nullptr) {
@@ -341,6 +355,9 @@ inline padded_string padded_string_builder::convert() noexcept {
 }
 
 inline bool padded_string_builder::reserve(size_t additional) noexcept {
+  if (simdjson_unlikely(additional + size < size)) {
+    return false; // overflow: cannot satisfy request
+  }
   size_t needed = size + additional;
   if (needed <= capacity) {
     return true;
@@ -350,8 +367,9 @@ inline bool padded_string_builder::reserve(size_t additional) noexcept {
   // repeated allocations.
   if (new_capacity < 4096) {
     new_capacity *= 2;
-  } else {
-    new_capacity += new_capacity/2; // grow by 1.5x
+    // overflow guard: ensure new_capacity + new_capacity/2 does not overflow
+  } else if (new_capacity + new_capacity / 2 > new_capacity) {
+    new_capacity += new_capacity / 2; // grow by 1.5x
   }
   char *new_data = internal::allocate_padded_buffer(new_capacity);
   if (new_data == nullptr) {
@@ -366,6 +384,57 @@ inline bool padded_string_builder::reserve(size_t additional) noexcept {
   return true;
 }
 
+
+#ifndef _WIN32
+simdjson_inline padded_memory_map::padded_memory_map(const char *filename) noexcept {
+
+    int fd = open(filename, O_RDONLY);
+    if (fd == -1) {
+      return; // file not found or cannot be opened, data will be nullptr
+    }
+    struct stat st;
+    if (fstat(fd, &st) == -1) {
+      close(fd);
+      return; // failed to get file size, data will be nullptr
+    }
+    size = static_cast<size_t>(st.st_size);
+    size_t total_size = size + simdjson::SIMDJSON_PADDING;
+    void *anon_map =
+        mmap(NULL, total_size, PROT_READ, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+    if (anon_map == MAP_FAILED) {
+      close(fd);
+      return; // failed to create anonymous mapping, data will be nullptr
+    }
+    void *file_map =
+        mmap(anon_map, size, PROT_READ, MAP_SHARED | MAP_FIXED, fd, 0);
+    if (file_map == MAP_FAILED) {
+      munmap(anon_map, total_size);
+      close(fd);
+      return; // failed to mmap file, data will be nullptr
+    }
+    data = static_cast<const char *>(file_map);
+    close(fd); // no longer needed after mapping
+}
+
+simdjson_inline padded_memory_map::~padded_memory_map() noexcept {
+  if (data != nullptr) {
+    munmap(const_cast<char *>(data), size + simdjson::SIMDJSON_PADDING);
+  }
+}
+
+
+simdjson_inline simdjson::padded_string_view padded_memory_map::view() const noexcept simdjson_lifetime_bound {
+  if(!is_valid()) {
+    return simdjson::padded_string_view(); // return an empty view if mapping failed
+  }
+  return simdjson::padded_string_view(data, size, size + simdjson::SIMDJSON_PADDING);
+}
+
+simdjson_inline bool padded_memory_map::is_valid() const noexcept {
+  return data != nullptr;
+}
+#endif // _WIN32
+
 } // namespace simdjson
 
 inline simdjson::padded_string operator ""_padded(const char *str, size_t len) {
@@ -376,4 +445,5 @@ inline simdjson::padded_string operator ""_padded(const char8_t *str, size_t len
   return simdjson::padded_string(reinterpret_cast<const char *>(str), len);
 }
 #endif
+
 #endif // SIMDJSON_PADDED_STRING_INL_H

include/simdjson/padded_string.h

@@ -277,6 +277,62 @@ inline std::ostream& operator<<(std::ostream& out, const padded_string& s) { ret
 inline std::ostream& operator<<(std::ostream& out, simdjson_result<padded_string> &s) noexcept(false) { return out << s.value(); }
 #endif
 
+
+#ifndef _WIN32
+/**
+ * A class representing a memory-mapped file with padding.
+ * It is only available on non-Windows platforms, as Windows has different APIs for memory mapping.
+ */
+class padded_memory_map {
+public:
+  /**
+   * Create a new padded memory map for the given file.
+   * After creating the memory map, you can call view() to get a padded_string_view of the file content.
+   * The memory map will be automatically released when the padded_memory_map instance is destroyed.
+   * Note that the file content is not copied, so this is efficient for large files. However,
+   * the file must remain unchanged while the memory map is in use. In case of error (e.g., file not found,
+   * permission denied, etc.), the memory map will be invalid and view() will return an empty view.
+   * You can check if the memory map is valid by calling is_valid() before using view().
+   *
+   * @param filename the path to the file to memory-map.
+   */
+  simdjson_inline padded_memory_map(const char *filename) noexcept;
+  /**
+   * Destroy the padded memory map and release any resources.
+   */
+  simdjson_inline ~padded_memory_map() noexcept;
+
+  // lifetime of the view is tied to the memory map, so we can return a view
+  // directly
+  /**
+   * Get a view of the memory-mapped file. It always succeeds, but the view may be empty
+   * if the memory map is invalid (e.g., due to file not found, permission denied, etc.).
+   * You can check if the memory map is valid by calling is_valid() before using the view.
+   *
+   * Lifetime of the view is tied to the memory map, so the view should not be used after the
+   * padded_memory_map instance is destroyed.
+   *
+   * @return a padded_string_view representing the memory-mapped file, or an empty view if the memory map is invalid.
+   */
+  simdjson_inline simdjson::padded_string_view view() const noexcept simdjson_lifetime_bound;
+  /**
+   * Check if the memory map is valid.
+   *
+   * @return true if the memory map is valid, false otherwise.
+   */
+  simdjson_inline bool is_valid() const noexcept;
+
+private:
+  padded_memory_map() = delete;
+  padded_memory_map(const padded_memory_map &) = delete;
+  padded_memory_map &operator=(const padded_memory_map &) = delete;
+  const char *data{nullptr};
+  size_t size{0};
+};
+#endif // _WIN32
+
+
+
 } // namespace simdjson
 
 // This is deliberately outside of simdjson so that people get it without having to use the namespace

include/simdjson/padded_string_view.h

@@ -17,7 +17,7 @@ namespace simdjson {
  */
 class padded_string_view : public std::string_view {
 private:
-  size_t _capacity;
+  size_t _capacity{0};
 
 public:
   /** Create an empty padded_string_view. */

include/simdjson/portability.h

@@ -45,22 +45,20 @@ using std::size_t;
 #define SIMDJSON_IS_ARM64 1
 #elif defined(__riscv) && __riscv_xlen == 64
 #define SIMDJSON_IS_RISCV64 1
+
   #if __riscv_v_intrinsic >= 11000
     #define SIMDJSON_HAS_RVV_INTRINSICS 1
   #endif
 
-  #define SIMDJSON_HAS_ZVBB_INTRINSICS                                          \
-    0 // there is currently no way to detect this
-
-  #if SIMDJSON_HAS_RVV_INTRINSICS && __riscv_vector &&                          \
-      __riscv_v_min_vlen >= 128 && __riscv_v_elen >= 64
-    // RISC-V V extension
-    #define SIMDJSON_IS_RVV 1
-    #if SIMDJSON_HAS_ZVBB_INTRINSICS && __riscv_zvbb >= 1000000
-      // RISC-V Vector Basic Bit-manipulation
-      #define SIMDJSON_IS_ZVBB 1
-    #endif
+  #if SIMDJSON_HAS_RVV_INTRINSICS && __riscv_vector && __riscv_v_min_vlen >= 128 && __riscv_v_elen >= 64
+    #define SIMDJSON_IS_RVV 1 // RISC-V V extension
   #endif
+
+  // current toolchains don't support fixed-size SIMD types that don't match VLEN directly
+  #if __riscv_v_fixed_vlen >= 128 && __riscv_v_fixed_vlen <= 512
+    #define SIMDJSON_IS_RVV_VLS 1
+  #endif
+
 #elif defined(__loongarch_lp64)
 #define SIMDJSON_IS_LOONGARCH64 1
 #if defined(__loongarch_sx) && defined(__loongarch_asx)
@@ -68,6 +66,25 @@ using std::size_t;
   #define SIMDJSON_IS_LASX 1 // We can always run both
 #elif defined(__loongarch_sx)
   #define SIMDJSON_IS_LSX 1
+
+// Adjust for runtime dispatching support.
+#if defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER) && !defined(__NVCOMPILER)
+#if __GNUC__ > 15 || (__GNUC__ == 15 && __GNUC_MINOR__ >= 0)
+  // We are ok, we will support runtime dispatch for LASX.
+#else
+  // We disable runtime dispatch for LASX, which means that we will not be able to use LASX
+  // even if it is supported by the hardware.
+  // Loongson users should update to GCC 15 or better.
+  #define SIMDJSON_IMPLEMENTATION_LASX 0
+#endif
+#else
+  // We are not using GCC, so we assume that we can support runtime dispatch for LASX.
+  // https://godbolt.org/z/jcMnrjYhs
+  #define SIMDJSON_IMPLEMENTATION_LASX 0
+#endif
+
+
+
 #endif
 #elif defined(__PPC64__) || defined(_M_PPC64)
 #define SIMDJSON_IS_PPC64 1

include/simdjson/ppc64/simd.h

@@ -397,6 +397,7 @@ template <typename T> struct simd8x64 {
   static_assert(NUM_CHUNKS == 4,
                 "PPC64 kernel should use four registers per 64-byte block.");
   const simd8<T> chunks[NUM_CHUNKS];
+  template<int idx> simd8<uint8_t> get() const { return idx < NUM_CHUNKS ? chunks[idx] : simd8<T>(); }
 
   simd8x64(const simd8x64<T> &o) = delete; // no copy allowed
   simd8x64<T> &

include/simdjson/ppc64/stringparsing_defs.h

@@ -17,7 +17,6 @@ using namespace simd;
 struct backslash_and_quote {
 public:
   static constexpr uint32_t BYTES_PROCESSED = 32;
-  // We only copy if dst is non-null.
   simdjson_inline backslash_and_quote
   copy_and_find(const uint8_t *src, uint8_t *dst);
 
@@ -45,10 +44,8 @@ backslash_and_quote::copy_and_find(const uint8_t *src, uint8_t *dst) {
                 "SIMDJSON_PADDING bytes");
   simd8<uint8_t> v0(src);
   simd8<uint8_t> v1(src + sizeof(v0));
-  if(dst != nullptr) {
-    v0.store(dst);
-    v1.store(dst + sizeof(v0));
-  }
+  v0.store(dst);
+  v1.store(dst + sizeof(v0));
 
   // Getting a 64-bit bitmask is much cheaper than multiple 16-bit bitmasks on
   // PPC; therefore, we smash them together into a 64-byte mask and get the

include/simdjson/rvv-vls.h

@@ -0,0 +1,9 @@
+#ifndef SIMDJSON_RVV_VLS_H
+#define SIMDJSON_RVV_VLS_H
+
+
+#include "simdjson/rvv-vls/begin.h"
+#include "simdjson/generic/amalgamated.h"
+#include "simdjson/rvv-vls/end.h"
+
+#endif // SIMDJSON_RVV_VLS_H

include/simdjson/rvv-vls/base.h

@@ -0,0 +1,19 @@
+#ifndef SIMDJSON_RVV_VLS_BASE_H
+#define SIMDJSON_RVV_VLS_BASE_H
+
+#ifndef SIMDJSON_CONDITIONAL_INCLUDE
+#include "simdjson/base.h"
+#endif // SIMDJSON_CONDITIONAL_INCLUDE
+
+namespace simdjson {
+/**
+ * RVV-VLS implementation.
+ */
+namespace rvv_vls {
+
+class implementation;
+
+} // namespace rvv_vls
+} // namespace simdjson
+
+#endif // SIMDJSON_RVV_VLS_BASE_H

include/simdjson/rvv-vls/begin.h

@@ -0,0 +1,10 @@
+#define SIMDJSON_IMPLEMENTATION rvv_vls
+#include "simdjson/rvv-vls/base.h"
+#include "simdjson/rvv-vls/intrinsics.h"
+#include "simdjson/rvv-vls/bitmanipulation.h"
+#include "simdjson/rvv-vls/bitmask.h"
+#include "simdjson/rvv-vls/simd.h"
+#include "simdjson/rvv-vls/stringparsing_defs.h"
+#include "simdjson/rvv-vls/numberparsing_defs.h"
+
+#define SIMDJSON_SKIP_BACKSLASH_SHORT_CIRCUIT 1

include/simdjson/rvv-vls/bitmanipulation.h

@@ -0,0 +1,48 @@
+#ifndef SIMDJSON_RVV_VLS_BITMANIPULATION_H
+#define SIMDJSON_RVV_VLS_BITMANIPULATION_H
+
+#ifndef SIMDJSON_CONDITIONAL_INCLUDE
+#include "simdjson/rvv-vls/base.h"
+#endif // SIMDJSON_CONDITIONAL_INCLUDE
+
+namespace simdjson {
+namespace rvv_vls {
+namespace {
+
+// We sometimes call trailing_zero on inputs that are zero,
+// but the algorithms do not end up using the returned value.
+// Sadly, sanitizers are not smart enough to figure it out.
+SIMDJSON_NO_SANITIZE_UNDEFINED
+// This function can be used safely even if not all bytes have been
+// initialized.
+// See issue https://github.com/simdjson/simdjson/issues/1965
+SIMDJSON_NO_SANITIZE_MEMORY
+simdjson_inline int trailing_zeroes(uint64_t input_num) {
+  return __builtin_ctzll(input_num);
+}
+
+/* result might be undefined when input_num is zero */
+simdjson_inline uint64_t clear_lowest_bit(uint64_t input_num) {
+  return input_num & (input_num-1);
+}
+
+/* result might be undefined when input_num is zero */
+simdjson_inline int leading_zeroes(uint64_t input_num) {
+  return __builtin_clzll(input_num);
+}
+
+simdjson_inline long long int count_ones(uint64_t input_num) {
+  return __builtin_popcountll(input_num);
+}
+
+simdjson_inline bool add_overflow(uint64_t value1, uint64_t value2,
+                                uint64_t *result) {
+  return __builtin_uaddll_overflow(value1, value2,
+                                   reinterpret_cast<unsigned long long *>(result));
+}
+
+} // unnamed namespace
+} // namespace rvv_vls
+} // namespace simdjson
+
+#endif // SIMDJSON_RVV_VLS_BITMANIPULATION_H

include/simdjson/rvv-vls/bitmask.h

@@ -0,0 +1,39 @@
+#ifndef SIMDJSON_RVV_VLS_BITMASK_H
+#define SIMDJSON_RVV_VLS_BITMASK_H
+
+#ifndef SIMDJSON_CONDITIONAL_INCLUDE
+#include "simdjson/rvv-vls/base.h"
+#include "simdjson/rvv-vls/intrinsics.h"
+#endif // SIMDJSON_CONDITIONAL_INCLUDE
+
+namespace simdjson {
+namespace rvv_vls {
+namespace {
+
+//
+// Perform a "cumulative bitwise xor," flipping bits each time a 1 is encountered.
+//
+// For example, prefix_xor(00100100) == 00011100
+//
+simdjson_inline uint64_t prefix_xor(uint64_t bitmask) {
+#if __riscv_zbc
+  return __riscv_clmul_64(bitmask, ~(uint64_t)0);
+#elif __riscv_zvbc
+  return __riscv_vmv_x(__riscv_vclmul(__riscv_vmv_s_x_u64m1(bitmask, 1), ~(uint64_t)0, 1));
+#else
+  bitmask ^= bitmask << 1;
+  bitmask ^= bitmask << 2;
+  bitmask ^= bitmask << 4;
+  bitmask ^= bitmask << 8;
+  bitmask ^= bitmask << 16;
+  bitmask ^= bitmask << 32;
+#endif
+  return bitmask;
+}
+
+} // unnamed namespace
+} // namespace rvv_vls
+} // namespace simdjson
+
+#endif // SIMDJSON_RVV_VLS_BITMASK_H
+

include/simdjson/rvv-vls/builder.h

@@ -0,0 +1,8 @@
+#ifndef SIMDJSON_RVV_VLS_BUILDER_H
+#define SIMDJSON_RVV_VLS_BUILDER_H
+
+#include "simdjson/rvv-vls/begin.h"
+#include "simdjson/generic/builder/amalgamated.h"
+#include "simdjson/rvv-vls/end.h"
+
+#endif // SIMDJSON_RVV_VLS_BUILDER_H