4.6.0 (#2655)

* 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" \
+        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 -DCMAKE_BUILD_TYPE=Release -B build
+        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DSIMDJSON_DEVELOPER_MODE=ON -B build
-        cmake --build build/ -j$(nproc)
+        cmake --build build/ -j$(nproc) --config Release
     - name: Test VLEN=1024
       run: |
-        export QEMU_LD_PREFIX="/usr/riscv64-linux-gnu"
+        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_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" \
+        CC=clang-17 CXX=clang++-17 CFLAGS="--target=riscv64-linux-gnu -march=rv64gcv" CXXFLAGS="${CFLAGS}" \
-        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DCMAKE_BUILD_TYPE=Release -B build
+        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DSIMDJSON_DEVELOPER_MODE=ON -B build
-        cmake --build build/ -j$(nproc)
+        cmake --build build/ -j$(nproc) --config Release
-    - 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)

.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 \
+        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 -DCMAKE_BUILD_TYPE=Release -B build
+        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DSIMDJSON_DEVELOPER_MODE=ON -B build
-        cmake --build build/ -j$(nproc)
+        cmake --build build/ -j$(nproc) --config Release
     - name: Test VLEN=256
       run: |
-        export QEMU_LD_PREFIX="/usr/riscv64-linux-gnu"
+        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_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.0
     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_VERSION "33.0.0" CACHE STRING "simdjson library version")
-set(SIMDJSON_LIB_SOVERSION "29" CACHE STRING "simdjson library soversion")
+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)
+if(SIMDJSON_INSTALL)
-include(GNUInstallDirs)
+    include(CMakePackageConfigHelpers)
+    include(GNUInstallDirs)
 
-if(SIMDJSON_SINGLEHEADER)
+    if(SIMDJSON_SINGLEHEADER)
-  install(
+      install(
-      FILES singleheader/simdjson.h
+          FILES singleheader/simdjson.h
-      DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
+          DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
-      COMPONENT simdjson_Development
+          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.0"
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a

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)
 
+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);
+  serde_benchmark::set_citm_data(data);
-  size_t output_volume = strlen(output);
+  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]() {
+               bench([&measured_volume, &output_volume]() {
-                 const char * output = serde_benchmark::str_from_citm(data);
+                 measured_volume = serde_benchmark::serialize_citm_to_string();
-                 measured_volume = strlen(output);
-                 if (measured_volume != output_volume) {
-                   printf("mismatch\n");
-                 }
-                 serde_benchmark::free_str(const_cast<char*>(output));
                }));
-  serde_benchmark::free_str(const_cast<char*>(output));
 }
 #endif // SIMDJSON_RUST_VERSION
 
@@ -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()));
+  builder.append(buf.data(), size_t(stream.gcount()));
-  return out;
+  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 {
+// Price structure - field names must match JSON keys for reflection
-  int64_t id;
+struct CITMPrice {
-  std::string name;
+    uint64_t amount;
-  int64_t parent;
+    uint64_t audienceSubCategoryId;
-  std::vector<int64_t> childAreas;
+    uint64_t seatCategoryId;
-  bool operator==(const Area &other) const = default;
+    bool operator==(const CITMPrice&) const = default;
 };
 
-struct AudienceSubCategory {
+struct CITMArea {
-  int64_t id;
+    uint64_t areaId;
-  std::string name;
+    std::vector<uint64_t> blockIds;
-  int64_t parent;
+    bool operator==(const CITMArea&) const = default;
-  bool operator==(const AudienceSubCategory &other) const = default;
 };
 
-struct Event {
+struct CITMSeatCategory {
-  int64_t id;
+    std::vector<CITMArea> areas;
-  std::string name;
+    uint64_t seatCategoryId;
-  std::string description;
+    bool operator==(const CITMSeatCategory&) const = default;
-  int64_t subTopic;
-  int64_t topic;
-  std::vector<int64_t> audience;
-  bool operator==(const Event &other) const = default;
 };
 
-struct Performance {
+struct CITMPerformance {
-  int64_t id;
+    uint64_t id;
-  std::string name;
+    uint64_t eventId;
-  int64_t event;
+    std::optional<std::string> logo;
-  std::string start;
+    std::optional<std::string> name;
-  int64_t venueCode;
+    std::vector<CITMPrice> prices;
-  bool operator==(const Performance &other) const = default;
+    std::vector<CITMSeatCategory> seatCategories;
+    std::optional<std::string> seatMapImage;
+    uint64_t start;
+    std::string venueCode;
+    bool operator==(const CITMPerformance&) const = default;
 };
 
-struct SeatCategory {
+struct CITMEvent {
-  int64_t id;
+    uint64_t id;
-  std::string name;
+    std::string name;
-  std::vector<int64_t> areas;
+    std::optional<std::string> description;
-  bool operator==(const SeatCategory &other) const = default;
+    std::optional<std::string> logo;
-};
+    std::vector<uint64_t> subTopicIds;
-
+    std::optional<std::string> subjectCode;
-struct SubTopic {
+    std::optional<std::string> subtitle;
-  int64_t id;
+    std::vector<uint64_t> topicIds;
-  std::string name;
+    bool operator==(const CITMEvent&) const = default;
-  int64_t parent;
-  bool operator==(const SubTopic &other) const = default;
-};
-
-struct Topic {
-  int64_t id;
-  std::string name;
-  bool operator==(const Topic &other) const = default;
-};
-
-struct Venue {
-  int64_t id;
-  std::string name;
-  int64_t address;
-  bool operator==(const Venue &other) const = default;
 };
 
 struct CitmCatalog {
-  std::map<std::string, Area> areas;
+    std::map<std::string, CITMEvent> events;
-  std::map<std::string, AudienceSubCategory> audienceSubCategory;
+    std::vector<CITMPerformance> performances;
-  std::map<std::string, Event> events;
+    bool operator==(const CitmCatalog&) const = default;
-  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;
 };
 
+// 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 ----
+// ---- CITMPrice ----
-inline void to_json(json &j, const Area &a) {
+inline void to_json(json &j, const CITMPrice &p) {
     j = json{
-      {"id", a.id},
+      {"amount", p.amount},
-      {"name", a.name},
+      {"audienceSubCategoryId", p.audienceSubCategoryId},
-      {"parent", a.parent},
+      {"seatCategoryId", p.seatCategoryId}
-      {"childAreas", a.childAreas}
     };
 }
-inline void from_json(const json &j, Area &a) {
-    j.at("id").get_to(a.id);
-    j.at("name").get_to(a.name);
-    j.at("parent").get_to(a.parent);
-    j.at("childAreas").get_to(a.childAreas);
-}
 
-// ---- AudienceSubCategory ----
+// ---- CITMArea ----
-inline void to_json(json &j, const AudienceSubCategory &asc) {
+inline void to_json(json &j, const CITMArea &a) {
     j = json{
-      {"id", asc.id},
+      {"areaId", a.areaId},
-      {"name", asc.name},
+      {"blockIds", a.blockIds}
-      {"parent", asc.parent}
     };
 }
-inline void from_json(const json &j, AudienceSubCategory &asc) {
-    j.at("id").get_to(asc.id);
-    j.at("name").get_to(asc.name);
-    j.at("parent").get_to(asc.parent);
-}
 
-// ---- Event ----
+// ---- CITMSeatCategory ----
-inline void to_json(json &j, const Event &e) {
+inline void to_json(json &j, const CITMSeatCategory &s) {
     j = json{
-      {"id", e.id},
+      {"areas", s.areas},
-      {"name", e.name},
+      {"seatCategoryId", s.seatCategoryId}
-      {"description", e.description},
-      {"subTopic", e.subTopic},
-      {"topic", e.topic},
-      {"audience", e.audience}
     };
 }
-inline void from_json(const json &j, Event &e) {
-    j.at("id").get_to(e.id);
-    j.at("name").get_to(e.name);
-    j.at("description").get_to(e.description);
-    j.at("subTopic").get_to(e.subTopic);
-    j.at("topic").get_to(e.topic);
-    j.at("audience").get_to(e.audience);
-}
 
-// ---- Performance ----
+// ---- CITMPerformance ----
-inline void to_json(json &j, const Performance &p) {
+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 ----
+// ---- CITMEvent ----
-inline void to_json(json &j, const SeatCategory &sc) {
+inline void to_json(json &j, const CITMEvent &e) {
     j = json{
-      {"id", sc.id},
+      {"id", e.id},
-      {"name", sc.name},
+      {"name", e.name},
-      {"areas", sc.areas}
+      {"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},
+      {"performances", c.performances}
-      {"seatCategory", c.seatCategory},
-      {"subTopic", c.subTopic},
-      {"topic", c.topic},
-      {"venue", c.venue}
     };
 }
-inline void from_json(const json &j, CitmCatalog &c) {
-    j.at("areas").get_to(c.areas);
-    j.at("audienceSubCategory").get_to(c.audienceSubCategory);
-    j.at("events").get_to(c.events);
-    j.at("performances").get_to(c.performances);
-    j.at("seatCategory").get_to(c.seatCategory);
-    j.at("subTopic").get_to(c.subTopic);
-    j.at("topic").get_to(c.topic);
-    j.at("venue").get_to(c.venue);
-}
 
-// Optional convenience functions for benchmarking
+// 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)]
+// Twitter Benchmark Structures
-pub struct Metadata {
+// These match the C++ TwitterData structures exactly
-    result_type: String,
+//==============================================================================
-    iso_language_code: String,
-}
 
 #[derive(Serialize, Deserialize)]
 pub struct User {
-    id: i64,
+    id: u64,
-    id_str: String,
     name: String,
     screen_name: String,
     location: String,
     description: String,
-    // C++ does not have those:
-    // url: Option<String>,
-    //protected: bool,
-    //listed_count: i64,
-    //created_at: String,
-    //favourites_count: i64,
-    //utc_offset: Option<i64>,
-    //time_zone: Option<String>,
-    //geo_enabled: bool,
     verified: bool,
-    followers_count: i64,
+    followers_count: u64,
-    friends_count: i64,
+    friends_count: u64,
-    statuses_count: i64,
+    statuses_count: u64,
-    // C++ does not have those:
-    //lang: String,
-    //profile_background_color: String,
-    //profile_background_image_url: String,
-    //profile_background_image_url_https: String,
-    //profile_background_tile: bool,
-    //profile_image_url: String,
-    //profile_image_url_https: String,
-    //profile_banner_url: Option<String>,
-    //profile_link_color: String,
-    //profile_sidebar_border_color: String,
-    //profile_sidebar_fill_color: String,
-    //profile_text_color: String,
-    //profile_use_background_image: bool,
-    //default_profile: bool,
-    //default_profile_image: bool,
-    //following: bool,
-    //follow_request_sent: bool,
-    //notifications: bool,
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct Hashtag {
-    text: String,
-
-    // C++ has those but D. Lemire does not know what they are, they don't appear in the JSON:
-    // int64_t indices_start;
-    // int64_t indices_end;
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct Url {
-    url: String,
-    expanded_url: String,
-    display_url: String,
-    // C++ has those but D. Lemire does not know what they are, they don't appear in the JSON:
-    // int64_t indices_start;
-    // int64_t indices_end;
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct UserMention {
-    id: i64,
-    name: String,
-    screen_name: String,
-    // Not in the C++ equivalent:
-    //id_str: String,
-    //indices: Vec<i64>,
-    // C++ has those but D. Lemire does not know what they are, they don't appear in the JSON:
-    // int64_t indices_start;
-    // int64_t indices_end;
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct Entities {
-    hashtags: Vec<Hashtag>,
-    urls: Vec<Url>,
-    user_mentions: Vec<UserMention>,
 }
 
 #[derive(Serialize, Deserialize)]
 pub struct Status {
     created_at: String,
-    id: i64,
+    id: u64,
     text: String,
     user: User,
-    entities: Entities,
+    retweet_count: u64,
-    retweet_count: i64,
+    favorite_count: u64,
-    favorite_count: i64,
-    favorited: bool,
-    retweeted: bool,
-    // None of these are in the C++ equivalent:
-    /*
-    metadata: Metadata,
-    id_str: String,
-    source: String,
-    truncated: bool,
-    in_reply_to_status_id: Option<i64>,
-    in_reply_to_status_id_str: Option<String>,
-    in_reply_to_user_id: Option<i64>,
-    in_reply_to_user_id_str: Option<String>,
-    in_reply_to_screen_name: Option<String>,
-    geo: Option<String>,
-    coordinates: Option<String>,
-    place: Option<String>,
-    contributors: Option<String>,
-    lang: String,
-    */
 }
 
 #[derive(Serialize, Deserialize)]
 pub struct TwitterData {
     statuses: Vec<Status>,
 }
+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 {
+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));
+    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) {
+    match serde_json::from_str(&input) {
-    Ok(result) => Box::into_raw(Box::new(result)),
+        Ok(result) => Box::into_raw(Box::new(result)),
-    Err(_) => std::ptr::null_mut(),
+        Err(_) => std::ptr::null_mut(),
-  }
+    }
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn str_from_twitter(raw: *mut TwitterData) -> *const c_char {
+pub unsafe extern "C" fn set_twitter_data(raw: *mut TwitterData) {
-  let twitter_thing = { &*raw };
+    TWITTER_DATA = raw;
-  let serialized = serde_json::to_string(&twitter_thing).unwrap();
-  return std::ffi::CString::new(serialized.as_str()).unwrap().into_raw()
 }
 
+#[no_mangle]
+pub unsafe extern "C" fn 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() {
+    if raw.is_null() {
-    return;
+        return;
-  }
+    }
-
+    drop(Box::from_raw(raw))
-  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)]
+/// Matches C++ CITMPrice struct exactly
-pub struct Area {
+#[derive(Serialize, Deserialize, Debug, Clone)]
-    pub id: i64,
+pub struct CITMPrice {
-    pub name: Option<String>,  // Changed to Option
+    pub amount: u64,
-    pub parent: i64,
+    #[serde(rename = "audienceSubCategoryId")]
-    #[serde(rename = "childAreas")]
+    pub audience_sub_category_id: u64,
-    pub child_areas: Vec<i64>,
+    #[serde(rename = "seatCategoryId")]
+    pub seat_category_id: u64,
 }
 
-#[derive(Serialize, Deserialize)]
+/// Matches C++ CITMArea struct exactly
-pub struct AudienceSubCategory {
+#[derive(Serialize, Deserialize, Debug, Clone)]
-    pub id: i64,
+pub struct CITMArea {
-    pub name: Option<String>,  // Changed to Option
+    #[serde(rename = "areaId")]
-    pub parent: i64,
+    pub area_id: u64,
+    #[serde(rename = "blockIds")]
+    pub block_ids: Vec<u64>,
 }
 
-#[derive(Serialize, Deserialize, Debug)]
+/// Matches C++ CITMSeatCategory struct exactly
-pub struct Event {
+#[derive(Serialize, Deserialize, Debug, Clone)]
-    #[serde(default)]
+pub struct CITMSeatCategory {
-    pub description: Option<String>,
+    pub areas: Vec<CITMArea>,
-    pub id: i64,
+    #[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>,
+    #[serde(rename = "topicIds")]
-    // Add a catch-all for any other fields
+    pub topic_ids: Vec<u64>,
-    #[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)
 }
 
+/// 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 events: HashMap<String, CITMEvent>,
-    pub area_names: HashMap<String, String>,
+    pub performances: Vec<CITMPerformance>,
-
-    #[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>,
 }
 
+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
+    // Parse the full JSON to extract only events and performances
-    match serde_json::from_str::<CitmCatalog>(input_str) {
+    match serde_json::from_str::<serde_json::Value>(input_str) {
-        Ok(catalog) => Box::into_raw(Box::new(catalog)),
+        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 {
+pub unsafe extern "C" fn set_citm_data(raw: *mut CitmCatalog) {
-    if raw_catalog.is_null() {
+    CITM_DATA = raw;
-        eprintln!("Error: Catalog pointer is null");
+}
-        return ptr::null_mut();
-    }
 
-    // Fix: Actually serialize the catalog
+#[no_mangle]
-    let catalog = &*raw_catalog;
+pub unsafe extern "C" fn serialize_citm_to_string() -> usize {
-
+    if CITM_DATA.is_null() {
-    match serde_json::to_string(catalog) {
+        return 0;
-        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()
-        }
     }
+    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).
+void set_citm_data(CitmCatalog *raw);
-char *str_from_citm(CitmCatalog *raw_catalog);
+
+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_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);
+  serde_benchmark::set_twitter_data(data);
-  size_t output_volume = strlen(output);
+  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]() {
+               bench([&measured_volume, &output_volume]() {
-                 const char * output = serde_benchmark::str_from_twitter(data);
+                 measured_volume = serde_benchmark::serialize_twitter_to_string();
-                 serde_benchmark::free_string(output);
                }));
 }
 #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()));
+  builder.append(buf.data(), size_t(stream.gcount()));
-  return out;
+  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.data(), json_str.size());
-    serde_benchmark::TwitterData * td = serde_benchmark::twitter_from_str(json_str.c_str(), json_str.size());
+    if (td == nullptr) {
-    bench_rust(td);
+      printf("# Failed to parse Twitter data for Rust benchmark\n");
-    serde_benchmark::free_twitter(td);
+    } 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},
+                     {"favorite_count", s.favorite_count}};
-                     {"favorited", s.favorited},
-                     {"retweeted", s.retweeted}};
-}
-
-
-std::string nlohmann_serialize(const std::vector<Hashtag>& v) {
-  nlohmann::json a = nlohmann::json::array();
-  for(const Hashtag & h : v) {
-    a.push_back(nlohmann::json{{"text", h.text},
-                     {"indices_start", h.indices_start},
-                     {"indices_end", h.indices_end}});
-  }
-  return a.dump();
-}
-std::string nlohmann_serialize(const std::vector<Url>& v) {
-  nlohmann::json a = nlohmann::json::array();
-  for(const Url & u : v) {
-    a.push_back(nlohmann::json{{"url", u.url},
-                     {"expanded_url", u.expanded_url},
-                     {"display_url", u.display_url},
-                     {"indices_start", u.indices_start},
-                     {"indices_end", u.indices_end}});
-  }
-  return a.dump();
-}
-std::string nlohmann_serialize(const std::vector<UserMention>& v) {
-  nlohmann::json a = nlohmann::json::array();
-  for(const UserMention & um : v) {
-    a.push_back(nlohmann::json{{"id", um.id},
-                     {"name", um.name},
-                     {"screen_name", um.screen_name},
-                     {"indices_start", um.indices_start},
-                     {"indices_end", um.indices_end}});
-  }
-  return a.dump();
-}
-
-std::string nlohmann_serialize(const std::vector<Status>& v) {
-  nlohmann::json a = nlohmann::json::array();
-  for(const Status & s : v) {
-    a.push_back(nlohmann::json{{"created_at", s.created_at},
-                     {"id", s.id},
-                     {"text", s.text},
-                     {"user", s.user},
-                     {"entities", s.entities},
-                     {"retweet_count", s.retweet_count},
-                     {"favorite_count", s.favorite_count},
-                     {"favorited", s.favorited},
-                     {"retweeted", s.retweeted}});
-  }
-  return a.dump();
 }
 
 void to_json(nlohmann::json &j, const TwitterData &t) {
   j = nlohmann::json{{"statuses", t.statuses}};
 }
 
+// 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;
+  uint64_t id;
-  std::string id_str;
   std::string name;
   std::string screen_name;
   std::string location;
   std::string description;
   bool verified;
-  int64_t followers_count;
+  uint64_t followers_count;
-  int64_t friends_count;
+  uint64_t friends_count;
-  int64_t statuses_count;
+  uint64_t statuses_count;
-  bool operator<=>(const User &other) const = default;
-};
-
-struct Hashtag {
-  std::string text;
-  int64_t indices_start;
-  int64_t indices_end;
-  bool operator<=>(const Hashtag &other) const = default;
-};
-
-struct Url {
-  std::string url;
-  std::string expanded_url;
-  std::string display_url;
-  int64_t indices_start;
-  int64_t indices_end;
-  bool operator<=>(const Url &other) const = default;
-};
-
-struct UserMention {
-  int64_t id;
-  std::string name;
-  std::string screen_name;
-  int64_t indices_start;
-  int64_t indices_end;
-  bool operator<=>(const UserMention &other) const = default;
-};
-
-struct Entities {
-  std::vector<Hashtag> hashtags;
-  std::vector<Url> urls;
-  std::vector<UserMention> user_mentions;
-  bool operator==(const Entities &other) const = default;
 };
 
 struct Status {
   std::string created_at;
-  int64_t id;
+  uint64_t id;
   std::string text;
   User user;
-  Entities entities;
+  uint64_t retweet_count;
-  int64_t retweet_count;
+  uint64_t favorite_count;
-  int64_t favorite_count;
-  bool favorited;
-  bool retweeted;
-  bool operator==(const Status &other) const = default;
 };
 
 struct TwitterData {
   std::vector<Status> statuses;
-  bool operator==(const TwitterData &other) const = default;
 };
 
-#endif
+#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

@@ -271,6 +271,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 +389,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 +436,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 +446,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
+  When calling `get_uint64()`, `get_int64()`, `get_uint32()` or `get_int32()`, if the number does not fit in the
-  64-bit integer type, it is also considered an error. When parsing numbers or other scalar values, the library checks
+  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 +488,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

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/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

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

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

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

@@ -132,6 +132,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/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

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
+// Scalar fallback for finding next quotable character
-find_next_json_quotable_character(const std::string_view view,
+SIMDJSON_CONSTEXPR_LAMBDA simdjson_inline size_t
-                                  size_t location) noexcept {
+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/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); }
 
@@ -504,6 +522,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();
@@ -731,6 +757,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 +786,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
@@ -879,6 +919,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();

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.
    *
@@ -829,6 +849,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;
@@ -982,6 +1004,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;
@@ -1069,6 +1093,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;

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

@@ -172,7 +172,7 @@ 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;

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
@@ -401,6 +419,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();

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.
    *
@@ -746,6 +768,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;

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/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/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

@@ -212,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/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/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,10 @@ inline padded_string padded_string_builder::convert() noexcept {
 }
 
 inline bool padded_string_builder::reserve(size_t additional) noexcept {
+  // Guard 1: size + additional must not wrap around.
+  if (simdjson_unlikely(additional > SIZE_MAX - size)) {
+    return false; // overflow: cannot satisfy request
+  }
   size_t needed = size + additional;
   if (needed <= capacity) {
     return true;
@@ -349,9 +367,17 @@ inline bool padded_string_builder::reserve(size_t additional) noexcept {
   // We are going to grow the capacity exponentially to avoid
   // repeated allocations.
   if (new_capacity < 4096) {
+    // Guard 2: doubling must not wrap around.
+    if (simdjson_unlikely(new_capacity > SIZE_MAX / 2)) {
+      return false; // overflow: fall back to exact allocation
+    }
     new_capacity *= 2;
   } else {
-    new_capacity += new_capacity/2; // grow by 1.5x
+    // Guard 3: 1.5x growth must not wrap around.
+    if (simdjson_unlikely(new_capacity > SIZE_MAX - new_capacity / 2)) {
+      return false; // overflow: fall back to exact allocation
+    }
+    new_capacity += new_capacity / 2; // grow by 1.5x
   }
   char *new_data = internal::allocate_padded_buffer(new_capacity);
   if (new_data == nullptr) {
@@ -366,6 +392,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 +453,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                                          \
+  #if SIMDJSON_HAS_RVV_INTRINSICS && __riscv_vector && __riscv_v_min_vlen >= 128 && __riscv_v_elen >= 64
-    0 // there is currently no way to detect this
+    #define SIMDJSON_IS_RVV 1 // RISC-V V extension
-
-  #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
   #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/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

include/simdjson/rvv-vls/end.h

@@ -0,0 +1,5 @@
+#ifndef SIMDJSON_CONDITIONAL_INCLUDE
+#include "simdjson/rvv-vls/base.h"
+#endif // SIMDJSON_CONDITIONAL_INCLUDE
+
+#undef SIMDJSON_IMPLEMENTATION

include/simdjson/rvv-vls/implementation.h

@@ -0,0 +1,34 @@
+#ifndef SIMDJSON_RVV_VLS_IMPLEMENTATION_H
+#define SIMDJSON_RVV_VLS_IMPLEMENTATION_H
+
+#ifndef SIMDJSON_CONDITIONAL_INCLUDE
+#include "simdjson/rvv-vls/base.h"
+#include "simdjson/implementation.h"
+#endif // SIMDJSON_CONDITIONAL_INCLUDE
+
+namespace simdjson {
+namespace rvv_vls {
+
+/**
+ * @private
+ */
+class implementation final : public simdjson::implementation {
+public:
+  simdjson_inline implementation() : simdjson::implementation(
+      "rvv_vls",
+      "RISC-V V extension",
+      0
+  ) {}
+  simdjson_warn_unused error_code create_dom_parser_implementation(
+    size_t capacity,
+    size_t max_length,
+    std::unique_ptr<simdjson::internal::dom_parser_implementation>& dst
+  ) const noexcept final;
+  simdjson_warn_unused error_code minify(const uint8_t *buf, size_t len, uint8_t *dst, size_t &dst_len) const noexcept final;
+  simdjson_warn_unused bool validate_utf8(const char *buf, size_t len) const noexcept final;
+};
+
+} // namespace rvv_vls
+} // namespace simdjson
+
+#endif // SIMDJSON_RVV_VLS_IMPLEMENTATION_H

include/simdjson/rvv-vls/intrinsics.h

@@ -0,0 +1,32 @@
+#ifndef SIMDJSON_RVV_VLS_INTRINSICS_H
+#define SIMDJSON_RVV_VLS_INTRINSICS_H
+
+#ifndef SIMDJSON_CONDITIONAL_INCLUDE
+#include "simdjson/rvv-vls/base.h"
+#endif // SIMDJSON_CONDITIONAL_INCLUDE
+
+#include <riscv_vector.h>
+
+#define simdutf_vrgather_u8m1x2(tbl, idx)                                      \
+  __riscv_vcreate_v_u8m1_u8m2(                                                 \
+      __riscv_vrgather_vv_u8m1(tbl, __riscv_vget_v_u8m2_u8m1(idx, 0),          \
+                               __riscv_vsetvlmax_e8m1()),                      \
+      __riscv_vrgather_vv_u8m1(tbl, __riscv_vget_v_u8m2_u8m1(idx, 1),          \
+                               __riscv_vsetvlmax_e8m1()))
+
+#define simdutf_vrgather_u8m1x4(tbl, idx)                                      \
+  __riscv_vcreate_v_u8m1_u8m4(                                                 \
+      __riscv_vrgather_vv_u8m1(tbl, __riscv_vget_v_u8m4_u8m1(idx, 0),          \
+                               __riscv_vsetvlmax_e8m1()),                      \
+      __riscv_vrgather_vv_u8m1(tbl, __riscv_vget_v_u8m4_u8m1(idx, 1),          \
+                               __riscv_vsetvlmax_e8m1()),                      \
+      __riscv_vrgather_vv_u8m1(tbl, __riscv_vget_v_u8m4_u8m1(idx, 2),          \
+                               __riscv_vsetvlmax_e8m1()),                      \
+      __riscv_vrgather_vv_u8m1(tbl, __riscv_vget_v_u8m4_u8m1(idx, 3),          \
+                               __riscv_vsetvlmax_e8m1()))
+
+#if __riscv_zbc
+#include <riscv_bitmanip.h>
+#endif
+
+#endif // SIMDJSON_RVV_VLS_INTRINSICS_H

include/simdjson/rvv-vls/numberparsing_defs.h

@@ -0,0 +1,56 @@
+#ifndef SIMDJSON_RVV_VLS_NUMBERPARSING_DEFS_H
+#define SIMDJSON_RVV_VLS_NUMBERPARSING_DEFS_H
+
+#ifndef SIMDJSON_CONDITIONAL_INCLUDE
+#include "simdjson/rvv-vls/base.h"
+#include "simdjson/internal/numberparsing_tables.h"
+#endif // SIMDJSON_CONDITIONAL_INCLUDE
+
+#include <cstring>
+
+#ifdef JSON_TEST_NUMBERS // for unit testing
+void found_invalid_number(const uint8_t *buf);
+void found_integer(int64_t result, const uint8_t *buf);
+void found_unsigned_integer(uint64_t result, const uint8_t *buf);
+void found_float(double result, const uint8_t *buf);
+#endif
+
+namespace simdjson {
+namespace rvv_vls {
+namespace numberparsing {
+
+// credit: https://johnnylee-sde.github.io/Fast-numeric-string-to-int/
+/** @private */
+static simdjson_inline uint32_t parse_eight_digits_unrolled(const char *chars) {
+  uint64_t val;
+#if __riscv_misaligned_fast
+  memcpy(&val, chars, sizeof(uint64_t));
+#else
+  val = __riscv_vmv_x(__riscv_vreinterpret_u64m1(__riscv_vlmul_ext_u8m1(__riscv_vle8_v_u8mf2((uint8_t*)chars, 8))));
+#endif
+  val = (val & 0x0F0F0F0F0F0F0F0F) * 2561 >> 8;
+  val = (val & 0x00FF00FF00FF00FF) * 6553601 >> 16;
+  return uint32_t((val & 0x0000FFFF0000FFFF) * 42949672960001 >> 32);
+}
+
+/** @private */
+static simdjson_inline uint32_t parse_eight_digits_unrolled(const uint8_t *chars) {
+  return parse_eight_digits_unrolled(reinterpret_cast<const char *>(chars));
+}
+
+/** @private */
+simdjson_inline internal::value128 full_multiplication(uint64_t value1, uint64_t value2) {
+  internal::value128 answer;
+  __uint128_t r = (static_cast<__uint128_t>(value1)) * value2;
+  answer.low = uint64_t(r);
+  answer.high = uint64_t(r >> 64);
+  return answer;
+}
+
+} // namespace numberparsing
+} // namespace rvv_vls
+} // namespace simdjson
+
+#define SIMDJSON_SWAR_NUMBER_PARSING 1
+
+#endif // SIMDJSON_RVV_VLS_NUMBERPARSING_DEFS_H

include/simdjson/rvv-vls/ondemand.h

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

include/simdjson/rvv-vls/simd.h

@@ -0,0 +1,370 @@
+#ifndef SIMDJSON_RVV_VLS_SIMD_H
+#define SIMDJSON_RVV_VLS_SIMD_H
+
+#ifndef SIMDJSON_CONDITIONAL_INCLUDE
+#include "simdjson/rvv-vls/base.h"
+#include "simdjson/rvv-vls/bitmanipulation.h"
+#include "simdjson/internal/simdprune_tables.h"
+#endif // SIMDJSON_CONDITIONAL_INCLUDE
+
+namespace simdjson {
+namespace rvv_vls {
+namespace {
+namespace simd {
+
+#if __riscv_v_fixed_vlen >= 512
+  static constexpr size_t VL8 = 512/8;
+  using vint8_t   = vint8m1_t   __attribute__((riscv_rvv_vector_bits(512)));
+  using vuint8_t  = vuint8m1_t  __attribute__((riscv_rvv_vector_bits(512)));
+  using vbool_t    = vbool8_t  __attribute__((riscv_rvv_vector_bits(512/8)));
+  using vbitmask_t = uint64_t;
+#else
+  static constexpr size_t VL8 = __riscv_v_fixed_vlen/8;
+  using vint8_t   = vint8m1_t   __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen)));
+  using vuint8_t  = vuint8m1_t  __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen)));
+  using vbool_t    = vbool8_t  __attribute__((riscv_rvv_vector_bits(__riscv_v_fixed_vlen/8)));
+  #if __riscv_v_fixed_vlen == 128
+    using vbitmask_t = uint16_t;
+  #elif __riscv_v_fixed_vlen == 256
+    using vbitmask_t = uint32_t;
+  #endif
+#endif
+
+#if __riscv_v_fixed_vlen == 128
+  using vuint8x64_t = vuint8m4_t __attribute__((riscv_rvv_vector_bits(512)));
+  using vboolx64_t    = vbool2_t  __attribute__((riscv_rvv_vector_bits(512/8)));
+#elif __riscv_v_fixed_vlen == 256
+  using vuint8x64_t = vuint8m2_t __attribute__((riscv_rvv_vector_bits(512)));
+  using vboolx64_t    = vbool4_t  __attribute__((riscv_rvv_vector_bits(512/8)));
+#else
+  using vuint8x64_t = vuint8m1_t __attribute__((riscv_rvv_vector_bits(512)));
+  using vboolx64_t    = vbool8_t  __attribute__((riscv_rvv_vector_bits(512/8)));
+#endif
+
+  template<typename T>
+  struct simd8;
+
+  // SIMD byte mask type (returned by things like eq and gt)
+  template<>
+  struct simd8<bool> {
+    vbool_t value;
+    using bitmask_t = vbitmask_t;
+    static constexpr int SIZE = sizeof(value);
+
+    simdjson_inline simd8(const vbool_t _value) : value(_value) {}
+    simdjson_inline simd8() : simd8(__riscv_vmclr_m_b8(VL8)) {}
+    simdjson_inline simd8(bool _value) : simd8(splat(_value)) {}
+
+    simdjson_inline operator const vbool_t&() const { return value; }
+    simdjson_inline operator vbool_t&() { return value; }
+
+    static simdjson_inline simd8<bool> splat(bool _value) {
+      return __riscv_vreinterpret_b8(__riscv_vmv_v_x_u64m1(((uint64_t)!_value)-1, 1));
+    }
+
+    simdjson_inline vbitmask_t to_bitmask() const {
+#if __riscv_v_fixed_vlen == 128
+      return __riscv_vmv_x(__riscv_vreinterpret_u16m1(value));
+#elif __riscv_v_fixed_vlen == 256
+      return __riscv_vmv_x(__riscv_vreinterpret_u32m1(value));
+#else
+      return __riscv_vmv_x(__riscv_vreinterpret_u64m1(value));
+#endif
+    }
+
+    // Bit operations
+    simdjson_inline simd8<bool> operator|(const simd8<bool> other) const {  return __riscv_vmor(*this, other, VL8); }
+    simdjson_inline simd8<bool> operator&(const simd8<bool> other) const {  return __riscv_vmand(*this, other, VL8); }
+    simdjson_inline simd8<bool> operator^(const simd8<bool> other) const {  return __riscv_vmxor(*this, other, VL8); }
+    simdjson_inline simd8<bool> bit_andnot(const simd8<bool> other) const { return __riscv_vmandn(other, *this, VL8); }
+    simdjson_inline simd8<bool> operator~() const { return __riscv_vmnot(*this, VL8); }
+    simdjson_inline simd8<bool>& operator|=(const simd8<bool> other) { auto this_cast = static_cast<simd8<bool>*>(this); *this_cast = *this_cast | other; return *this_cast; }
+    simdjson_inline simd8<bool>& operator&=(const simd8<bool> other) { auto this_cast = static_cast<simd8<bool>*>(this); *this_cast = *this_cast & other; return *this_cast; }
+    simdjson_inline simd8<bool>& operator^=(const simd8<bool> other) { auto this_cast = static_cast<simd8<bool>*>(this); *this_cast = *this_cast ^ other; return *this_cast; }
+  };
+
+  // Unsigned bytes
+  template<>
+  struct simd8<uint8_t> {
+
+    vuint8_t value;
+    static constexpr int SIZE = sizeof(value);
+
+    simdjson_inline simd8(const vuint8_t _value) : value(_value) {}
+    simdjson_inline simd8() : simd8(zero()) {}
+    simdjson_inline simd8(const uint8_t values[VL8]) : simd8(load(values)) {}
+    simdjson_inline simd8(uint8_t _value) : simd8(splat(_value)) {}
+    simdjson_inline simd8(simd8<bool> mask) : value(__riscv_vmerge_vxm_u8m1(zero(), -1, (vbool_t)mask, VL8)) {}
+
+    simdjson_inline operator const vuint8_t&() const { return this->value; }
+    simdjson_inline operator vuint8_t&() { return this->value; }
+
+    simdjson_inline simd8(
+      uint8_t v0,  uint8_t v1,  uint8_t v2,  uint8_t v3,  uint8_t v4,  uint8_t v5,  uint8_t v6,  uint8_t v7,
+      uint8_t v8,  uint8_t v9,  uint8_t v10, uint8_t v11, uint8_t v12, uint8_t v13, uint8_t v14, uint8_t v15
+    ) : simd8(vuint8_t{
+      v0, v1, v2, v3, v4, v5, v6, v7,
+      v8, v9, v10,v11,v12,v13,v14,v15
+    }) {}
+
+    // Repeat 16 values as many times as necessary (usually for lookup tables)
+    simdjson_inline static simd8<uint8_t> repeat_16(
+      uint8_t v0,  uint8_t v1,  uint8_t v2,  uint8_t v3,  uint8_t v4,  uint8_t v5,  uint8_t v6,  uint8_t v7,
+      uint8_t v8,  uint8_t v9,  uint8_t v10, uint8_t v11, uint8_t v12, uint8_t v13, uint8_t v14, uint8_t v15
+    ) {
+      return simd8<uint8_t>(
+        v0, v1, v2, v3, v4, v5, v6, v7,
+        v8, v9, v10,v11,v12,v13,v14,v15
+      );
+    }
+
+    static simdjson_inline vuint8_t splat(uint8_t _value) { return __riscv_vmv_v_x_u8m1(_value, VL8); }
+    static simdjson_inline vuint8_t zero() { return splat(0); }
+    static simdjson_inline vuint8_t load(const uint8_t values[VL8]) { return __riscv_vle8_v_u8m1(values, VL8); }
+
+    // Bit operations
+    simdjson_inline simd8<uint8_t> operator|(const simd8<uint8_t> other) const { return  __riscv_vor_vv_u8m1(  value, other, VL8); }
+    simdjson_inline simd8<uint8_t> operator&(const simd8<uint8_t> other) const { return  __riscv_vand_vv_u8m1( value, other, VL8); }
+    simdjson_inline simd8<uint8_t> operator^(const simd8<uint8_t> other) const { return  __riscv_vxor_vv_u8m1( value, other, VL8); }
+    simdjson_inline simd8<uint8_t> operator~() const { return __riscv_vnot_v_u8m1(value, VL8); }
+#if __riscv_zvbb
+    simdjson_inline simd8<uint8_t> bit_andnot(const simd8<uint8_t> other) const { return __riscv_vandn_vv_u8m1(other, value, VL8); }
+#else
+    simdjson_inline simd8<uint8_t> bit_andnot(const simd8<uint8_t> other) const { return other & ~*this; }
+#endif
+    simdjson_inline simd8<uint8_t>& operator|=(const simd8<uint8_t> other) { value = *this | other; return *this; }
+    simdjson_inline simd8<uint8_t>& operator&=(const simd8<uint8_t> other) { value = *this & other; return *this; }
+    simdjson_inline simd8<uint8_t>& operator^=(const simd8<uint8_t> other) { value = *this ^ other; return *this; }
+
+    simdjson_inline simd8<bool> operator==(const simd8<uint8_t> other) const { return __riscv_vmseq(value, other, VL8); }
+    simdjson_inline simd8<bool> operator==(uint8_t other) const { return __riscv_vmseq(value, other, VL8); }
+
+    template<int N=1>
+    simdjson_inline simd8<uint8_t> prev(const simd8<uint8_t> prev_chunk) const {
+      return __riscv_vslideup(__riscv_vslidedown(prev_chunk, VL8-N, VL8), value, N, VL8);
+    }
+
+    // Store to array
+    simdjson_inline void store(uint8_t dst[VL8]) const { return __riscv_vse8(dst, value, VL8); }
+
+    // Saturated math
+    simdjson_inline simd8<uint8_t> saturating_add(const simd8<uint8_t> other) const { return __riscv_vsaddu(value, other, VL8); }
+    simdjson_inline simd8<uint8_t> saturating_sub(const simd8<uint8_t> other) const { return __riscv_vssubu(value, other, VL8); }
+
+    // Addition/subtraction are the same for signed and unsigned
+    simdjson_inline simd8<uint8_t> operator+(const simd8<uint8_t> other) const { return __riscv_vadd(value, other, VL8); }
+    simdjson_inline simd8<uint8_t> operator-(const simd8<uint8_t> other) const { return __riscv_vsub(value, other, VL8); }
+    simdjson_inline simd8<uint8_t>& operator+=(const simd8<uint8_t> other) { value = *this + other; return *this; }
+    simdjson_inline simd8<uint8_t>& operator-=(const simd8<uint8_t> other) { value = *this - other; return *this; }
+
+    // Order-specific operations
+    simdjson_inline simd8<bool> operator<=(const simd8<uint8_t> other) const { return __riscv_vmsleu(value, other, VL8); }
+    simdjson_inline simd8<bool> operator>=(const simd8<uint8_t> other) const { return __riscv_vmsgeu(value, other, VL8); }
+    simdjson_inline simd8<bool> operator<(const simd8<uint8_t> other) const  { return __riscv_vmsltu(value, other, VL8); }
+    simdjson_inline simd8<bool> operator>(const simd8<uint8_t> other) const  { return __riscv_vmsgtu(value, other, VL8); }
+
+    // Same as >, but instead of guaranteeing all 1's == true, false = 0 and true = nonzero.
+    simdjson_inline simd8<uint8_t> gt_bits(const simd8<uint8_t> other) const { return simd8<uint8_t>(*this > other); }
+    // Same as <, but instead of guaranteeing all 1's == true, false = 0 and true = nonzero.
+    simdjson_inline simd8<uint8_t> lt_bits(const simd8<uint8_t> other) const { return simd8<uint8_t>(*this < other); }
+
+    // Bit-specific operations
+    simdjson_inline bool any_bits_set_anywhere() const {
+      return __riscv_vfirst(__riscv_vmsne(value, 0, VL8), VL8) >= 0;
+    }
+    simdjson_inline bool any_bits_set_anywhere(simd8<uint8_t> bits) const { return (*this & bits).any_bits_set_anywhere(); }
+    template<int N>
+    simdjson_inline simd8<uint8_t> shr() const { return __riscv_vsrl(value, N, VL8); }
+    template<int N>
+    simdjson_inline simd8<uint8_t> shl() const { return __riscv_vsll(value, N, VL8); }
+
+
+    // Perform a lookup assuming the value is between 0 and 16 (undefined behavior for out of range values)
+    template<typename L>
+    simdjson_inline simd8<L> lookup_16(simd8<L> lookup_table) const {
+      return __riscv_vrgather(lookup_table, value, VL8);
+    }
+
+    // compress inactive elements, to match AVX-512 behavior
+    template<typename L>
+    simdjson_inline void compress(vbitmask_t mask, L * output) const {
+      mask = (vbitmask_t)~mask;
+#if __riscv_v_fixed_vlen == 128
+      vbool8_t m = __riscv_vreinterpret_b8(__riscv_vmv_s_x_u16m1(mask, 1));
+#elif __riscv_v_fixed_vlen == 256
+      vbool8_t m = __riscv_vreinterpret_b8(__riscv_vmv_s_x_u32m1(mask, 1));
+#else
+      vbool8_t m = __riscv_vreinterpret_b8(__riscv_vmv_s_x_u64m1(mask, 1));
+#endif
+      __riscv_vse8_v_u8m1(output, __riscv_vcompress(value, m, VL8), count_ones(mask));
+    }
+
+    template<typename L>
+    simdjson_inline simd8<L> lookup_16(
+        L replace0,  L replace1,  L replace2,  L replace3,
+        L replace4,  L replace5,  L replace6,  L replace7,
+        L replace8,  L replace9,  L replace10, L replace11,
+        L replace12, L replace13, L replace14, L replace15) const {
+      return lookup_16(simd8<L>::repeat_16(
+        replace0,  replace1,  replace2,  replace3,
+        replace4,  replace5,  replace6,  replace7,
+        replace8,  replace9,  replace10, replace11,
+        replace12, replace13, replace14, replace15
+      ));
+    }
+  };
+
+  // Signed bytes
+  template<>
+  struct simd8<int8_t> {
+    vint8_t value;
+    static constexpr int SIZE = sizeof(value);
+
+    simdjson_inline simd8(const vint8_t _value) : value(_value) {}
+    simdjson_inline simd8() : simd8(zero()) {}
+    simdjson_inline simd8(const int8_t values[VL8]) : simd8(load(values)) {}
+    simdjson_inline simd8(int8_t _value) : simd8(splat(_value)) {}
+
+    simdjson_inline operator const vint8_t&() const { return this->value; }
+    simdjson_inline operator vint8_t&() { return this->value; }
+
+    simdjson_inline simd8(
+      int8_t v0,  int8_t v1,  int8_t v2,  int8_t v3,  int8_t v4,  int8_t v5,  int8_t v6,  int8_t v7,
+      int8_t v8,  int8_t v9,  int8_t v10, int8_t v11, int8_t v12, int8_t v13, int8_t v14, int8_t v15
+    ) : simd8(vint8_t{
+      v0, v1, v2, v3, v4, v5, v6, v7,
+      v8, v9, v10,v11,v12,v13,v14,v15
+    }) {}
+
+    // Repeat 16 values as many times as necessary (usually for lookup tables)
+    simdjson_inline static simd8<int8_t> repeat_16(
+      int8_t v0,  int8_t v1,  int8_t v2,  int8_t v3,  int8_t v4,  int8_t v5,  int8_t v6,  int8_t v7,
+      int8_t v8,  int8_t v9,  int8_t v10, int8_t v11, int8_t v12, int8_t v13, int8_t v14, int8_t v15
+    ) {
+      return simd8<int8_t>(
+        v0, v1, v2, v3, v4, v5, v6, v7,
+        v8, v9, v10,v11,v12,v13,v14,v15
+      );
+    }
+
+    static simdjson_inline vint8_t splat(int8_t _value) { return __riscv_vmv_v_x_i8m1(_value, VL8); }
+    static simdjson_inline vint8_t zero() { return splat(0); }
+    static simdjson_inline vint8_t load(const int8_t values[VL8]) { return __riscv_vle8_v_i8m1(values, VL8); }
+
+
+    simdjson_inline void store(int8_t dst[VL8]) const { return __riscv_vse8(dst, value, VL8); }
+
+    // Explicit conversion to/from unsigned
+    simdjson_inline explicit simd8(const vuint8_t other): simd8(__riscv_vreinterpret_i8m1(other)) {}
+    simdjson_inline explicit operator simd8<uint8_t>() const { return __riscv_vreinterpret_u8m1(value); }
+
+    // Math
+    simdjson_inline simd8<int8_t> operator+(const simd8<int8_t> other) const { return __riscv_vadd(value, other, VL8); }
+    simdjson_inline simd8<int8_t> operator-(const simd8<int8_t> other) const { return __riscv_vsub(value, other, VL8); }
+    simdjson_inline simd8<int8_t>& operator+=(const simd8<int8_t> other) { value = *this + other; return *this; }
+    simdjson_inline simd8<int8_t>& operator-=(const simd8<int8_t> other) { value = *this - other; return *this; }
+
+    // Order-sensitive comparisons
+    simdjson_inline simd8<int8_t> max_val( const simd8<int8_t> other) const { return __riscv_vmax( value, other, VL8); }
+    simdjson_inline simd8<int8_t> min_val( const simd8<int8_t> other) const { return __riscv_vmin( value, other, VL8); }
+    simdjson_inline simd8<bool> operator>( const simd8<int8_t> other) const { return __riscv_vmsgt(value, other, VL8); }
+    simdjson_inline simd8<bool> operator<( const simd8<int8_t> other) const { return __riscv_vmslt(value, other, VL8); }
+    simdjson_inline simd8<bool> operator==(const simd8<int8_t> other) const { return __riscv_vmseq(value, other, VL8); }
+
+    template<int N=1>
+    simdjson_inline simd8<int8_t> prev(const simd8<int8_t> prev_chunk) const {
+      return __riscv_vslideup(__riscv_vslidedown(prev_chunk, VL8-N, VL8), value, N, VL8);
+    }
+
+    // Perform a lookup assuming no value is larger than 16
+    template<typename L>
+    simdjson_inline simd8<L> lookup_16(simd8<L> lookup_table) const {
+      return __riscv_vrgather(lookup_table, value, VL8);
+    }
+    template<typename L>
+    simdjson_inline simd8<L> lookup_16(
+        L replace0,  L replace1,  L replace2,  L replace3,
+        L replace4,  L replace5,  L replace6,  L replace7,
+        L replace8,  L replace9,  L replace10, L replace11,
+        L replace12, L replace13, L replace14, L replace15) const {
+      return lookup_16(simd8<L>::repeat_16(
+        replace0,  replace1,  replace2,  replace3,
+        replace4,  replace5,  replace6,  replace7,
+        replace8,  replace9,  replace10, replace11,
+        replace12, replace13, replace14, replace15
+      ));
+    }
+  };
+
+  template<typename T>
+  struct simd8x64;
+  template<>
+  struct simd8x64<uint8_t> {
+    static constexpr int NUM_CHUNKS = 64 / sizeof(simd8<uint8_t>);
+    vuint8x64_t value;
+
+#if __riscv_v_fixed_vlen >= 512
+    template<int idx> simd8<uint8_t> get() const { return value; }
+#else
+    template<int idx> simd8<uint8_t> get() const { return __riscv_vget_u8m1(value, idx); }
+#endif
+
+    simdjson_inline operator const vuint8x64_t&() const { return this->value; }
+    simdjson_inline operator vuint8x64_t&() { return this->value; }
+
+    simd8x64(const simd8x64<uint8_t>& o) = delete; // no copy allowed
+    simd8x64<uint8_t>& operator=(const simd8<uint8_t>& other) = delete; // no assignment allowed
+    simd8x64() = delete; // no default constructor allowed
+
+#if __riscv_v_fixed_vlen == 128
+    simdjson_inline simd8x64(const uint8_t *ptr, size_t n = 64) : value(__riscv_vle8_v_u8m4(ptr, n)) {}
+#elif __riscv_v_fixed_vlen == 256
+    simdjson_inline simd8x64(const uint8_t *ptr, size_t n = 64) : value(__riscv_vle8_v_u8m2(ptr, n)) {}
+#else
+    simdjson_inline simd8x64(const uint8_t *ptr, size_t n = 64) : value(__riscv_vle8_v_u8m1(ptr, n)) {}
+#endif
+
+    simdjson_inline void store(uint8_t ptr[64]) const {
+      __riscv_vse8(ptr, value, 64);
+    }
+
+    simdjson_inline bool is_ascii() const {
+#if __riscv_v_fixed_vlen == 128
+      return __riscv_vfirst(__riscv_vmslt(__riscv_vreinterpret_i8m4(value), 0, 64), 64) < 0;
+#elif __riscv_v_fixed_vlen == 256
+      return __riscv_vfirst(__riscv_vmslt(__riscv_vreinterpret_i8m2(value), 0, 64), 64) < 0;
+#else
+      return __riscv_vfirst(__riscv_vmslt(__riscv_vreinterpret_i8m1(value), 0, 64), 64) < 0;
+#endif
+    }
+
+    // compress inactive elements, to match AVX-512 behavior
+    simdjson_inline uint64_t compress(uint64_t mask, uint8_t * output) const {
+      mask = ~mask;
+#if __riscv_v_fixed_vlen == 128
+      vboolx64_t m = __riscv_vreinterpret_b2(__riscv_vmv_s_x_u64m1(mask, 1));
+#elif __riscv_v_fixed_vlen == 256
+      vboolx64_t m = __riscv_vreinterpret_b4(__riscv_vmv_s_x_u64m1(mask, 1));
+#else
+      vboolx64_t m = __riscv_vreinterpret_b8(__riscv_vmv_s_x_u64m1(mask, 1));
+#endif
+      size_t cnt = count_ones(mask);
+      __riscv_vse8(output, __riscv_vcompress(value, m, 64), cnt);
+      return cnt;
+    }
+
+    simdjson_inline uint64_t eq(const uint8_t m) const {
+      return __riscv_vmv_x(__riscv_vreinterpret_u64m1(__riscv_vmseq(value, m, 64)));
+    }
+
+    simdjson_inline uint64_t lteq(const uint8_t m) const {
+      return __riscv_vmv_x(__riscv_vreinterpret_u64m1(__riscv_vmsleu(value, m, 64)));
+    }
+  }; // struct simd8x64<uint8_t>
+
+} // namespace simd
+} // unnamed namespace
+} // namespace rvv_vls
+} // namespace simdjson
+
+#endif // SIMDJSON_RVV_VLS_SIMD_H

include/simdjson/rvv-vls/stringparsing_defs.h

@@ -0,0 +1,58 @@
+#ifndef SIMDJSON_RVV_VLS_STRINGPARSING_DEFS_H
+#define SIMDJSON_RVV_VLS_STRINGPARSING_DEFS_H
+
+#ifndef SIMDJSON_CONDITIONAL_INCLUDE
+#include "simdjson/rvv-vls/base.h"
+#endif // SIMDJSON_CONDITIONAL_INCLUDE
+
+namespace simdjson {
+namespace rvv_vls {
+namespace {
+
+using namespace simd;
+
+// Holds backslashes and quotes locations.
+struct backslash_and_quote {
+public:
+  static constexpr uint64_t BYTES_PROCESSED = sizeof(simd8<uint8_t>);
+  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; }
+  simdjson_inline bool has_backslash() { return ((quote_bits - 1) & bs_bits) != 0; }
+  simdjson_inline int quote_index() { return trailing_zeroes(quote_bits); }
+  simdjson_inline int backslash_index() { return trailing_zeroes(bs_bits); }
+
+  uint64_t bs_bits;
+  uint64_t quote_bits;
+}; // struct backslash_and_quote
+
+simdjson_inline backslash_and_quote backslash_and_quote::copy_and_find(const uint8_t *src, uint8_t *dst) {
+  static_assert(SIMDJSON_PADDING >= (BYTES_PROCESSED - 1), "backslash and quote finder must process fewer than SIMDJSON_PADDING bytes");
+  simd8<uint8_t> v(src);
+  v.store(dst);
+  return { (v == '\\').to_bitmask(), (v == '"').to_bitmask() };
+}
+
+struct escaping {
+  static constexpr uint64_t BYTES_PROCESSED = sizeof(simd8<uint8_t>);
+  simdjson_inline static escaping copy_and_find(const uint8_t *src, uint8_t *dst);
+
+  simdjson_inline bool has_escape() { return escape_bits != 0; }
+  simdjson_inline int escape_index() { return trailing_zeroes(escape_bits) / 4; }
+
+  uint64_t escape_bits;
+}; // struct escaping
+
+simdjson_inline escaping escaping::copy_and_find(const uint8_t *src, uint8_t *dst) {
+  static_assert(SIMDJSON_PADDING >= (BYTES_PROCESSED - 1), "escaping finder must process fewer than SIMDJSON_PADDING bytes");
+  simd8<uint8_t> v(src);
+  v.store(dst);
+  return { ((v == '"') | (v == '\\') | (v == 32)).to_bitmask() };
+}
+
+
+} // unnamed namespace
+} // namespace rvv_vls
+} // namespace simdjson
+
+#endif // SIMDJSON_RVV_VLS_STRINGPARSING_DEFS_H

include/simdjson/simdjson_version.h

@@ -4,7 +4,7 @@
 #define SIMDJSON_SIMDJSON_VERSION_H
 
 /** The version of simdjson being used (major.minor.revision) */
-#define SIMDJSON_VERSION "4.2.4"
+#define SIMDJSON_VERSION "4.6.0"
 
 namespace simdjson {
 enum {
@@ -15,11 +15,11 @@ enum {
   /**
    * The minor version (major.MINOR.revision) of simdjson being used.
    */
-  SIMDJSON_VERSION_MINOR = 2,
+  SIMDJSON_VERSION_MINOR = 6,
   /**
    * The revision (major.minor.REVISION) of simdjson being used.
    */
-  SIMDJSON_VERSION_REVISION = 4
+  SIMDJSON_VERSION_REVISION = 0
 };
 } // namespace simdjson
 

include/simdjson/westmere/simd.h

@@ -265,6 +265,7 @@ namespace simd {
     static constexpr int NUM_CHUNKS = 64 / sizeof(simd8<T>);
     static_assert(NUM_CHUNKS == 4, "Westmere 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

p2996/README.md

@@ -54,15 +54,15 @@ Importantly, we build the experimental LLVM compiler based on the current state
 ```bash
 CXX=clang++ cmake -B buildreflect -D SIMDJSON_STATIC_REFLECTION=ON -DSIMDJSON_DEVELOPER_MODE=ON
 ```
-This only needs to be done once.
+This only needs to be done once. To build the Rust code, add `-D SIMDJSON_USE_RUST=ON`. Note that you should have Rust on your system as a prerequisite for this option to be meaningful.
 
 5. Build the code...
 ```bash
-cmake --build buildreflect --target benchmark_serialization_citm_catalog benchmark_serialization_twitter
+cmake --build buildreflect --target benchmark_serialization_citm_catalog benchmark_serialization_twitter benchmark_parsing_twitter  benchmark_parsing_citm
 ```
+This is sufficient if you only mean to run the benchmarks (and skip the tests).
 
-
+6. Run the tests... (optional)
-6. Run the tests...
 ```bash
 cmake --build buildreflect
 ctest --test-dir buildreflect --output-on-failure
@@ -71,9 +71,16 @@ ctest --test-dir buildreflect --output-on-failure
 7. Run the benchmarks.
 ```bash
 ./buildreflect/benchmark/static_reflect/citm_catalog_benchmark/benchmark_serialization_citm_catalog
+./buildreflect/benchmark/static_reflect/citm_catalog_benchmark/benchmark_parsing_citm
 ./buildreflect/benchmark/static_reflect/twitter_benchmark/benchmark_serialization_twitter
+./buildreflect/benchmark/static_reflect/twitter_benchmark/benchmark_parsing_twitter
 ```
 
+These benchmarks should print performance counters *if* run in privileged mode (e.g., run under sudo).
+If you run the code inside a docker container, under Linux, it should have access to the performance
+counters if they are enabled on the host. Note that they are usually disabled in a cloud setting
+unless you have so-called metal access.
+
 You can modify the source code with your favorite editor and run again steps 5 (Build the code) and 6 (Run the tests) and 7 (Run the benchmark). Importantly, you should remain in the docker shell.
 
 You can create a new docker shell at any time by running step 3 (bash script).

singleheader/amalgamate.py

@@ -13,6 +13,18 @@ import datetime
 import json
 from typing import Dict, List, Optional, Set, TextIO, Union, cast
 
+# Pre-compile regex patterns for performance
+pragma_once_re = re.compile(r'^#pragma once$')
+ifndef_conditional_re = re.compile(r'^#ifndef\s+SIMDJSON_CONDITIONAL_INCLUDE\s*$')
+endif_conditional_re = re.compile(r'^#endif\s*//\s*SIMDJSON_CONDITIONAL_INCLUDE\s*$')
+include_re = re.compile(r'^#include\s+["<]([^">]*)[">]')
+define_implementation_re = re.compile(r'^#define\s+SIMDJSON_IMPLEMENTATION\s+(.+)$')
+undef_implementation_re = re.compile(r'^#undef\s+SIMDJSON_IMPLEMENTATION\s*$')
+simdjson_implementation_re = re.compile(r'\bSIMDJSON_IMPLEMENTATION\b')
+define_conditional_re = re.compile(r'^#define\s+SIMDJSON_CONDITIONAL_INCLUDE\s*$')
+undef_conditional_re = re.compile(r'^#undef\s+SIMDJSON_CONDITIONAL_INCLUDE\s*$')
+version_re = re.compile(r'\d+\.\d+\.\d+')
+
 # Check for Python 3, this does not actually work.
 if sys.version_info < (3, 0):
     sys.stdout.write("Sorry, requires Python 3.x or better\n")
@@ -108,7 +120,8 @@ else:
 RelativeRoot = str # Literal['src','include'] # Literal not supported in Python 3.7 (CI)
 RELATIVE_ROOTS: List[RelativeRoot] = ['src', 'include' ]
 Implementation = str # Literal['arm64', 'fallback', 'haswell', 'icelake', 'ppc64', 'westmere', 'lsx', 'lasx'] # Literal not supported in Python 3.7 (CI)
-IMPLEMENTATIONS: List[Implementation] = [ 'arm64', 'haswell', 'icelake', 'lasx', 'lsx', 'ppc64', 'westmere', 'fallback' ]
+IMPLEMENTATIONS: List[Implementation] = [ 'arm64', 'haswell', 'icelake', 'lasx', 'lsx', 'ppc64', 'rvv-vls', 'westmere', 'fallback' ]
+implementation_re = re.compile(f'(^|/)({"|".join(IMPLEMENTATIONS)})')
 GENERIC_INCLUDE = "simdjson/generic"
 GENERIC_SRC = "generic"
 BUILTIN = "simdjson/builtin"
@@ -199,7 +212,7 @@ class SimdjsonFile:
 
     @property
     def implementation(self) -> Optional[Implementation]:
-        match = re.search(f'(^|/)({"|".join(IMPLEMENTATIONS)})', self.include_path)
+        match = implementation_re.search(self.include_path)
         if match:
             return cast(Implementation, str(match.group(2)))
 
@@ -417,23 +430,23 @@ class Amalgamator:
                 line = line.rstrip('\n')
 
                 # Ignore #pragma once, it causes warnings if it ends up in a .cpp file
-                if re.search(r'^#pragma once$', line):
+                if pragma_once_re.search(line):
                     continue
 
                 # Ignore lines inside #ifndef SIMDJSON_CONDITIONAL_INCLUDE
-                if re.search(r'^#ifndef\s+SIMDJSON_CONDITIONAL_INCLUDE\s*$', line):
+                if ifndef_conditional_re.search(line):
                     assert file.is_conditional_include, f"Error: File '{file}' uses '#ifndef SIMDJSON_CONDITIONAL_INCLUDE', but it's not an amalgamated file. Conditional includes are only for amalgamated files. {rules}"
                     assert self.in_conditional_include_block, f"Error: File '{file}' uses '#ifndef SIMDJSON_CONDITIONAL_INCLUDE' without a prior '#define SIMDJSON_CONDITIONAL_INCLUDE'. Ensure the define comes first. Stack: {self.include_stack}. {rules}"
                     assert not self.editor_only_region, f"Error: File '{file}' uses '#ifndef SIMDJSON_CONDITIONAL_INCLUDE' twice in a row. Ensure conditional blocks are properly nested and closed. {rules}"
                     self.editor_only_region = True
 
                 # Handle ignored lines (and ending ignore blocks)
-                end_ignore = re.search(r'^#endif\s*//\s*SIMDJSON_CONDITIONAL_INCLUDE\s*$', line)
+                end_ignore = endif_conditional_re.search(line)
                 if self.editor_only_region:
                     self.write(f"/* amalgamation skipped (editor-only): {line} */")
 
                     # Add the editor-only include so we can check dependencies.h for completeness later
-                    included = re.search(r'^#include\s+["<]([^">]*)[">]', line)
+                    included = include_re.search(line)
                     if included:
                         included_file = self.repository[included.group(1)]
                         if included_file:
@@ -445,7 +458,7 @@ class Amalgamator:
                 assert not end_ignore, f"Error: File '{file}' has '#endif // SIMDJSON_CONDITIONAL_INCLUDE' without a matching '#ifndef'. Ensure proper conditional block structure. {rules}"
 
                 # Handle #include lines
-                included = re.search(r'^#include\s+["<]([^">]*)[">]', line)
+                included = include_re.search(line)
                 if included:
                     # we explicitly include simdjson headers, one time each (unless they are generic, in which case multiple times is fine)
                     included_file = self.repository[included.group(1)]
@@ -455,7 +468,7 @@ class Amalgamator:
                         continue
 
                 # Handle defining and replacing SIMDJSON_IMPLEMENTATION
-                defined = re.search(r'^#define\s+SIMDJSON_IMPLEMENTATION\s+(.+)$', line)
+                defined = define_implementation_re.search(line)
                 if defined:
                     old_implementation = self.implementation
                     self.implementation = defined.group(1)
@@ -463,24 +476,24 @@ class Amalgamator:
                         self.write(f'/* defining SIMDJSON_IMPLEMENTATION to "{self.implementation}" */')
                     else:
                         self.write(f'/* redefining SIMDJSON_IMPLEMENTATION from "{old_implementation}" to "{self.implementation}" */')
-                elif re.search(r'^#undef\s+SIMDJSON_IMPLEMENTATION\s*$', line):
+                elif undef_implementation_re.search(line):
                     # Don't include #undef SIMDJSON_IMPLEMENTATION since we're handling it ourselves
                     self.write(f'/* undefining SIMDJSON_IMPLEMENTATION from "{self.implementation}" */')
                     self.implementation = None
-                elif re.search(r'\bSIMDJSON_IMPLEMENTATION\b', line) and file.include_path != IMPLEMENTATION_DETECTION_H:
+                elif self.implementation and file.include_path != IMPLEMENTATION_DETECTION_H:
                     # copy the line, with SIMDJSON_IMPLEMENTATION replace to what it is currently defined to
                     assert self.implementation, f"Error: In '{file}', line '{line}' uses SIMDJSON_IMPLEMENTATION, but it's not defined. Ensure SIMDJSON_IMPLEMENTATION is set before use. {rules}"
-                    line = re.sub(r'\bSIMDJSON_IMPLEMENTATION\b',self.implementation,line)
+                    line = simdjson_implementation_re.sub(self.implementation, line)
 
                 # Handle defining and undefining SIMDJSON_CONDITIONAL_INCLUDE
-                defined = re.search(r'^#define\s+SIMDJSON_CONDITIONAL_INCLUDE\s*$', line)
+                defined = define_conditional_re.search(line)
                 if defined:
                     assert not file.is_conditional_include, f"Error: Amalgamated file '{file}' defines SIMDJSON_CONDITIONAL_INCLUDE, which is not allowed. Only non-amalgamated files can define it. {rules}"
                     assert not self.in_conditional_include_block, f"Error: File '{file}' redefines SIMDJSON_CONDITIONAL_INCLUDE while already in a conditional block. Avoid redefinition. {rules}"
                     self.in_conditional_include_block = True
                     self.found_includes_per_conditional_block.clear()
                     self.write(f'/* defining SIMDJSON_CONDITIONAL_INCLUDE */')
-                elif re.search(r'^#undef\s+SIMDJSON_CONDITIONAL_INCLUDE\s*$', line):
+                elif undef_conditional_re.search(line):
                     assert not file.is_conditional_include, f"Error: Amalgamated file '{file}' undefines SIMDJSON_CONDITIONAL_INCLUDE, which is not allowed. Only non-amalgamated files can undefine it. {rules}"
                     assert self.in_conditional_include_block, f"Error: File '{file}' undefines SIMDJSON_CONDITIONAL_INCLUDE without having defined it first. Ensure proper define/undefine pairing. {rules}"
                     self.write(f'/* undefining SIMDJSON_CONDITIONAL_INCLUDE */')
@@ -554,7 +567,7 @@ def validate_implementations():
 
 def read_version():
     with open(os.path.join(PROJECTPATH, 'include/simdjson/simdjson_version.h')) as f:
-        return re.search(r'\d+\.\d+\.\d+', f.read()).group(0)
+        return version_re.search(f.read()).group(0)
 
 version = read_version()
 if not validate_implementations():