cont : rename common_schema to common_chat_schema

cont : restore (min|max)Length to imply string type
cont : make "{}" mean any object for json_object as well
2026-10-30 16:37:36 -05:00 · 2026-09-12 13:23:12 -05:00 · 2026-09-12 13:23:12 -05:00 · 2026-09-12 13:23:12 -05:00 · 2026-09-12 13:23:12 -05:00 · 2026-09-12 13:23:12 -05:00
778 changed files with 58789 additions and 110936 deletions
@@ -1,4 +1,4 @@
-ARG ONEAPI_VERSION=2026.1.1-devel-ubuntu24.04
+ARG ONEAPI_VERSION=2025.3.3-0-devel-ubuntu24.04
 ARG BUILD_DATE=N/A
 ARG APP_VERSION=N/A
 ARG APP_REVISION=N/A
@@ -19,7 +19,7 @@ RUN npm ci
 COPY tools/ui/ ./
 RUN LLAMA_BUILD_NUMBER="$APP_VERSION" npm run build

-FROM docker.io/intel/oneapi-toolkit:$ONEAPI_VERSION AS build
+FROM docker.io/intel/deep-learning-essentials:$ONEAPI_VERSION AS build

 ARG GGML_SYCL_F16=ON
 ARG LEVEL_ZERO_VERSION=1.28.2
@@ -59,7 +59,7 @@ RUN mkdir -p /app/full \
    && cp requirements.txt /app/full \
    && cp .devops/tools.sh /app/full/tools.sh

-FROM docker.io/intel/oneapi-toolkit:$ONEAPI_VERSION AS base
+FROM docker.io/intel/deep-learning-essentials:$ONEAPI_VERSION AS base

 ARG BUILD_DATE=N/A
 ARG APP_VERSION=N/A
@@ -1,9 +1,10 @@
 ARG UBUNTU_VERSION=22.04
 # This needs to generally match the container host's environment.
+ARG MUSA_VERSION=rc4.3.0
 # Target the MUSA build image
-ARG BASE_MUSA_DEV_CONTAINER=registry.mthreads.com/mcconline/musa_sdk:5.2.0-devel-ubuntu${UBUNTU_VERSION}-s5000
+ARG BASE_MUSA_DEV_CONTAINER=docker.io/mthreads/musa:${MUSA_VERSION}-devel-ubuntu${UBUNTU_VERSION}-amd64

-ARG BASE_MUSA_RUN_CONTAINER=registry.mthreads.com/mcconline/musa_sdk:5.2.0-runtime-ubuntu${UBUNTU_VERSION}-s5000
+ARG BASE_MUSA_RUN_CONTAINER=docker.io/mthreads/musa:${MUSA_VERSION}-runtime-ubuntu${UBUNTU_VERSION}-amd64

 ARG BUILD_DATE=N/A
 ARG APP_VERSION=N/A
@@ -36,10 +37,7 @@ RUN apt-get update && \
    python3-pip \
    git \
    libssl-dev \
-    libgomp1 \
-    musa-mualg-5-2 \
-    musa-muthrust-5-2 \
-    libmthreads-compute
+    libgomp1

 WORKDIR /app

@@ -82,16 +80,13 @@ LABEL org.opencontainers.image.created=$BUILD_DATE \
      org.opencontainers.image.source=$IMAGE_SOURCE

 RUN apt-get update \
-    && apt-get install -y libgomp1 curl ffmpeg libmthreads-compute \
+    && apt-get install -y libgomp1 curl ffmpeg \
    && apt autoremove -y \
    && apt clean -y \
    && rm -rf /tmp/* /var/tmp/* \
    && find /var/cache/apt/archives /var/lib/apt/lists -not -name lock -type f -delete \
    && find /var/cache -type f -delete

-# The MUSA runtime image does not register its library directory
-RUN echo "/usr/local/musa/lib" > /etc/ld.so.conf.d/musa-runtime.conf && ldconfig
-
 COPY --from=build /app/lib/ /app

 ### Full
@@ -1,18 +1,18 @@
-ARG OPENVINO_VERSION_MAJOR=2026.4.1
-ARG OPENVINO_VERSION_FULL=2026.4.1.22982.07f9c262b05
+ARG OPENVINO_VERSION_MAJOR=2026.3.1
+ARG OPENVINO_VERSION_FULL=2026.3.1.22476.56d9685302d
 ARG UBUNTU_VERSION=24.04

 # Intel GPU driver versions. https://github.com/intel/compute-runtime/releases
-ARG IGC_VERSION=v2.41.5
-ARG IGC_VERSION_FULL=2_2.41.5+22716
-ARG COMPUTE_RUNTIME_VERSION=26.35.39758.10
-ARG COMPUTE_RUNTIME_VERSION_FULL=26.35.39758.10-0
+ARG IGC_VERSION=v2.40.13
+ARG IGC_VERSION_FULL=2_2.40.13+22418
+ARG COMPUTE_RUNTIME_VERSION=26.31.39395.13
+ARG COMPUTE_RUNTIME_VERSION_FULL=26.31.39395.13-0
 ARG IGDGMM_VERSION=22.10.0

 # Intel NPU driver versions. https://github.com/intel/linux-npu-driver/releases
-ARG NPU_DRIVER_VERSION=v1.38.0
-ARG NPU_DRIVER_FULL=v1.38.0.20260910-34487311128
-ARG LIBZE1_VERSION=1.32.0-1~24.04~ppa1
+ARG NPU_DRIVER_VERSION=v1.35.0
+ARG NPU_DRIVER_FULL=v1.35.0.20260722-29947505341
+ARG LIBZE1_VERSION=1.28.2-1~24.04~ppa1

 # Optional proxy build arguments
 ARG http_proxy=
@@ -173,7 +173,7 @@ RUN --mount=type=cache,target=/var/cache/intel-npu,sharing=locked \
    fi; \
    DEB=/var/cache/intel-npu/libze1_${LIBZE1_VERSION}_amd64.deb; \
    if [ ! -f "$DEB" ]; then \
-        wget -q -O "$DEB" https://snapshot.ppa.launchpadcontent.net/kobuk-team/intel-graphics/ubuntu/20260830T100000Z/pool/main/l/level-zero-loader/libze1_${LIBZE1_VERSION}_amd64.deb; \
+        wget -q -O "$DEB" https://snapshot.ppa.launchpadcontent.net/kobuk-team/intel-graphics/ubuntu/20260606T100000Z/pool/main/l/level-zero-loader/libze1_${LIBZE1_VERSION}_amd64.deb; \
    fi; \
    mkdir /tmp/npu/ && cd /tmp/npu/ && tar -xf "$TGZ" && cp "$DEB" .; \
    apt-get update; \
@@ -1,5 +1,5 @@
 {
-  "Exclude": ["^\\.gitmodules$", "stb_image\\.h", "examples/test-cmake/build/", "examples/test-cmake/build-subdir/"],
+  "Exclude": ["^\\.gitmodules$", "stb_image\\.h"],
  "Disable": {
    "IndentSize": true
  }
@@ -14,7 +14,7 @@ runs:
      run: |
        BUILD_NUMBER="$(git rev-list --count HEAD)"
        SHORT_HASH="$(git rev-parse --short=7 HEAD)"
-        if [[ "${{ env.BRANCH_NAME }}" == "master" || "${{ env.BRANCH_NAME }}" == "b${BUILD_NUMBER}" ]]; then
+        if [[ "${{ env.BRANCH_NAME }}" == "master" ]]; then
          echo "name=b${BUILD_NUMBER}" >> $GITHUB_OUTPUT
        else
          SAFE_NAME=$(echo "${{ env.BRANCH_NAME }}" | tr '/' '-')
@@ -100,36 +100,36 @@ runs:
          echo "CUDA_PATH=C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.1" | Out-File -FilePath $env:GITHUB_ENV -Append -Encoding utf8
          echo "CUDA_PATH_V13_1=C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.1" | Out-File -FilePath $env:GITHUB_ENV -Append -Encoding utf8

-    - name: Install Cuda Toolkit 13.4 for x64
-      if: ${{ inputs.cuda_version == '13.4' && inputs.cuda_arch == 'x64' }}
+    - name: Install Cuda Toolkit 13.3
+      if: ${{ inputs.cuda_version == '13.3' }}
      shell: pwsh
      run: |
-          mkdir -p "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.4"
+          mkdir -p "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.3"
          choco install unzip -y
-          curl -O "https://developer.download.nvidia.com/compute/cuda/redist/cuda_crt/windows-x86_64/cuda_crt-windows-x86_64-13.4.59-archive.zip"
-          curl -O "https://developer.download.nvidia.com/compute/cuda/redist/cuda_cudart/windows-x86_64/cuda_cudart-windows-x86_64-13.4.49-archive.zip"
-          curl -O "https://developer.download.nvidia.com/compute/cuda/redist/cuda_nvcc/windows-x86_64/cuda_nvcc-windows-x86_64-13.4.59-archive.zip"
-          curl -O "https://developer.download.nvidia.com/compute/cuda/redist/cuda_nvrtc/windows-x86_64/cuda_nvrtc-windows-x86_64-13.4.59-archive.zip"
-          curl -O "https://developer.download.nvidia.com/compute/cuda/redist/libcublas/windows-x86_64/libcublas-windows-x86_64-13.7.0.27-archive.zip"
-          curl -O "https://developer.download.nvidia.com/compute/cuda/redist/libnvvm/windows-x86_64/libnvvm-windows-x86_64-13.4.59-archive.zip"
-          curl -O "https://developer.download.nvidia.com/compute/cuda/redist/cuda_nvtx/windows-x86_64/cuda_nvtx-windows-x86_64-13.4.49-archive.zip"
-          curl -O "https://developer.download.nvidia.com/compute/cuda/redist/cuda_profiler_api/windows-x86_64/cuda_profiler_api-windows-x86_64-13.4.49-archive.zip"
-          curl -O "https://developer.download.nvidia.com/compute/cuda/redist/visual_studio_integration/windows-x86_64/visual_studio_integration-windows-x86_64-13.4.49-archive.zip"
-          curl -O "https://developer.download.nvidia.com/compute/cuda/redist/cccl/windows-x86_64/cccl-windows-x86_64-13.3.4.2.1-archive.zip"
-          unzip '*.zip' -d "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.4"
-          xcopy "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.4\cuda_crt-windows-x86_64-13.4.59-archive\*" "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.4" /E /I /H /Y
-          xcopy "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.4\cuda_cudart-windows-x86_64-13.4.49-archive\*" "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.4" /E /I /H /Y
-          xcopy "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.4\cuda_nvcc-windows-x86_64-13.4.59-archive\*" "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.4" /E /I /H /Y
-          xcopy "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.4\cuda_nvrtc-windows-x86_64-13.4.59-archive\*" "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.4" /E /I /H /Y
-          xcopy "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.4\libcublas-windows-x86_64-13.7.0.27-archive\*" "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.4" /E /I /H /Y
-          xcopy "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.4\libnvvm-windows-x86_64-13.4.59-archive\*" "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.4" /E /I /H /Y
-          xcopy "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.4\cuda_nvtx-windows-x86_64-13.4.49-archive\*" "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.4" /E /I /H /Y
-          xcopy "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.4\cuda_profiler_api-windows-x86_64-13.4.49-archive\*" "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.4" /E /I /H /Y
-          xcopy "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.4\visual_studio_integration-windows-x86_64-13.4.49-archive\*" "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.4" /E /I /H /Y
-          xcopy "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.4\cccl-windows-x86_64-13.3.4.2.1-archive\*" "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.4" /E /I /H /Y
-          echo "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.4\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
-          echo "CUDA_PATH=C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.4" | Out-File -FilePath $env:GITHUB_ENV -Append -Encoding utf8
-          echo "CUDA_PATH_V13_4=C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.4" | Out-File -FilePath $env:GITHUB_ENV -Append -Encoding utf8
+          curl -O "https://developer.download.nvidia.com/compute/cuda/redist/cuda_crt/windows-x86_64/cuda_crt-windows-x86_64-13.3.33-archive.zip"
+          curl -O "https://developer.download.nvidia.com/compute/cuda/redist/cuda_cudart/windows-x86_64/cuda_cudart-windows-x86_64-13.3.29-archive.zip"
+          curl -O "https://developer.download.nvidia.com/compute/cuda/redist/cuda_nvcc/windows-x86_64/cuda_nvcc-windows-x86_64-13.3.33-archive.zip"
+          curl -O "https://developer.download.nvidia.com/compute/cuda/redist/cuda_nvrtc/windows-x86_64/cuda_nvrtc-windows-x86_64-13.3.33-archive.zip"
+          curl -O "https://developer.download.nvidia.com/compute/cuda/redist/libcublas/windows-x86_64/libcublas-windows-x86_64-13.5.1.27-archive.zip"
+          curl -O "https://developer.download.nvidia.com/compute/cuda/redist/libnvvm/windows-x86_64/libnvvm-windows-x86_64-13.3.33-archive.zip"
+          curl -O "https://developer.download.nvidia.com/compute/cuda/redist/cuda_nvtx/windows-x86_64/cuda_nvtx-windows-x86_64-13.3.29-archive.zip"
+          curl -O "https://developer.download.nvidia.com/compute/cuda/redist/cuda_profiler_api/windows-x86_64/cuda_profiler_api-windows-x86_64-13.3.27-archive.zip"
+          curl -O "https://developer.download.nvidia.com/compute/cuda/redist/visual_studio_integration/windows-x86_64/visual_studio_integration-windows-x86_64-13.3.27-archive.zip"
+          curl -O "https://developer.download.nvidia.com/compute/cuda/redist/cccl/windows-x86_64/cccl-windows-x86_64-13.3.3.3.1-archive.zip"
+          unzip '*.zip' -d "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.3"
+          xcopy "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.3\cuda_crt-windows-x86_64-13.3.33-archive\*" "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.3" /E /I /H /Y
+          xcopy "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.3\cuda_cudart-windows-x86_64-13.3.29-archive\*" "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.3" /E /I /H /Y
+          xcopy "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.3\cuda_nvcc-windows-x86_64-13.3.33-archive\*" "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.3" /E /I /H /Y
+          xcopy "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.3\cuda_nvrtc-windows-x86_64-13.3.33-archive\*" "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.3" /E /I /H /Y
+          xcopy "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.3\libcublas-windows-x86_64-13.5.1.27-archive\*" "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.3" /E /I /H /Y
+          xcopy "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.3\libnvvm-windows-x86_64-13.3.33-archive\*" "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.3" /E /I /H /Y
+          xcopy "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.3\cuda_nvtx-windows-x86_64-13.3.29-archive\*" "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.3" /E /I /H /Y
+          xcopy "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.3\cuda_profiler_api-windows-x86_64-13.3.27-archive\*" "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.3" /E /I /H /Y
+          xcopy "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.3\visual_studio_integration-windows-x86_64-13.3.27-archive\*" "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.3" /E /I /H /Y
+          xcopy "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.3\cccl-windows-x86_64-13.3.3.3.1-archive\*" "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.3" /E /I /H /Y
+          echo "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.3\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
+          echo "CUDA_PATH=C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.3" | Out-File -FilePath $env:GITHUB_ENV -Append -Encoding utf8
+          echo "CUDA_PATH_V13_3=C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.3" | Out-File -FilePath $env:GITHUB_ENV -Append -Encoding utf8

    - name: Install Cuda Toolkit 13.4 for ARM64
      if: ${{ inputs.cuda_version == '13.4' && inputs.cuda_arch == 'arm64' }}
@@ -29,7 +29,7 @@ concurrency:

 jobs:
  android-ndk-snapdragon:
-    runs-on: ubuntu-24.04  # previously ubuntu-latest
+    runs-on: ubuntu-latest
    container:
      image: 'ghcr.io/snapdragon-toolchain/arm64-android:v0.7'
    defaults:
@@ -59,7 +59,7 @@ jobs:
          path: pkg-snapdragon/llama.cpp

  linux-iot-snapdragon:
-    runs-on: ubuntu-24.04  # previously ubuntu-latest
+    runs-on: ubuntu-latest
    container:
      image: 'ghcr.io/snapdragon-toolchain/arm64-linux:v0.7'
    defaults:
@@ -33,7 +33,7 @@ env:

 jobs:
  default:
-    runs-on: ubuntu-24.04  # previously ubuntu-latest
+    runs-on: ubuntu-latest

    steps:
      - name: Clone
@@ -49,7 +49,7 @@ jobs:
          distribution: zulu

      - name: Setup Android SDK
-        uses: android-actions/setup-android@be39fa834029ff78f1a44aa3bb0819b8fc2bd8fd # v4.0.4
+        uses: android-actions/setup-android@40fd30fb8d7440372e1316f5d1809ec01dcd3699 # v4.0.1
        with:
          log-accepted-android-sdk-licenses: false

@@ -59,7 +59,7 @@ jobs:
          ./gradlew build --no-daemon

  ndk:
-    runs-on: ubuntu-24.04  # previously ubuntu-latest
+    runs-on: ubuntu-latest
    container:
      image: 'ghcr.io/snapdragon-toolchain/arm64-android:v0.3'
    defaults:
@@ -93,7 +93,7 @@ jobs:
          path: pkg-adb/llama.cpp

  arm64:
-    runs-on: ubuntu-24.04  # previously ubuntu-latest
+    runs-on: ubuntu-latest

    env:
      NDK_VERSION: "29.0.14206865"
@@ -123,7 +123,7 @@ jobs:
          distribution: temurin

      - name: Setup Android SDK
-        uses: android-actions/setup-android@be39fa834029ff78f1a44aa3bb0819b8fc2bd8fd # v4.0.4
+        uses: android-actions/setup-android@40fd30fb8d7440372e1316f5d1809ec01dcd3699 # v4.0.1
        with:
          log-accepted-android-sdk-licenses: false

@@ -33,7 +33,6 @@ concurrency:
 env:
  GGML_NLOOP: 3
  GGML_N_THREADS: 1
-  GGML_SCHED_DEBUG_REALLOC: 1
  LLAMA_ARG_LOG_COLORS: 1
  LLAMA_ARG_LOG_PREFIX: 1
  LLAMA_ARG_LOG_TIMESTAMPS: 1
@@ -99,8 +98,7 @@ jobs:
        id: cmake_test
        run: |
          cd build
-          # ref: https://github.com/ggml-org/llama.cpp/pull/19802#issuecomment-4013704023
-          ctest -L main -E "test-llama-archs|test-save-load-state" --verbose --timeout 900
+          ctest -L main -E "test-llama-archs" --verbose --timeout 900

  macos-latest-x64:
    runs-on: macos-15-intel
@@ -41,8 +41,8 @@ jobs:

    env:
      # Sync versions in build-openvino.yml, build-self-hosted.yml, release.yml, build-cache.yml, .devops/openvino.Dockerfile
-      OPENVINO_VERSION_MAJOR: "2026.4.1"
-      OPENVINO_VERSION_FULL: "2026.4.1.22982.07f9c262b05"
+      OPENVINO_VERSION_MAJOR: "2026.3.1"
+      OPENVINO_VERSION_FULL: "2026.3.1.22476.56d9685302d"

    steps:
      - name: Clone
@@ -69,8 +69,8 @@ jobs:

    env:
      # Sync versions in build.yml, build-self-hosted.yml, release.yml, build-cache.yml, .devops/openvino.Dockerfile
-      OPENVINO_VERSION_MAJOR: "2026.4.1"
-      OPENVINO_VERSION_FULL: "2026.4.1.22982.07f9c262b05"
+      OPENVINO_VERSION_MAJOR: "2026.3.1"
+      OPENVINO_VERSION_FULL: "2026.3.1.22476.56d9685302d"

    steps:
      - name: Clone
@@ -5,7 +5,7 @@ on:

 jobs:
  linux:
-    runs-on: [self-hosted, Linux, CPU]
+    runs-on: [self-hosted, Linux]
    steps:
      - uses: actions/checkout@v6
        with:
@@ -37,7 +37,6 @@ concurrency:
 env:
  GGML_NLOOP: 3
  GGML_N_THREADS: 1
-  GGML_SCHED_DEBUG_REALLOC: 1
  LLAMA_ARG_LOG_COLORS: 1
  LLAMA_ARG_LOG_PREFIX: 1
  LLAMA_ARG_LOG_TIMESTAMPS: 1
@@ -89,7 +88,7 @@ jobs:
        run: |
          export PIP_BREAK_SYSTEM_PACKAGES="1"
          python3 -m pip install --upgrade pip setuptools
-          pip3 install ./gguf-py jinja2==3.1.6
+          pip3 install ./gguf-py

      - name: ccache-buckets-restore
        uses: ./.github/actions/ccache-buckets
@@ -125,7 +124,7 @@ jobs:
        id: cmake_test
        run: |
          cd build
-          ctest -L 'main|python' --verbose --timeout 900
+          ctest -L main --verbose --timeout 900

      - name: Test llama2c conversion
        id: llama2c_test
@@ -68,7 +68,7 @@ jobs:
          hf_bucket: ggml-org/cache

      - name: Build with CMake
-        # TODO: Drop GGML_CUDA_CCCL_VERSION when this job uses CTK >= 13.5, which bundles CCCL >= 3.5.
+        # TODO: Remove GGML_CUDA_CUB_3DOT2 flag once CCCL 3.2 is bundled within CTK and that CTK version is used in this project
        run: |
          cmake -S . -B build -G Ninja \
            -DLLAMA_FATAL_WARNINGS=ON \
@@ -77,7 +77,7 @@ jobs:
            -DCMAKE_EXE_LINKER_FLAGS=-Wl,--allow-shlib-undefined \
            -DGGML_NATIVE=OFF \
            -DGGML_CUDA=ON \
-            -DGGML_CUDA_CCCL_VERSION=v3.4.3
+            -DGGML_CUDA_CUB_3DOT2=ON
          cmake --build build

      - name: ccache-buckets-save
@@ -145,7 +145,7 @@ jobs:

  musa:
    runs-on: ubuntu-22.04
-    container: registry.mthreads.com/mcconline/musa_sdk:5.2.0-devel-ubuntu22.04-s5000
+    container: mthreads/musa:rc4.3.0-devel-ubuntu22.04-amd64

    steps:
      - name: Clone
@@ -156,7 +156,7 @@ jobs:
        id: depends
        run: |
          apt-get update
-          apt-get install -y build-essential git cmake libssl-dev jq python3-venv musa-mualg-5-2 musa-muthrust-5-2 libmthreads-compute
+          apt-get install -y build-essential git cmake libssl-dev jq

      - name: ccache
        uses: ggml-org/ccache-action@v1.2.24
@@ -177,9 +177,8 @@ jobs:
        id: cmake_build
        run: |
          cmake -B build -S . \
-            -DGGML_MUSA=ON \
-            -DMUSA_ARCHITECTURES=31
-          cmake --build build --config Release -j $(nproc)
+            -DGGML_MUSA=ON
+          time cmake --build build --config Release -j $(nproc)

      - name: ccache-buckets-save
        if: ${{ github.event_name == 'push' && github.ref == 'refs/heads/master' }}
@@ -31,16 +31,15 @@ jobs:
    strategy:
      matrix:
        include:
-          # CTK >= 13.5 bundles CCCL >= 3.5; omit GGML_CUDA_CCCL_VERSION for those versions.
          - cuda: '12.4'
            arch: x64
-            defines: '-DGGML_CUDA_CCCL_VERSION=v3.4.3'
-          - cuda: '13.4'
+            defines: '-DGGML_CUDA_CUB_3DOT2=ON'
+          - cuda: '13.3'
            arch: x64
-            defines: '-DGGML_CUDA_CCCL_VERSION=v3.4.3'
+            defines: ''
          - cuda: '13.4'
            arch: arm64
-            defines: '-DGGML_CUDA_CCCL_VERSION=v3.4.3 -DCMAKE_TOOLCHAIN_FILE=cmake/arm64-windows-msvc-cuda.cmake'
+            defines: '-DCMAKE_TOOLCHAIN_FILE=cmake/arm64-windows-msvc-cuda.cmake'

    steps:
      - name: Clone
@@ -19,8 +19,7 @@ on:
    types: [opened, synchronize, reopened]
    paths: [
      '.github/workflows/build-ibm.yml',
-      'ggml/src/ggml-cpu/**',
-      'ggml/src/ggml-zdnn/**'
+      'ggml/src/ggml-cpu/**'
    ]

 concurrency:
@@ -35,14 +34,9 @@ env:
  LLAMA_ARG_LOG_TIMESTAMPS: 1

 jobs:
-  ubuntu-24-s390x:
-    name: ubuntu-24-s390x (VXE ${{ matrix.vxe }})
-    runs-on: ubuntu-24.04-s390x

-    strategy:
-      fail-fast: false
-      matrix:
-        vxe: ["ON", "OFF"]  # `-DGGML_VXE=ON/OFF`
+  ubuntu-24-s390x:
+    runs-on: ubuntu-24.04-s390x

    steps:
      - name: Clone
@@ -83,8 +77,7 @@ jobs:
        run: |
          cmake -B build \
            -DLLAMA_FATAL_WARNINGS=ON \
-            -DGGML_RPC=ON \
-            -DGGML_VXE=${{ matrix.vxe }}
+            -DGGML_RPC=ON
          time cmake --build build --config Release -j $(nproc)

      - name: Test
@@ -101,46 +94,6 @@ jobs:
          wget https://huggingface.co/ggml-org/models/resolve/main/tinyllamas/stories260K-be.gguf
          ./bin/llama-completion -m stories260K-be.gguf -p "One day, Lily met a Shoggoth" -n 500 -c 256

-  ubuntu-26-zdnn-s390x:
-    name: ubuntu-26-zdnn-s390x
-    runs-on: ubuntu-24.04-s390x
-    container: ubuntu:26.04  # required to get GCC 15.1 and binutils 2.44
-    defaults:
-      run:
-        shell: bash
-
-    steps:
-      - name: Build Dependencies
-        id: build_depends
-        run: |
-          apt-get update
-          apt-get install -y --no-install-recommends \
-            build-essential cmake git ca-certificates \
-            libssl-dev libzdnn-dev
-
-      - name: Clone
-        id: checkout
-        uses: actions/checkout@v6
-
-      - name: Toolchain workaround (GCC 15)
-        run: |
-          apt-get install -y gcc-15 g++-15
-          echo "CC=gcc-15" >> "$GITHUB_ENV"
-          echo "CXX=g++-15" >> "$GITHUB_ENV"
-
-      - name: Build with zDNN Backend
-        id: cmake_build
-        run: |
-          cmake -B build \
-            -DLLAMA_FATAL_WARNINGS=ON \
-            -DGGML_NATIVE=OFF \
-            -DGGML_VXE=ON \
-            -DGGML_ZDNN=ON \
-            -DGGML_RPC=ON \
-            -DCMAKE_C_FLAGS="-march=arch15" \
-            -DCMAKE_CXX_FLAGS="-march=arch15"
-          time cmake --build build --config Release -j $(nproc)
-
  ubuntu-24-ppc64le:
    runs-on: ubuntu-24.04-ppc64le

@@ -41,8 +41,8 @@ jobs:

    env:
      # Sync versions in build-openvino.yml, build-self-hosted.yml, release.yml, build-cache.yml, .devops/openvino.Dockerfile
-      OPENVINO_VERSION_MAJOR: "2026.4.1"
-      OPENVINO_VERSION_FULL: "2026.4.1.22982.07f9c262b05"
+      OPENVINO_VERSION_MAJOR: "2026.3.1"
+      OPENVINO_VERSION_FULL: "2026.3.1.22476.56d9685302d"

    steps:
      - name: Clone
@@ -96,8 +96,8 @@ jobs:

    env:
      # Sync versions in build-openvino.yml, build-self-hosted.yml, release.yml, build-cache.yml, .devops/openvino.Dockerfile
-      OPENVINO_VERSION_MAJOR: "2026.4.1"
-      OPENVINO_VERSION_FULL: "2026.4.1.22982.07f9c262b05"
+      OPENVINO_VERSION_MAJOR: "2026.3.1"
+      OPENVINO_VERSION_FULL: "2026.3.1.22476.56d9685302d"

    steps:
      - name: Clone
@@ -0,0 +1,445 @@
+name: CI (self-hosted)
+
+on:
+  workflow_dispatch: # allows manual triggering
+  push:
+    branches:
+      - master
+    paths: [
+      '.github/workflows/build-self-hosted.yml',
+      '**/CMakeLists.txt',
+      '**/.cmake',
+      '**/*.h',
+      '**/*.hpp',
+      '**/*.c',
+      '**/*.cpp',
+      '**/*.cu',
+      '**/*.cuh',
+      '**/*.swift',
+      '**/*.m',
+      '**/*.metal',
+      '**/*.comp',
+      '**/*.glsl',
+      '**/*.wgsl'
+    ]
+
+  pull_request:
+    types: [opened, synchronize, reopened]
+    paths: [
+      '.github/workflows/build-self-hosted.yml',
+      '**/CMakeLists.txt',
+      '**/.cmake',
+      '**/*.h',
+      '**/*.hpp',
+      '**/*.c',
+      '**/*.cpp',
+      '**/*.cu',
+      '**/*.cuh',
+      '**/*.swift',
+      '**/*.m',
+      '**/*.metal',
+      '**/*.comp',
+      '**/*.glsl',
+      '**/*.wgsl'
+    ]
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.head_ref && github.ref || github.run_id }}
+  cancel-in-progress: true
+
+env:
+  # note: this is dud token to avoid rate limiting (https://github.com/ggml-org/llama.cpp/pull/25706#issuecomment-4979941302)
+  HF_TOKEN: ${{ secrets.HF_TOKEN_CI }}
+  GGML_NLOOP: 3
+  GGML_N_THREADS: 1
+  LLAMA_ARG_LOG_COLORS: 1
+  LLAMA_ARG_LOG_PREFIX: 1
+  LLAMA_ARG_LOG_TIMESTAMPS: 1
+
+jobs:
+  gpu-cuda:
+    runs-on: "hf-jobs-t4-small:cuda13"
+
+    steps:
+      - name: Clone
+        id: checkout
+        uses: actions/checkout@v6
+
+      - name: Install dependencies
+        run: |
+          sudo apt update
+          sudo apt install -y cmake libssl-dev time unzip wget python3 python3-venv python3-pip
+
+      - name: ccache
+        uses: ggml-org/ccache-action@v1.2.24
+        with:
+          restore: false
+          save: false
+
+      - name: ccache-buckets-restore
+        uses: ./.github/actions/ccache-buckets
+        with:
+          key: self-hosted-gpu-cuda
+          folder: llama.cpp
+          hf_bucket: ggml-org/cache
+
+      - name: Test
+        id: ggml-ci
+        run: |
+          nvidia-smi
+          GG_BUILD_CUDA=1 CUDACXX=/usr/local/cuda/bin/nvcc bash ./ci/run.sh ~/results/llama.cpp ~/mnt/llama.cpp
+
+      - name: ccache-buckets-save
+        if: ${{ github.event_name == 'push' && github.ref == 'refs/heads/master' }}
+        uses: ./.github/actions/ccache-buckets
+        env:
+          HF_TOKEN: ${{ secrets.HF_TOKEN_CACHE_OUTPUT }}
+        with:
+          key: self-hosted-gpu-cuda
+          folder: llama.cpp
+          evict-old-files: 1d
+          hf_bucket: ggml-org/cache
+          save: true
+
+  gpu-rocm:
+    runs-on: [self-hosted, Linux, AMD]
+
+    steps:
+      - name: Clone
+        id: checkout
+        uses: actions/checkout@v6
+
+      - name: Test
+        id: ggml-ci
+        # HIP_LAUNCH_BLOCKING=1: workaround for an async-execution correctness
+        # issue on integrated RDNA3.5 (gfx1151) where batched inference returns
+        # incorrect output (perplexity ~88 vs ~9.4). Serializing kernel launches
+        # restores correctness. Remove once the underlying ROCm/HIP issue is fixed.
+        env:
+          HIP_LAUNCH_BLOCKING: "1"
+        run: |
+          rocminfo
+          GG_BUILD_ROCM=1 GG_BUILD_AMDGPU_TARGETS=gfx1151 bash ./ci/run.sh ~/results/llama.cpp ~/mnt/llama.cpp
+
+  gpu-vulkan-nvidia-cm:
+    runs-on: [self-hosted, Linux, NVIDIA]
+
+    steps:
+      - name: Clone
+        id: checkout
+        uses: actions/checkout@v6
+
+      - name: Test
+        id: ggml-ci
+        run: |
+          vulkaninfo --summary
+          GG_BUILD_VULKAN=1 GGML_VK_DISABLE_COOPMAT2=1 bash ./ci/run.sh ~/results/llama.cpp ~/mnt/llama.cpp
+
+  gpu-vulkan-nvidia-cm2:
+    runs-on: [self-hosted, Linux, NVIDIA, COOPMAT2]
+
+    steps:
+      - name: Clone
+        id: checkout
+        uses: actions/checkout@v6
+
+      - name: Test
+        id: ggml-ci
+        run: |
+          vulkaninfo --summary
+          GG_BUILD_VULKAN=1 bash ./ci/run.sh ~/results/llama.cpp ~/mnt/llama.cpp
+
+  gpu-webgpu-nvidia:
+    runs-on: [self-hosted, Linux, NVIDIA, X64]
+
+    steps:
+      - name: Clone
+        id: checkout
+        uses: actions/checkout@v6
+
+      - name: Dawn Dependency
+        id: dawn-depends
+        run: |
+          DAWN_VERSION="v20260908.214631"
+          DAWN_OWNER="google"
+          DAWN_REPO="dawn"
+          DAWN_ASSET_NAME="Dawn-94c3c9cc0d5fb2e85aebb370fa8d37b71aa34655-ubuntu-latest-Release"
+          echo "Fetching release asset from https://github.com/google/dawn/releases/download/${DAWN_VERSION}/${DAWN_ASSET_NAME}.tar.gz"
+          curl -L -o artifact.tar.gz \
+            "https://github.com/google/dawn/releases/download/${DAWN_VERSION}/${DAWN_ASSET_NAME}.tar.gz"
+          mkdir dawn
+          tar -xvf artifact.tar.gz -C dawn --strip-components=1
+
+      - name: Test
+        id: ggml-ci
+        run: |
+          GG_BUILD_WEBGPU=1 \
+          GG_BUILD_WEBGPU_DAWN_PREFIX="$GITHUB_WORKSPACE/dawn" \
+          GG_BUILD_WEBGPU_DAWN_DIR="$GITHUB_WORKSPACE/dawn/lib64/cmake/Dawn" \
+            bash ./ci/run.sh ~/results/llama.cpp ~/mnt/llama.cpp
+
+  # TODO: provision AMX-compatible machine
+  #cpu-amx:
+  #  runs-on: [self-hosted, Linux, CPU, AMX]
+
+  #  steps:
+  #    - name: Clone
+  #      id: checkout
+  #      uses: actions/checkout@v6
+
+  #    - name: Test
+  #      id: ggml-ci
+  #      run: |
+  #        bash ./ci/run.sh ~/results/llama.cpp ~/mnt/llama.cpp
+
+  # TODO: provision AMD GPU machine
+  # amd-vulkan:
+  #   runs-on: [self-hosted, Linux, AMD]
+
+  #   steps:
+  #     - name: Clone
+  #       id: checkout
+  #       uses: actions/checkout@v6
+
+  #     - name: Test
+  #       id: ggml-ci
+  #       run: |
+  #         vulkaninfo --summary
+  #         GG_BUILD_VULKAN=1 bash ./ci/run.sh ~/results/llama.cpp ~/mnt/llama.cpp
+
+  # TODO: provision AMD GPU machine
+  # amd-rocm:
+  #   runs-on: [self-hosted, Linux, AMD]
+
+  #   steps:
+  #     - name: Clone
+  #       id: checkout
+  #       uses: actions/checkout@v6
+
+  #     - name: Test
+  #       id: ggml-ci
+  #       run: |
+  #         amd-smi static
+  #         GG_BUILD_ROCM=1 GG_BUILD_AMDGPU_TARGETS="gfx1101" bash ./ci/run.sh ~/results/llama.cpp ~/mnt/llama.cpp
+
+  gpu-metal:
+    runs-on: [self-hosted, macOS, ARM64]
+
+    steps:
+      - name: Clone
+        id: checkout
+        uses: actions/checkout@v6
+
+      - name: Test
+        id: ggml-ci
+        run: |
+          GG_BUILD_METAL=1 bash ./ci/run.sh ~/results/llama.cpp ~/mnt/llama.cpp
+
+  gpu-webgpu-apple:
+    runs-on: [self-hosted, macOS, ARM64]
+
+    steps:
+      - name: Clone
+        id: checkout
+        uses: actions/checkout@v6
+
+      - name: Dawn Dependency
+        id: dawn-depends
+        run: |
+          DAWN_VERSION="v20260908.214631"
+          DAWN_OWNER="google"
+          DAWN_REPO="dawn"
+          DAWN_ASSET_NAME="Dawn-94c3c9cc0d5fb2e85aebb370fa8d37b71aa34655-macos-latest-Release"
+          echo "Fetching release asset from https://github.com/google/dawn/releases/download/${DAWN_VERSION}/${DAWN_ASSET_NAME}.tar.gz"
+          curl -L -o artifact.tar.gz \
+            "https://github.com/google/dawn/releases/download/${DAWN_VERSION}/${DAWN_ASSET_NAME}.tar.gz"
+          mkdir dawn
+          tar -xvf artifact.tar.gz -C dawn --strip-components=1
+
+      - name: Test
+        id: ggml-ci
+        run: |
+          GG_BUILD_WEBGPU=1 GG_BUILD_WEBGPU_DAWN_PREFIX="$GITHUB_WORKSPACE/dawn" \
+            bash ./ci/run.sh ~/results/llama.cpp ~/mnt/llama.cpp
+
+  gpu-vulkan-apple:
+    runs-on: [self-hosted, macOS, ARM64]
+
+    steps:
+      - name: Clone
+        id: checkout
+        uses: actions/checkout@v6
+
+      - name: Test
+        id: ggml-ci
+        run: |
+          vulkaninfo --summary
+          GG_BUILD_VULKAN=1 bash ./ci/run.sh ~/results/llama.cpp ~/mnt/llama.cpp
+
+  gpu-vulkan-intel-linux:
+    runs-on: [self-hosted, Linux, Intel]
+
+    steps:
+      - name: Clone
+        id: checkout
+        uses: actions/checkout@v6
+        with:
+          persist-credentials: false
+
+      - name: Test
+        id: ggml-ci
+        run: |
+          vulkaninfo --summary
+          GG_BUILD_VULKAN=1 bash ./ci/run.sh ~/results/llama.cpp ~/mnt/llama.cpp
+
+  gpu-vulkan-intel-windows:
+    runs-on: [self-hosted, Windows, X64, Intel]
+
+    steps:
+      - name: Clone
+        id: checkout
+        uses: actions/checkout@v6
+
+      - name: Test
+        id: ggml-ci
+        shell: C:\msys64\usr\bin\bash.exe --noprofile --norc -eo pipefail "{0}"
+        env:
+          MSYSTEM: UCRT64
+          CHERE_INVOKING: 1
+          PATH: C:\msys64\ucrt64\bin;C:\msys64\usr\bin;C:\Windows\System32;${{ env.PATH }}
+        run: |
+          vulkaninfo --summary
+          # Skip python related tests with GG_BUILD_LOW_PERF=1 since Windows MSYS2 UCRT64 currently fails to create
+          # a valid python environment for testing
+          LLAMA_FATAL_WARNINGS=OFF GG_BUILD_NINJA=1 GG_BUILD_VULKAN=1 GG_BUILD_LOW_PERF=1 ./ci/run.sh ./results/llama.cpp ./mnt/llama.cpp
+
+  gpu-openvino-low-perf:
+    runs-on: [self-hosted, Linux, Intel, OpenVINO]
+
+    env:
+      # Sync versions in build.yml, build-self-hosted.yml, release.yml, build-cache.yml, .devops/openvino.Dockerfile
+      OPENVINO_VERSION_MAJOR: "2026.3.1"
+      OPENVINO_VERSION_FULL: "2026.3.1.22476.56d9685302d"
+
+    steps:
+      - name: Clone
+        id: checkout
+        uses: actions/checkout@v6
+
+      - name: Setup OpenVINO Toolkit
+        uses: ./.github/actions/linux-setup-openvino
+        with:
+          path: ./openvino_toolkit
+          version_major: ${{ env.OPENVINO_VERSION_MAJOR }}
+          version_full: ${{ env.OPENVINO_VERSION_FULL }}
+
+      - name: Install OpenVINO dependencies
+        run: |
+          cd ./openvino_toolkit
+          chmod +x ./install_dependencies/install_openvino_dependencies.sh
+          echo "Y" | sudo -E ./install_dependencies/install_openvino_dependencies.sh
+
+      - name: Test
+        id: ggml-ci
+        run: |
+          source ./openvino_toolkit/setupvars.sh
+          GG_BUILD_OPENVINO=1 GGML_OPENVINO_DEVICE=GPU GG_BUILD_LOW_PERF=1 bash ./ci/run.sh ~/results/llama.cpp ~/mnt/llama.cpp
+
+  cpu-x64-high-perf:
+    runs-on: [self-hosted, Linux, X64]
+
+    steps:
+      - name: Clone
+        id: checkout
+        uses: actions/checkout@v6
+
+      - name: Test
+        id: ggml-ci
+        run: |
+          LLAMA_ARG_THREADS=$(nproc) GG_BUILD_HIGH_PERF=1 GG_BUILD_EXTRA_TESTS_0=1 bash ./ci/run.sh ~/results/llama.cpp ~/mnt/llama.cpp
+
+  cpu-arm64-high-perf-graviton4:
+    runs-on: ah-ubuntu_22_04-c8g_8x
+
+    steps:
+      - name: Clone
+        id: checkout
+        uses: actions/checkout@v6
+
+      - name: Dependencies
+        id: depends
+        run: |
+          set -euxo pipefail
+          sudo apt-get update
+          sudo DEBIAN_FRONTEND=noninteractive NEEDRESTART_MODE=a \
+          apt-get install -y \
+          build-essential \
+          python3-venv \
+          gpg \
+          wget \
+          time \
+          git-lfs
+
+          git lfs install
+
+          # install the latest cmake
+          sudo install -d /usr/share/keyrings
+          wget -O - https://apt.kitware.com/keys/kitware-archive-latest.asc \
+            | gpg --dearmor \
+            | sudo tee /usr/share/keyrings/kitware-archive-keyring.gpg >/dev/null
+          echo 'deb [signed-by=/usr/share/keyrings/kitware-archive-keyring.gpg] https://apt.kitware.com/ubuntu/ jammy main' \
+            | sudo tee /etc/apt/sources.list.d/kitware.list
+          sudo apt-get update
+          sudo apt-get install -y cmake
+
+      - name: Test
+        id: ggml-ci
+        run: |
+          LLAMA_ARG_THREADS=$(nproc) \
+          GG_BUILD_HIGH_PERF=1 \
+          GG_BUILD_NO_BF16=1 \
+          GG_BUILD_EXTRA_TESTS_0=1 \
+          bash ./ci/run.sh ~/results/llama.cpp ~/mnt/llama.cpp
+
+  cpu-arm64-graviton4-kleidiai:
+    runs-on: ah-ubuntu_22_04-c8g_8x
+
+    steps:
+      - name: Clone
+        id: checkout
+        uses: actions/checkout@v6
+
+      - name: Dependencies
+        id: depends
+        run: |
+          set -euxo pipefail
+          sudo apt-get update
+          sudo DEBIAN_FRONTEND=noninteractive NEEDRESTART_MODE=a \
+          apt-get install -y \
+          build-essential \
+          python3-venv \
+          gpg \
+          wget \
+          time \
+          git-lfs
+
+          git lfs install
+
+          # install the latest cmake
+          sudo install -d /usr/share/keyrings
+          wget -O - https://apt.kitware.com/keys/kitware-archive-latest.asc \
+            | gpg --dearmor \
+            | sudo tee /usr/share/keyrings/kitware-archive-keyring.gpg >/dev/null
+          echo 'deb [signed-by=/usr/share/keyrings/kitware-archive-keyring.gpg] https://apt.kitware.com/ubuntu/ jammy main' \
+            | sudo tee /etc/apt/sources.list.d/kitware.list
+          sudo apt-get update
+          sudo apt-get install -y cmake
+
+      - name: Test
+        id: ggml-ci
+        run: |
+          LLAMA_ARG_THREADS=$(nproc) \
+          GG_BUILD_KLEIDIAI=1 \
+          GG_BUILD_EXTRA_TESTS_0=1 \
+          GG_BUILD_HIGH_PERF=1 \
+          bash ./ci/run.sh ~/results/llama.cpp ~/mnt/llama.cpp
@@ -48,8 +48,8 @@ jobs:

    env:
      ONEAPI_ROOT: /opt/intel/oneapi/
-      ONEAPI_INSTALLER_VERSION: "2026.1"
-      LEVEL_ZERO_VERSION: "1.33.1"
+      ONEAPI_INSTALLER_VERSION: "2025.3.3"
+      LEVEL_ZERO_VERSION: "1.28.2"
      LEVEL_ZERO_UBUNTU_VERSION: "u24.04"

    continue-on-error: true
@@ -63,17 +63,16 @@ jobs:
        shell: bash
        run: |
          cd /tmp
-          wget https://registrationcenter-download.intel.com/akdlm/IRC_NAS/5996e26b-f48a-42b1-8db0-b002ad0bd8d7/intel-oneapi-toolkit-2026.1.1.33_offline.sh -O intel-oneapi-toolkit_offline.sh
-          sudo bash intel-oneapi-toolkit_offline.sh -s -a --silent --eula accept
+          wget https://registrationcenter-download.intel.com/akdlm/IRC_NAS/56f7923a-adb8-43f3-8b02-2b60fcac8cab/intel-deep-learning-essentials-2025.3.3.16_offline.sh -O intel-deep-learning-essentials_offline.sh
+          sudo bash intel-deep-learning-essentials_offline.sh -s -a --silent --eula accept

      - name: Install Level Zero SDK
        shell: bash
        run: |
          cd /tmp
-          # v1.33.x renamed the Debian packages to libze1 / libze-dev
-          wget -q "https://github.com/oneapi-src/level-zero/releases/download/v${LEVEL_ZERO_VERSION}/libze1_${LEVEL_ZERO_VERSION}%2B${LEVEL_ZERO_UBUNTU_VERSION}_amd64.deb" -O libze1.deb
-          wget -q "https://github.com/oneapi-src/level-zero/releases/download/v${LEVEL_ZERO_VERSION}/libze-dev_${LEVEL_ZERO_VERSION}%2B${LEVEL_ZERO_UBUNTU_VERSION}_amd64.deb" -O libze-dev.deb
-          sudo apt-get install -y ./libze1.deb ./libze-dev.deb
+          wget -q "https://github.com/oneapi-src/level-zero/releases/download/v${LEVEL_ZERO_VERSION}/level-zero_${LEVEL_ZERO_VERSION}%2B${LEVEL_ZERO_UBUNTU_VERSION}_amd64.deb" -O level-zero.deb
+          wget -q "https://github.com/oneapi-src/level-zero/releases/download/v${LEVEL_ZERO_VERSION}/level-zero-devel_${LEVEL_ZERO_VERSION}%2B${LEVEL_ZERO_UBUNTU_VERSION}_amd64.deb" -O level-zero-devel.deb
+          sudo apt-get install -y ./level-zero.deb ./level-zero-devel.deb

      - name: ccache
        uses: ggml-org/ccache-action@v1.2.24
@@ -102,11 +101,7 @@ jobs:
            -DCMAKE_CXX_COMPILER=icpx \
            -DLLAMA_OPENSSL=OFF \
            -DGGML_NATIVE=OFF \
-            -DGGML_SYCL_F16=${{ matrix.fp16 }} \
-            -DGGML_SYCL_SUPPORT_LEVEL_ZERO_API=ON \
-            -DGGML_SYCL_DNN=ON \
-            -DCMAKE_CXX_FLAGS="-fsycl-unnamed-lambda" \
-            -DCMAKE_EXE_LINKER_FLAGS="-fsycl-unnamed-lambda"
+            -DGGML_SYCL_F16=${{ matrix.fp16 }}
          time cmake --build build --config Release -j $(nproc)

      - name: ccache-buckets-save
@@ -129,11 +124,11 @@ jobs:
        shell: bash

    env:
-      WINDOWS_BASEKIT_URL: https://registrationcenter-download.intel.com/akdlm/IRC_NAS/0cb67a0d-67f6-410b-868b-f4a0a17ff0cf/intel-oneapi-toolkit-2026.1.1.32_offline.exe
+      WINDOWS_BASEKIT_URL: https://registrationcenter-download.intel.com/akdlm/IRC_NAS/b60765d1-2b85-4e85-86b6-cb0e9563a699/intel-deep-learning-essentials-2025.3.3.18_offline.exe
      WINDOWS_DPCPP_MKL: intel.oneapi.win.cpp-dpcpp-common:intel.oneapi.win.mkl.devel:intel.oneapi.win.dnnl:intel.oneapi.win.tbb.devel
-      LEVEL_ZERO_SDK_URL: https://github.com/oneapi-src/level-zero/releases/download/v1.33.1/level-zero-win-sdk-1.33.1.zip
+      LEVEL_ZERO_SDK_URL: https://github.com/oneapi-src/level-zero/releases/download/v1.28.2/level-zero-win-sdk-1.28.2.zip
      ONEAPI_ROOT: "C:/Program Files (x86)/Intel/oneAPI"
-      ONEAPI_INSTALLER_VERSION: "2026.1"
+      ONEAPI_INSTALLER_VERSION: "2025.3.3"
    steps:
      - name: Clone
        id: checkout
@@ -31,7 +31,6 @@ concurrency:
 env:
  GGML_NLOOP: 3
  GGML_N_THREADS: 1
-  GGML_SCHED_DEBUG_REALLOC: 1
  LLAMA_ARG_LOG_COLORS: 1
  LLAMA_ARG_LOG_PREFIX: 1
  LLAMA_ARG_LOG_TIMESTAMPS: 1
@@ -19,7 +19,7 @@ on:

 jobs:
  check-vendor:
-    runs-on: ubuntu-slim
+    runs-on: [self-hosted, fast]

    steps:
      - name: Checkout
@@ -1,112 +0,0 @@
-name: CI (self-hosted CPU backend)
-
-on:
-  workflow_dispatch: # allows manual triggering
-  push:
-    branches:
-      - master
-    paths: [
-      '.github/workflows/ci-self-hosted-cpu.yml',
-      'ci/run.sh',
-      '**/CMakeLists.txt',
-      '**/.cmake',
-      '**/*.h',
-      '**/*.hpp',
-      '**/*.c',
-      '**/*.cpp'
-    ]
-
-  pull_request:
-    types: [opened, synchronize, reopened]
-    paths: [
-      '.github/workflows/ci-self-hosted-cpu.yml',
-      'ci/run.sh',
-      '**/CMakeLists.txt',
-      '**/.cmake',
-      'ggml/src/*',
-      'ggml/src/ggml-cpu/**'
-    ]
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.head_ref && github.ref || github.run_id }}
-  cancel-in-progress: true
-
-env:
-  # note: this is dud token to avoid rate limiting (https://github.com/ggml-org/llama.cpp/pull/25706#issuecomment-4979941302)
-  HF_TOKEN: ${{ secrets.HF_TOKEN_CI }}
-  GGML_NLOOP: 3
-  GGML_N_THREADS: 1
-  LLAMA_ARG_LOG_COLORS: 1
-  LLAMA_ARG_LOG_PREFIX: 1
-  LLAMA_ARG_LOG_TIMESTAMPS: 1
-
-jobs:
-  cpu-x64-high-perf:
-    runs-on: [self-hosted, Linux, X64]
-
-    steps:
-      - name: Clone
-        id: checkout
-        uses: actions/checkout@v6
-
-      - name: Test
-        id: ggml-ci
-        run: |
-          LLAMA_ARG_THREADS=$(nproc) GG_BUILD_HIGH_PERF=1 GG_BUILD_EXTRA_TESTS_0=1 bash ./ci/run.sh ~/results/llama.cpp ~/mnt/llama.cpp
-
-  cpu-arm64-high-perf-graviton4:
-    runs-on: ah-ubuntu_24_04-c8g_8x
-
-    steps:
-      - name: Clone
-        id: checkout
-        uses: actions/checkout@v6
-
-      - name: Dependencies
-        id: depends
-        run: |
-          set -euxo pipefail
-          sudo apt-get update
-          sudo DEBIAN_FRONTEND=noninteractive NEEDRESTART_MODE=a \
-          apt-get install -y \
-          build-essential \
-          python3-venv \
-          gpg \
-          wget \
-          time \
-          git-lfs
-
-          git lfs install
-
-          # install the latest cmake
-          sudo install -d /usr/share/keyrings
-          wget -O - https://apt.kitware.com/keys/kitware-archive-latest.asc \
-            | gpg --dearmor \
-            | sudo tee /usr/share/keyrings/kitware-archive-keyring.gpg >/dev/null
-          echo 'deb [signed-by=/usr/share/keyrings/kitware-archive-keyring.gpg] https://apt.kitware.com/ubuntu/ jammy main' \
-            | sudo tee /etc/apt/sources.list.d/kitware.list
-          sudo apt-get update
-          sudo apt-get install -y cmake
-
-      - name: Test
-        id: ggml-ci
-        run: |
-          LLAMA_ARG_THREADS=$(nproc) \
-          GG_BUILD_HIGH_PERF=1 \
-          GG_BUILD_NO_BF16=1 \
-          GG_BUILD_EXTRA_TESTS_0=1 \
-          bash ./ci/run.sh ~/results/llama.cpp ~/mnt/llama.cpp
-
-  # TODO: provision AMX-compatible machine
-  #cpu-amx:
-  #  runs-on: [self-hosted, Linux, CPU, AMX]
-
-  #  steps:
-  #    - name: Clone
-  #      id: checkout
-  #      uses: actions/checkout@v6
-
-  #    - name: Test
-  #      id: ggml-ci
-  #      run: |
-  #        bash ./ci/run.sh ~/results/llama.cpp ~/mnt/llama.cpp
@@ -1,124 +0,0 @@
-name: CI (self-hosted CUDA backend)
-
-on:
-  workflow_dispatch: # allows manual triggering
-  push:
-    branches:
-      - master
-    paths: [
-      '.github/workflows/ci-self-hosted-cuda.yml',
-      'ci/run.sh',
-      '**/CMakeLists.txt',
-      '**/.cmake',
-      '**/*.h',
-      '**/*.hpp',
-      '**/*.c',
-      '**/*.cpp',
-      '**/*.cu',
-      '**/*.cuh'
-    ]
-
-  pull_request:
-    types: [opened, synchronize, reopened]
-    paths: [
-      '.github/workflows/ci-self-hosted-cuda.yml',
-      'ci/run.sh',
-      '**/CMakeLists.txt',
-      '**/.cmake',
-      'ggml/src/*',
-      'ggml/src/ggml-cpu/**',
-      'ggml/src/ggml-cuda/**'
-    ]
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.head_ref && github.ref || github.run_id }}
-  cancel-in-progress: true
-
-env:
-  # note: this is dud token to avoid rate limiting (https://github.com/ggml-org/llama.cpp/pull/25706#issuecomment-4979941302)
-  HF_TOKEN: ${{ secrets.HF_TOKEN_CI }}
-  GGML_NLOOP: 3
-  GGML_N_THREADS: 1
-  LLAMA_ARG_LOG_COLORS: 1
-  LLAMA_ARG_LOG_PREFIX: 1
-  LLAMA_ARG_LOG_TIMESTAMPS: 1
-
-jobs:
-  gpu-cuda:
-    runs-on: "hf-jobs-t4-medium:cuda13"
-
-    steps:
-      - name: Clone
-        id: checkout
-        uses: actions/checkout@v6
-
-      - name: Install dependencies
-        run: |
-          sudo apt update
-          sudo apt install -y cmake libssl-dev time unzip wget python3 python3-venv python3-pip
-
-      - name: ccache
-        uses: ggml-org/ccache-action@v1.2.24
-        with:
-          restore: false
-          save: false
-
-      - name: ccache-buckets-restore
-        uses: ./.github/actions/ccache-buckets
-        with:
-          key: self-hosted-gpu-cuda
-          folder: llama.cpp
-          hf_bucket: ggml-org/cache
-
-      - name: Test
-        id: ggml-ci
-        run: |
-          nvidia-smi
-          GG_BUILD_CUDA=1 CUDACXX=/usr/local/cuda/bin/nvcc bash ./ci/run.sh ~/results/llama.cpp ~/mnt/llama.cpp
-
-      - name: ccache-buckets-save
-        if: ${{ github.event_name == 'push' && github.ref == 'refs/heads/master' }}
-        uses: ./.github/actions/ccache-buckets
-        env:
-          HF_TOKEN: ${{ secrets.HF_TOKEN_CACHE_OUTPUT }}
-        with:
-          key: self-hosted-gpu-cuda
-          folder: llama.cpp
-          evict-old-files: 1d
-          hf_bucket: ggml-org/cache
-          save: true
-
-  gpu-rocm:
-    runs-on: [self-hosted, Linux, AMD]
-
-    steps:
-      - name: Clone
-        id: checkout
-        uses: actions/checkout@v6
-
-      - name: Test
-        id: ggml-ci
-        # HIP_LAUNCH_BLOCKING=1: workaround for an async-execution correctness
-        # issue on integrated RDNA3.5 (gfx1151) where batched inference returns
-        # incorrect output (perplexity ~88 vs ~9.4). Serializing kernel launches
-        # restores correctness. Remove once the underlying ROCm/HIP issue is fixed.
-        env:
-          HIP_LAUNCH_BLOCKING: "1"
-        run: |
-          rocminfo
-          GG_BUILD_ROCM=1 GG_BUILD_AMDGPU_TARGETS=gfx1151 bash ./ci/run.sh ~/results/llama.cpp ~/mnt/llama.cpp
-
-  # TODO: provision AMD GPU machine
-  # amd-rocm:
-  #   runs-on: [self-hosted, Linux, AMD]
-
-  #   steps:
-  #     - name: Clone
-  #       id: checkout
-  #       uses: actions/checkout@v6
-
-  #     - name: Test
-  #       id: ggml-ci
-  #       run: |
-  #         amd-smi static
-  #         GG_BUILD_ROCM=1 GG_BUILD_AMDGPU_TARGETS="gfx1101" bash ./ci/run.sh ~/results/llama.cpp ~/mnt/llama.cpp
@@ -1,85 +0,0 @@
-name: CI (self-hosted KleidiAI backend)
-
-on:
-  workflow_dispatch: # allows manual triggering
-  push:
-    branches:
-      - master
-    paths: [
-      '.github/workflows/ci-self-hosted-kleidiai.yml',
-      'ci/run.sh',
-      '**/CMakeLists.txt',
-      '**/.cmake',
-      '**/*.h',
-      '**/*.hpp',
-      '**/*.c',
-      '**/*.cpp'
-    ]
-
-  pull_request:
-    types: [opened, synchronize, reopened]
-    paths: [
-      '.github/workflows/ci-self-hosted-kleidiai.yml',
-      'ci/run.sh',
-      '**/CMakeLists.txt',
-      '**/.cmake',
-      'ggml/src/*',
-      'ggml/src/ggml-cpu/**'
-    ]
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.head_ref && github.ref || github.run_id }}
-  cancel-in-progress: true
-
-env:
-  # note: this is dud token to avoid rate limiting (https://github.com/ggml-org/llama.cpp/pull/25706#issuecomment-4979941302)
-  HF_TOKEN: ${{ secrets.HF_TOKEN_CI }}
-  GGML_NLOOP: 3
-  GGML_N_THREADS: 1
-  LLAMA_ARG_LOG_COLORS: 1
-  LLAMA_ARG_LOG_PREFIX: 1
-  LLAMA_ARG_LOG_TIMESTAMPS: 1
-
-jobs:
-  cpu-arm64-graviton4-kleidiai:
-    runs-on: ah-ubuntu_24_04-c8g_8x
-
-    steps:
-      - name: Clone
-        id: checkout
-        uses: actions/checkout@v6
-
-      - name: Dependencies
-        id: depends
-        run: |
-          set -euxo pipefail
-          sudo apt-get update
-          sudo DEBIAN_FRONTEND=noninteractive NEEDRESTART_MODE=a \
-          apt-get install -y \
-          build-essential \
-          python3-venv \
-          gpg \
-          wget \
-          time \
-          git-lfs
-
-          git lfs install
-
-          # install the latest cmake
-          sudo install -d /usr/share/keyrings
-          wget -O - https://apt.kitware.com/keys/kitware-archive-latest.asc \
-            | gpg --dearmor \
-            | sudo tee /usr/share/keyrings/kitware-archive-keyring.gpg >/dev/null
-          echo 'deb [signed-by=/usr/share/keyrings/kitware-archive-keyring.gpg] https://apt.kitware.com/ubuntu/ jammy main' \
-            | sudo tee /etc/apt/sources.list.d/kitware.list
-          sudo apt-get update
-          sudo apt-get install -y cmake
-
-      - name: Test
-        id: ggml-ci
-        run: |
-          LLAMA_ARG_THREADS=$(nproc) \
-          GG_BUILD_KLEIDIAI=1 \
-          GG_BUILD_EXTRA_TESTS_0=1 \
-          GG_BUILD_HIGH_PERF=1 \
-          bash ./ci/run.sh ~/results/llama.cpp ~/mnt/llama.cpp
@@ -1,59 +0,0 @@
-name: CI (self-hosted Metal backend)
-
-on:
-  workflow_dispatch: # allows manual triggering
-  push:
-    branches:
-      - master
-    paths: [
-      '.github/workflows/ci-self-hosted-metal.yml',
-      'ci/run.sh',
-      '**/CMakeLists.txt',
-      '**/.cmake',
-      '**/*.h',
-      '**/*.hpp',
-      '**/*.c',
-      '**/*.cpp',
-      '**/*.swift',
-      '**/*.m',
-      '**/*.metal'
-    ]
-
-  pull_request:
-    types: [opened, synchronize, reopened]
-    paths: [
-      '.github/workflows/ci-self-hosted-metal.yml',
-      'ci/run.sh',
-      '**/CMakeLists.txt',
-      '**/.cmake',
-      'ggml/src/*',
-      'ggml/src/ggml-cpu/**',
-      'ggml/src/ggml-metal/**'
-    ]
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.head_ref && github.ref || github.run_id }}
-  cancel-in-progress: true
-
-env:
-  # note: this is dud token to avoid rate limiting (https://github.com/ggml-org/llama.cpp/pull/25706#issuecomment-4979941302)
-  HF_TOKEN: ${{ secrets.HF_TOKEN_CI }}
-  GGML_NLOOP: 3
-  GGML_N_THREADS: 1
-  LLAMA_ARG_LOG_COLORS: 1
-  LLAMA_ARG_LOG_PREFIX: 1
-  LLAMA_ARG_LOG_TIMESTAMPS: 1
-
-jobs:
-  gpu-metal:
-    runs-on: [self-hosted, macOS, ARM64]
-
-    steps:
-      - name: Clone
-        id: checkout
-        uses: actions/checkout@v6
-
-      - name: Test
-        id: ggml-ci
-        run: |
-          GG_BUILD_METAL=1 bash ./ci/run.sh ~/results/llama.cpp ~/mnt/llama.cpp
@@ -1,75 +0,0 @@
-name: CI (self-hosted OpenVINO backend)
-
-on:
-  workflow_dispatch: # allows manual triggering
-  push:
-    branches:
-      - master
-    paths: [
-      '.github/workflows/ci-self-hosted-openvino.yml',
-      'ci/run.sh',
-      '**/CMakeLists.txt',
-      '**/.cmake',
-      '**/*.h',
-      '**/*.hpp',
-      '**/*.c',
-      '**/*.cpp'
-    ]
-
-  pull_request:
-    types: [opened, synchronize, reopened]
-    paths: [
-      '.github/workflows/ci-self-hosted-openvino.yml',
-      'ci/run.sh',
-      '**/CMakeLists.txt',
-      '**/.cmake',
-      'ggml/src/*',
-      'ggml/src/ggml-cpu/**',
-      'ggml/src/ggml-openvino/**'
-    ]
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.head_ref && github.ref || github.run_id }}
-  cancel-in-progress: true
-
-env:
-  # note: this is dud token to avoid rate limiting (https://github.com/ggml-org/llama.cpp/pull/25706#issuecomment-4979941302)
-  HF_TOKEN: ${{ secrets.HF_TOKEN_CI }}
-  GGML_NLOOP: 3
-  GGML_N_THREADS: 1
-  LLAMA_ARG_LOG_COLORS: 1
-  LLAMA_ARG_LOG_PREFIX: 1
-  LLAMA_ARG_LOG_TIMESTAMPS: 1
-
-jobs:
-  gpu-openvino-low-perf:
-    runs-on: [self-hosted, Linux, Intel, OpenVINO]
-
-    env:
-      # Sync versions in build.yml, build-self-hosted.yml, release.yml, build-cache.yml, .devops/openvino.Dockerfile
-      OPENVINO_VERSION_MAJOR: "2026.4.1"
-      OPENVINO_VERSION_FULL: "2026.4.1.22982.07f9c262b05"
-
-    steps:
-      - name: Clone
-        id: checkout
-        uses: actions/checkout@v6
-
-      - name: Setup OpenVINO Toolkit
-        uses: ./.github/actions/linux-setup-openvino
-        with:
-          path: ./openvino_toolkit
-          version_major: ${{ env.OPENVINO_VERSION_MAJOR }}
-          version_full: ${{ env.OPENVINO_VERSION_FULL }}
-
-      - name: Install OpenVINO dependencies
-        run: |
-          cd ./openvino_toolkit
-          chmod +x ./install_dependencies/install_openvino_dependencies.sh
-          echo "Y" | sudo -E ./install_dependencies/install_openvino_dependencies.sh
-
-      - name: Test
-        id: ggml-ci
-        run: |
-          source ./openvino_toolkit/setupvars.sh
-          GG_BUILD_OPENVINO=1 GGML_OPENVINO_DEVICE=GPU GG_BUILD_LOW_PERF=1 bash ./ci/run.sh ~/results/llama.cpp ~/mnt/llama.cpp
@@ -1,201 +0,0 @@
-name: CI (self-hosted Vulkan backend)
-
-on:
-  workflow_dispatch: # allows manual triggering
-  push:
-    branches:
-      - master
-    paths: [
-      '.github/workflows/ci-self-hosted-vulkan.yml',
-      'ci/run.sh',
-      '**/CMakeLists.txt',
-      '**/.cmake',
-      '**/*.h',
-      '**/*.hpp',
-      '**/*.c',
-      '**/*.cpp',
-      '**/*.comp',
-      '**/*.glsl'
-    ]
-
-  pull_request:
-    types: [opened, synchronize, reopened]
-    paths: [
-      '.github/workflows/ci-self-hosted-vulkan.yml',
-      'ci/run.sh',
-      '**/CMakeLists.txt',
-      '**/.cmake',
-      'ggml/src/*',
-      'ggml/src/ggml-cpu/**',
-      'ggml/src/ggml-vulkan/**'
-    ]
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.head_ref && github.ref || github.run_id }}
-  cancel-in-progress: true
-
-env:
-  # note: this is dud token to avoid rate limiting (https://github.com/ggml-org/llama.cpp/pull/25706#issuecomment-4979941302)
-  HF_TOKEN: ${{ secrets.HF_TOKEN_CI }}
-  GGML_NLOOP: 3
-  GGML_N_THREADS: 1
-  LLAMA_ARG_LOG_COLORS: 1
-  LLAMA_ARG_LOG_PREFIX: 1
-  LLAMA_ARG_LOG_TIMESTAMPS: 1
-
-jobs:
-  gpu-vulkan-nvidia-cm:
-    # runs-on: "hf-jobs-t4-small:ubuntu26_04"
-    runs-on: [self-hosted, Linux, NVIDIA]
-
-    steps:
-      - name: Clone
-        id: checkout
-        uses: actions/checkout@v6
-
-      # - name: Install dependencies
-      #   run: |
-      #     sudo apt update
-      #     sudo apt install -y build-essential cmake libxcb-xinput0 libxcb-xinerama0 libxcb-cursor-dev libvulkan-dev glslc spirv-headers vulkan-tools mesa-vulkan-drivers libglvnd0 libgl1 libglx0 libegl1 libgles2 libssl-dev time unzip wget python3 python3-venv python3-pip
-
-      # - name: ccache
-      #   uses: ggml-org/ccache-action@v1.2.24
-      #   with:
-      #     restore: false
-      #     save: false
-
-      # - name: ccache-buckets-restore
-      #   uses: ./.github/actions/ccache-buckets
-      #   with:
-      #     key: self-hosted-vulkan-nvidia-cm
-      #     folder: llama.cpp
-      #     hf_bucket: ggml-org/cache
-
-      - name: Test
-        id: ggml-ci
-        run: |
-          vulkaninfo --summary
-          GG_BUILD_VULKAN=1 GGML_VK_DISABLE_COOPMAT2=1 bash ./ci/run.sh ~/results/llama.cpp ~/mnt/llama.cpp
-
-      # - name: ccache-buckets-save
-      #   if: ${{ github.event_name == 'push' && github.ref == 'refs/heads/master' }}
-      #   uses: ./.github/actions/ccache-buckets
-      #   env:
-      #     HF_TOKEN: ${{ secrets.HF_TOKEN_CACHE_OUTPUT }}
-      #   with:
-      #     key: self-hosted-vulkan-nvidia-cm
-      #     folder: llama.cpp
-      #     evict-old-files: 1d
-      #     hf_bucket: ggml-org/cache
-      #     save: true
-
-  gpu-vulkan-nvidia-cm2:
-    # runs-on: "hf-jobs-t4-small:ubuntu26_04"
-    runs-on: [self-hosted, Linux, NVIDIA, COOPMAT2]
-
-    steps:
-      - name: Clone
-        id: checkout
-        uses: actions/checkout@v6
-
-      # - name: Install dependencies
-      #   run: |
-      #     sudo apt update
-      #     sudo apt install -y build-essential cmake libxcb-xinput0 libxcb-xinerama0 libxcb-cursor-dev libvulkan-dev glslc spirv-headers vulkan-tools mesa-vulkan-drivers libglvnd0 libgl1 libglx0 libegl1 libgles2 libssl-dev time unzip wget python3 python3-venv python3-pip
-
-      # - name: ccache
-      #   uses: ggml-org/ccache-action@v1.2.24
-      #   with:
-      #     restore: false
-      #     save: false
-
-      # - name: ccache-buckets-restore
-      #   uses: ./.github/actions/ccache-buckets
-      #   with:
-      #     key: self-hosted-vulkan-nvidia-cm2
-      #     folder: llama.cpp
-      #     hf_bucket: ggml-org/cache
-
-      - name: Test
-        id: ggml-ci
-        run: |
-          vulkaninfo --summary
-          GG_BUILD_VULKAN=1 bash ./ci/run.sh ~/results/llama.cpp ~/mnt/llama.cpp
-
-      # - name: ccache-buckets-save
-      #   if: ${{ github.event_name == 'push' && github.ref == 'refs/heads/master' }}
-      #   uses: ./.github/actions/ccache-buckets
-      #   env:
-      #     HF_TOKEN: ${{ secrets.HF_TOKEN_CACHE_OUTPUT }}
-      #   with:
-      #     key: self-hosted-vulkan-nvidia-cm2
-      #     folder: llama.cpp
-      #     evict-old-files: 1d
-      #     hf_bucket: ggml-org/cache
-      #     save: true
-
-  gpu-vulkan-apple:
-    runs-on: [self-hosted, macOS, ARM64]
-
-    steps:
-      - name: Clone
-        id: checkout
-        uses: actions/checkout@v6
-
-      - name: Test
-        id: ggml-ci
-        run: |
-          vulkaninfo --summary
-          GG_BUILD_VULKAN=1 bash ./ci/run.sh ~/results/llama.cpp ~/mnt/llama.cpp
-
-  gpu-vulkan-intel-linux:
-    runs-on: [self-hosted, Linux, Intel]
-
-    steps:
-      - name: Clone
-        id: checkout
-        uses: actions/checkout@v6
-        with:
-          persist-credentials: false
-
-      - name: Test
-        id: ggml-ci
-        run: |
-          vulkaninfo --summary
-          GG_BUILD_VULKAN=1 bash ./ci/run.sh ~/results/llama.cpp ~/mnt/llama.cpp
-
-  gpu-vulkan-intel-windows:
-    runs-on: [self-hosted, Windows, X64, Intel]
-
-    steps:
-      - name: Clone
-        id: checkout
-        uses: actions/checkout@v6
-
-      - name: Test
-        id: ggml-ci
-        shell: C:\msys64\usr\bin\bash.exe --noprofile --norc -eo pipefail "{0}"
-        env:
-          MSYSTEM: UCRT64
-          CHERE_INVOKING: 1
-          PATH: C:\msys64\ucrt64\bin;C:\msys64\usr\bin;C:\Windows\System32;${{ env.PATH }}
-        run: |
-          vulkaninfo --summary
-          # Skip python related tests with GG_BUILD_LOW_PERF=1 since Windows MSYS2 UCRT64 currently fails to create
-          # a valid python environment for testing
-          LLAMA_FATAL_WARNINGS=OFF GG_BUILD_NINJA=1 GG_BUILD_VULKAN=1 GG_BUILD_LOW_PERF=1 ./ci/run.sh ./results/llama.cpp ./mnt/llama.cpp
-
-  # TODO: provision AMD GPU machine
-  # amd-vulkan:
-  #   runs-on: [self-hosted, Linux, AMD]
-
-  #   steps:
-  #     - name: Clone
-  #       id: checkout
-  #       uses: actions/checkout@v6
-
-  #     - name: Test
-  #       id: ggml-ci
-  #       run: |
-  #         vulkaninfo --summary
-  #         GG_BUILD_VULKAN=1 bash ./ci/run.sh ~/results/llama.cpp ~/mnt/llama.cpp
@@ -1,130 +0,0 @@
-name: CI (self-hosted WebGPU backend)
-
-on:
-  workflow_dispatch: # allows manual triggering
-  push:
-    branches:
-      - master
-    paths: [
-      '.github/workflows/ci-self-hosted-webgpu.yml',
-      'ci/run.sh',
-      '**/CMakeLists.txt',
-      '**/.cmake',
-      '**/*.h',
-      '**/*.hpp',
-      '**/*.c',
-      '**/*.cpp',
-      '**/*.wgsl'
-    ]
-
-  pull_request:
-    types: [opened, synchronize, reopened]
-    paths: [
-      '.github/workflows/ci-self-hosted-webgpu.yml',
-      'ci/run.sh',
-      '**/CMakeLists.txt',
-      '**/.cmake',
-      'ggml/src/*',
-      'ggml/src/ggml-cpu/**',
-      'ggml/src/ggml-webgpu/**'
-    ]
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.head_ref && github.ref || github.run_id }}
-  cancel-in-progress: true
-
-env:
-  # note: this is dud token to avoid rate limiting (https://github.com/ggml-org/llama.cpp/pull/25706#issuecomment-4979941302)
-  HF_TOKEN: ${{ secrets.HF_TOKEN_CI }}
-  GGML_NLOOP: 3
-  GGML_N_THREADS: 1
-  LLAMA_ARG_LOG_COLORS: 1
-  LLAMA_ARG_LOG_PREFIX: 1
-  LLAMA_ARG_LOG_TIMESTAMPS: 1
-
-jobs:
-  gpu-webgpu-nvidia:
-    runs-on: "hf-jobs-t4-small:ubuntu26_04"
-
-    steps:
-      - name: Clone
-        id: checkout
-        uses: actions/checkout@v6
-
-      - name: Install dependencies
-        run: |
-          sudo apt update
-          sudo apt install -y build-essential cmake libxcb-xinput0 libxcb-xinerama0 libxcb-cursor-dev libvulkan1 mesa-vulkan-drivers libglvnd0 libgl1 libglx0 libegl1 libgles2 libssl-dev time unzip wget python3 python3-venv python3-pip
-
-      - name: ccache
-        uses: ggml-org/ccache-action@v1.2.24
-        with:
-          restore: false
-          save: false
-
-      - name: ccache-buckets-restore
-        uses: ./.github/actions/ccache-buckets
-        with:
-          key: self-hosted-webgpu-nvidia
-          folder: llama.cpp
-          hf_bucket: ggml-org/cache
-
-      - name: Dawn Dependency
-        id: dawn-depends
-        run: |
-          DAWN_VERSION="v20260908.214631"
-          DAWN_OWNER="google"
-          DAWN_REPO="dawn"
-          DAWN_ASSET_NAME="Dawn-94c3c9cc0d5fb2e85aebb370fa8d37b71aa34655-ubuntu-latest-Release"
-          echo "Fetching release asset from https://github.com/google/dawn/releases/download/${DAWN_VERSION}/${DAWN_ASSET_NAME}.tar.gz"
-          curl -L -o artifact.tar.gz \
-            "https://github.com/google/dawn/releases/download/${DAWN_VERSION}/${DAWN_ASSET_NAME}.tar.gz"
-          mkdir dawn
-          tar -xvf artifact.tar.gz -C dawn --strip-components=1
-
-      - name: Test
-        id: ggml-ci
-        run: |
-          GG_BUILD_WEBGPU=1 \
-          GG_BUILD_WEBGPU_DAWN_PREFIX="$GITHUB_WORKSPACE/dawn" \
-          GG_BUILD_WEBGPU_DAWN_DIR="$GITHUB_WORKSPACE/dawn/lib64/cmake/Dawn" \
-            bash ./ci/run.sh ~/results/llama.cpp ~/mnt/llama.cpp
-
-      - name: ccache-buckets-save
-        if: ${{ github.event_name == 'push' && github.ref == 'refs/heads/master' }}
-        uses: ./.github/actions/ccache-buckets
-        env:
-          HF_TOKEN: ${{ secrets.HF_TOKEN_CACHE_OUTPUT }}
-        with:
-          key: self-hosted-webgpu-nvidia
-          folder: llama.cpp
-          evict-old-files: 1d
-          hf_bucket: ggml-org/cache
-          save: true
-
-  gpu-webgpu-apple:
-    runs-on: [self-hosted, macOS, ARM64]
-
-    steps:
-      - name: Clone
-        id: checkout
-        uses: actions/checkout@v6
-
-      - name: Dawn Dependency
-        id: dawn-depends
-        run: |
-          DAWN_VERSION="v20260908.214631"
-          DAWN_OWNER="google"
-          DAWN_REPO="dawn"
-          DAWN_ASSET_NAME="Dawn-94c3c9cc0d5fb2e85aebb370fa8d37b71aa34655-macos-latest-Release"
-          echo "Fetching release asset from https://github.com/google/dawn/releases/download/${DAWN_VERSION}/${DAWN_ASSET_NAME}.tar.gz"
-          curl -L -o artifact.tar.gz \
-            "https://github.com/google/dawn/releases/download/${DAWN_VERSION}/${DAWN_ASSET_NAME}.tar.gz"
-          mkdir dawn
-          tar -xvf artifact.tar.gz -C dawn --strip-components=1
-
-      - name: Test
-        id: ggml-ci
-        run: |
-          GG_BUILD_WEBGPU=1 GG_BUILD_WEBGPU_DAWN_PREFIX="$GITHUB_WORKSPACE/dawn" \
-            bash ./ci/run.sh ~/results/llama.cpp ~/mnt/llama.cpp
@@ -15,7 +15,7 @@ concurrency:

 jobs:
  model-naming:
-    runs-on: ubuntu-slim
+    runs-on: [self-hosted, fast]
    steps:
      - uses: actions/checkout@v6
      - name: Check model naming conventions
@@ -11,12 +11,10 @@ on:
    paths:
      - .github/workflows/copilot-setup-steps.yml

-cache-mode: none
-
 jobs:
  # The job MUST be called `copilot-setup-steps` or it will not be picked up by Copilot.
  copilot-setup-steps:
-    runs-on: ubuntu-24.04
+    runs-on: ubuntu-latest

    # Set the permissions to the lowest permissions possible needed for your steps.
    # Copilot will be given its own token for its operations.
@@ -33,8 +31,8 @@ jobs:
      - name: ccache
        uses: ggml-org/ccache-action@v1.2.24
        with:
-          restore: false
-          save: false
+          key: copilot-setup-steps
+          evict-old-files: 1d

      - name: Dependencies
        id: depends
@@ -90,8 +90,8 @@ jobs:
            { "tag": "cpu", "dockerfile": ".devops/s390x.Dockerfile", "platforms": "linux/s390x", "full": true, "light": true, "server": true, "free_disk_space": false, "runs_on": "ubuntu-24.04-s390x", "prebuilt_ui": true },
            { "tag": "cuda cuda12", "dockerfile": ".devops/cuda.Dockerfile", "cuda_version": "12.8.1", "platforms": "linux/amd64", "full": true, "light": true, "server": true, "free_disk_space": true, "runs_on": "ubuntu-24.04" },
            { "tag": "cuda cuda12", "dockerfile": ".devops/cuda.Dockerfile", "cuda_version": "12.8.1", "platforms": "linux/arm64", "full": true, "light": true, "server": true, "free_disk_space": true, "runs_on": "ubuntu-24.04-arm" },
-            { "tag": "cuda13", "dockerfile": ".devops/cuda.Dockerfile", "cuda_version": "13.4.1", "platforms": "linux/amd64", "full": true, "light": true, "server": true, "free_disk_space": true, "runs_on": "ubuntu-24.04" },
-            { "tag": "cuda13", "dockerfile": ".devops/cuda.Dockerfile", "cuda_version": "13.4.1", "platforms": "linux/arm64", "full": true, "light": true, "server": true, "free_disk_space": true, "runs_on": "ubuntu-24.04-arm" },
+            { "tag": "cuda13", "dockerfile": ".devops/cuda.Dockerfile", "cuda_version": "13.3.0", "platforms": "linux/amd64", "full": true, "light": true, "server": true, "free_disk_space": true, "runs_on": "ubuntu-24.04" },
+            { "tag": "cuda13", "dockerfile": ".devops/cuda.Dockerfile", "cuda_version": "13.3.0", "platforms": "linux/arm64", "full": true, "light": true, "server": true, "free_disk_space": true, "runs_on": "ubuntu-24.04-arm" },
            { "tag": "musa", "dockerfile": ".devops/musa.Dockerfile", "platforms": "linux/amd64", "full": true, "light": true, "server": true, "free_disk_space": true, "runs_on": "ubuntu-24.04" },
            { "tag": "intel", "dockerfile": ".devops/intel.Dockerfile", "platforms": "linux/amd64", "full": true, "light": true, "server": true, "free_disk_space": true, "runs_on": "ubuntu-24.04" },
            { "tag": "vulkan", "dockerfile": ".devops/vulkan.Dockerfile", "platforms": "linux/amd64", "full": true, "light": true, "server": true, "free_disk_space": false, "runs_on": "ubuntu-24.04" },
@@ -15,7 +15,7 @@ concurrency:

 jobs:
  editorconfig:
-    runs-on: ubuntu-slim
+    runs-on: [self-hosted, fast]
    steps:
      - uses: actions/checkout@v6
      - uses: editorconfig-checker/action-editorconfig-checker@840e866d93b8e032123c23bac69dece044d4d84c # v2.2.0
@@ -0,0 +1,67 @@
+name: Fusion
+
+on:
+  workflow_dispatch: # allows manual triggering
+  push:
+    branches:
+      - master
+    paths: [
+      '.github/workflows/fusion.yml',
+      'ggml/**',
+      'tests/fusion/**',
+      'tests/test-fusion.cpp'
+    ]
+
+  pull_request:
+    types: [opened, synchronize, reopened]
+    paths: [
+      '.github/workflows/fusion.yml',
+      'ggml/**',
+      'tests/fusion/**',
+      'tests/test-fusion.cpp'
+    ]
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.head_ref && github.ref || github.run_id }}
+  cancel-in-progress: true
+
+env:
+  GGML_NLOOP: 3
+  GGML_N_THREADS: 1
+  LLAMA_ARG_LOG_COLORS: 1
+  LLAMA_ARG_LOG_PREFIX: 1
+  LLAMA_ARG_LOG_TIMESTAMPS: 1
+
+jobs:
+  # TODO: add jobs for other backends as they adopt the fusion debug API
+  metal:
+    runs-on: [self-hosted, macOS, ARM64]
+
+    steps:
+      - name: Clone
+        id: checkout
+        uses: actions/checkout@v6
+
+      - name: Build
+        id: cmake_build
+        run: |
+          cmake -B build \
+            -DCMAKE_BUILD_TYPE=Release \
+            -DLLAMA_FATAL_WARNINGS=ON \
+            -DLLAMA_OPENSSL=OFF \
+            -DGGML_SCHED_NO_REALLOC=ON \
+            -DGGML_BLAS=OFF \
+            -DGGML_METAL=ON
+          time cmake --build build --config Release --target test-llama-archs -j $(sysctl -n hw.logicalcpu)
+          time cmake --build build --config Release --target test-fusion -j $(sysctl -n hw.logicalcpu)
+
+      - name: Generate models
+        id: generate_models
+        run: |
+          rm -rf build-ci-models && mkdir -p build-ci-models
+          ./build/bin/test-llama-archs -o build-ci-models
+
+      - name: Test fusion
+        id: test_fusion
+        run: |
+          ./build/bin/test-fusion --models build-ci-models --device MTL0 --check tests/fusion/MTL.csv
@@ -21,7 +21,7 @@ on:
 jobs:
  deploy:

-    runs-on: ubuntu-24.04  # previously ubuntu-latest
+    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v6
@@ -13,16 +13,6 @@ on:
        required: true
        type: boolean
        default: true
-      skip_apiabi_check:
-        description: 'Skip API/ABI compatibility check'
-        required: false
-        type: boolean
-        default: false
-      apiabi_compare_tag:
-        description: 'Tag to compare against for API/ABI check (default: latest release)'
-        required: false
-        type: string
-        default: ''

 env:
  GH_TOKEN: ${{ github.token }}
@@ -33,7 +23,7 @@ permissions:

 jobs:
  make-release:
-    runs-on: ubuntu-24.04  # previously ubuntu-latest
+    runs-on: ubuntu-latest

    steps:
      - name: Checkout
@@ -43,18 +33,12 @@ jobs:
          ref: ${{ inputs.commit != '' && inputs.commit || github.ref_name }}
          fetch-depth: 0

-      - name: Install API/ABI check tools
-        if: ${{ github.event.inputs.skip_apiabi_check != 'true' }}
-        run: sudo apt-get install -y abi-compliance-checker abigail-tools
-
      - name: Run release checks
        id: checks
        run: bash scripts/make-release-checks.sh ${{ github.event.inputs.dry_run == 'true' && '--dry-run' || '' }}
        env:
          GITHUB_REPOSITORY: ${{ github.repository }}
          RELEASE_BRANCH: ${{ github.ref_name }}
-          SKIP_APIABI_CHECK: ${{ github.event.inputs.skip_apiabi_check }}
-          APIABI_COMPARE_TAG: ${{ github.event.inputs.apiabi_compare_tag }}

      - name: Create release tag
        if: ${{ github.event.inputs.dry_run == 'false' }}
@@ -1,445 +0,0 @@
-name: Models Backend Check
-
-on:
-  workflow_dispatch: # allows manual triggering
-  push:
-    branches:
-      - master
-    paths: [
-      '.github/workflows/models-check.yml',
-      'ggml/**',
-      'tests/fusion/**',
-      'tests/test-fusion.cpp',
-      'tests/test-llama-archs.cpp',
-      'src/llama-graph.cpp',
-      'src/llama-model*',
-      'src/models/**'
-    ]
-
-  pull_request:
-    types: [opened, synchronize, reopened]
-    paths: [
-      '.github/workflows/models-check.yml',
-      'ggml/**',
-      'tests/fusion/**',
-      'tests/test-fusion.cpp',
-      'tests/test-llama-archs.cpp',
-      'src/llama-graph.cpp',
-      'src/llama-model*',
-      'src/models/**'
-    ]
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.head_ref && github.ref || github.run_id }}
-  cancel-in-progress: true
-
-env:
-  # note: this is dud token to avoid rate limiting (https://github.com/ggml-org/llama.cpp/pull/25706#issuecomment-4979941302)
-  HF_TOKEN: ${{ secrets.HF_TOKEN_CI }}
-  GGML_NLOOP: 3
-  GGML_N_THREADS: 1
-  LLAMA_ARG_LOG_COLORS: 1
-  LLAMA_ARG_LOG_PREFIX: 1
-  LLAMA_ARG_LOG_TIMESTAMPS: 1
-
-jobs:
-  cuda:
-    runs-on: "hf-jobs-t4-medium:cuda13"
-
-    steps:
-      - name: Clone
-        id: checkout
-        uses: actions/checkout@v6
-
-      - name: Install dependencies
-        run: |
-          sudo apt update
-          sudo apt install -y cmake time python3 python3-venv python3-pip
-
-      - name: ccache
-        uses: ggml-org/ccache-action@v1.2.24
-        with:
-          restore: false
-          save: false
-
-      - name: ccache-buckets-restore
-        uses: ./.github/actions/ccache-buckets
-        with:
-          key: models-check-cuda
-          folder: llama.cpp
-          hf_bucket: ggml-org/cache
-
-      - name: Build
-        id: cmake_build
-        run: |
-          cmake -B build \
-            -DCMAKE_BUILD_TYPE=Release \
-            -DLLAMA_FATAL_WARNINGS=ON \
-            -DLLAMA_OPENSSL=OFF \
-            -DGGML_SCHED_NO_REALLOC=ON \
-            -DCMAKE_CUDA_COMPILER=/usr/local/cuda/bin/nvcc \
-            -DGGML_CUDA=ON
-          time cmake --build build --config Release --target test-llama-archs -j$(nproc)
-          time cmake --build build --config Release --target test-fusion -j$(nproc)
-
-      - name: ccache-buckets-save
-        if: ${{ github.event_name == 'push' && github.ref == 'refs/heads/master' }}
-        uses: ./.github/actions/ccache-buckets
-        env:
-          HF_TOKEN: ${{ secrets.HF_TOKEN_CACHE_OUTPUT }}
-        with:
-          key: models-check-cuda
-          folder: llama.cpp
-          evict-old-files: 1d
-          hf_bucket: ggml-org/cache
-          save: true
-
-      # - name: Generate models
-      #   id: generate_models
-      #   run: |
-      #     rm -rf build-ci-models && mkdir -p build-ci-models
-      #     ./build/bin/test-llama-archs -o build-ci-models
-
-      # TODO: add for backends as they adopt the fusion debug API
-      # - name: Test fusion
-      #   id: test_fusion
-      #   run: |
-      #     ./build/bin/test-fusion --models build-ci-models --device CUDA0 --check tests/fusion/CUDA.csv
-
-      - name: Test archs
-        id: test_archs
-        run: |
-          GGML_CUDA_DEVICES=1 ./build/bin/test-llama-archs -s 1
-          GGML_CUDA_DEVICES=2 ./build/bin/test-llama-archs -s 1
-          GGML_CUDA_DEVICES=3 ./build/bin/test-llama-archs -s 1
-          GGML_CUDA_DEVICES=4 ./build/bin/test-llama-archs -s 1
-
-  metal:
-    runs-on: [self-hosted, macOS, ARM64]
-
-    steps:
-      - name: Clone
-        id: checkout
-        uses: actions/checkout@v6
-
-      - name: Build
-        id: cmake_build
-        run: |
-          cmake -B build \
-            -DCMAKE_BUILD_TYPE=Release \
-            -DLLAMA_FATAL_WARNINGS=ON \
-            -DLLAMA_OPENSSL=OFF \
-            -DGGML_SCHED_NO_REALLOC=ON \
-            -DGGML_BLAS=OFF \
-            -DGGML_METAL=ON
-          time cmake --build build --config Release --target test-llama-archs -j $(sysctl -n hw.logicalcpu)
-          time cmake --build build --config Release --target test-fusion -j $(sysctl -n hw.logicalcpu)
-
-      - name: Generate models
-        id: generate_models
-        run: |
-          rm -rf build-ci-models && mkdir -p build-ci-models
-          ./build/bin/test-llama-archs -o build-ci-models
-
-      - name: Test fusion
-        id: test_fusion
-        run: |
-          ./build/bin/test-fusion --models build-ci-models --device MTL0 --check tests/fusion/MTL.csv
-
-      - name: Test archs
-        id: test_archs
-        run: |
-          GGML_METAL_DEVICES=1 ./build/bin/test-llama-archs -s 1
-          GGML_METAL_DEVICES=2 ./build/bin/test-llama-archs -s 1
-          GGML_METAL_DEVICES=3 ./build/bin/test-llama-archs -s 1
-          GGML_METAL_DEVICES=4 ./build/bin/test-llama-archs -s 1
-
-  rocm:
-    runs-on: [self-hosted, Linux, gfx1201]
-    container: "rocm/dev-ubuntu-24.04:7.2.4-complete"
-
-    steps:
-      - name: Clone
-        id: checkout
-        uses: actions/checkout@v6
-
-      - name: Install dependencies
-        run: |
-          apt update
-          apt install -y build-essential jq cmake time python3 python3-venv python3-pip
-
-      - name: ccache
-        uses: ggml-org/ccache-action@v1.2.24
-        with:
-          restore: false
-          save: false
-
-      - name: ccache-buckets-restore
-        uses: ./.github/actions/ccache-buckets
-        with:
-          key: models-check-rocm
-          folder: llama.cpp
-          hf_bucket: ggml-org/cache
-
-      - name: Build
-        id: cmake_build
-        run: |
-          cmake -B build \
-            -DCMAKE_BUILD_TYPE=Release \
-            -DLLAMA_FATAL_WARNINGS=ON \
-            -DLLAMA_OPENSSL=OFF \
-            -DGGML_SCHED_NO_REALLOC=ON \
-            -DCMAKE_HIP_COMPILER=$(hipconfig -l)/clang \
-            -DGPU_TARGETS=gfx1201 \
-            -DGGML_HIP=ON
-          time cmake --build build --config Release --target test-llama-archs -j$(nproc)
-          time cmake --build build --config Release --target test-fusion -j$(nproc)
-
-      - name: ccache-buckets-save
-        if: ${{ github.event_name == 'push' && github.ref == 'refs/heads/master' }}
-        uses: ./.github/actions/ccache-buckets
-        env:
-          HF_TOKEN: ${{ secrets.HF_TOKEN_CACHE_OUTPUT }}
-        with:
-          key: models-check-rocm
-          folder: llama.cpp
-          evict-old-files: 1d
-          hf_bucket: ggml-org/cache
-          save: true
-
-      # - name: Generate models
-      #   id: generate_models
-      #   run: |
-      #     rm -rf build-ci-models && mkdir -p build-ci-models
-      #     ./build/bin/test-llama-archs -o build-ci-models
-
-      # TODO: add for backends as they adopt the fusion debug API
-      # - name: Test fusion
-      #   id: test_fusion
-      #   run: |
-      #     ./build/bin/test-fusion --models build-ci-models --device CUDA0 --check tests/fusion/CUDA.csv
-
-      - name: Test archs
-        id: test_archs
-        run: |
-          GGML_CUDA_DEVICES=1 ./build/bin/test-llama-archs -s 1
-          GGML_CUDA_DEVICES=2 ./build/bin/test-llama-archs -s 1
-          GGML_CUDA_DEVICES=3 ./build/bin/test-llama-archs -s 1
-          GGML_CUDA_DEVICES=4 ./build/bin/test-llama-archs -s 1
-
-  vulkan-nvidia:
-    runs-on: "hf-jobs-t4-small:ubuntu26_04"
-
-    steps:
-      - name: Clone
-        id: checkout
-        uses: actions/checkout@v6
-
-      - name: Install dependencies
-        run: |
-          sudo apt update
-          sudo apt install -y build-essential cmake libxcb-xinput0 libxcb-xinerama0 libxcb-cursor-dev libvulkan-dev glslc spirv-headers vulkan-tools mesa-vulkan-drivers libglvnd0 libgl1 libglx0 libegl1 libgles2 time python3 python3-venv python3-pip
-
-      - name: ccache
-        uses: ggml-org/ccache-action@v1.2.24
-        with:
-          restore: false
-          save: false
-
-      - name: ccache-buckets-restore
-        uses: ./.github/actions/ccache-buckets
-        with:
-          key: models-check-vulkan-nvidia
-          folder: llama.cpp
-          hf_bucket: ggml-org/cache
-
-      - name: Build
-        id: cmake_build
-        run: |
-          cmake -B build \
-            -DCMAKE_BUILD_TYPE=Release \
-            -DLLAMA_FATAL_WARNINGS=ON \
-            -DLLAMA_OPENSSL=OFF \
-            -DGGML_SCHED_NO_REALLOC=ON \
-            -DGGML_VULKAN=ON
-          time cmake --build build --config Release --target test-llama-archs -j$(nproc)
-          time cmake --build build --config Release --target test-fusion -j$(nproc)
-
-      - name: ccache-buckets-save
-        if: ${{ github.event_name == 'push' && github.ref == 'refs/heads/master' }}
-        uses: ./.github/actions/ccache-buckets
-        env:
-          HF_TOKEN: ${{ secrets.HF_TOKEN_CACHE_OUTPUT }}
-        with:
-          key: models-check-vulkan-nvidia
-          folder: llama.cpp
-          evict-old-files: 1d
-          hf_bucket: ggml-org/cache
-          save: true
-
-      # - name: Generate models
-      #   id: generate_models
-      #   run: |
-      #     rm -rf build-ci-models && mkdir -p build-ci-models
-      #     ./build/bin/test-llama-archs -o build-ci-models
-
-      # TODO: add for backends as they adopt the fusion debug API
-      # - name: Test fusion
-      #   id: test_fusion
-      #   run: |
-      #     ./build/bin/test-fusion --models build-ci-models --device Vulkan0 --check tests/fusion/Vulkan.csv
-
-      - name: Test archs
-        id: test_archs
-        run: |
-          ./build/bin/test-llama-archs -s 1
-
-  vulkan-amd:
-    runs-on: [self-hosted, Linux, gfx1201]
-    container: "ubuntu:26.04"
-
-    steps:
-      - name: Clone
-        id: checkout
-        uses: actions/checkout@v6
-
-      - name: Install dependencies
-        run: |
-          apt update
-          apt install -y build-essential jq cmake libxcb-xinput0 libxcb-xinerama0 libxcb-cursor-dev libvulkan-dev glslc spirv-headers vulkan-tools mesa-vulkan-drivers libglvnd0 libgl1 libglx0 libegl1 libgles2 time python3 python3-venv python3-pip
-
-      - name: ccache
-        uses: ggml-org/ccache-action@v1.2.24
-        with:
-          restore: false
-          save: false
-
-      - name: ccache-buckets-restore
-        uses: ./.github/actions/ccache-buckets
-        with:
-          key: models-check-vulkan-amd
-          folder: llama.cpp
-          hf_bucket: ggml-org/cache
-
-      - name: Build
-        id: cmake_build
-        run: |
-          cmake -B build \
-            -DCMAKE_BUILD_TYPE=Release \
-            -DLLAMA_FATAL_WARNINGS=ON \
-            -DLLAMA_OPENSSL=OFF \
-            -DGGML_SCHED_NO_REALLOC=ON \
-            -DGGML_VULKAN=ON
-          time cmake --build build --config Release --target test-llama-archs -j$(nproc)
-          time cmake --build build --config Release --target test-fusion -j$(nproc)
-
-      - name: ccache-buckets-save
-        if: ${{ github.event_name == 'push' && github.ref == 'refs/heads/master' }}
-        uses: ./.github/actions/ccache-buckets
-        env:
-          HF_TOKEN: ${{ secrets.HF_TOKEN_CACHE_OUTPUT }}
-        with:
-          key: models-check-vulkan-amd
-          folder: llama.cpp
-          evict-old-files: 1d
-          hf_bucket: ggml-org/cache
-          save: true
-
-      # - name: Generate models
-      #   id: generate_models
-      #   run: |
-      #     rm -rf build-ci-models && mkdir -p build-ci-models
-      #     ./build/bin/test-llama-archs -o build-ci-models
-
-      # TODO: add for backends as they adopt the fusion debug API
-      # - name: Test fusion
-      #   id: test_fusion
-      #   run: |
-      #     ./build/bin/test-fusion --models build-ci-models --device Vulkan0 --check tests/fusion/Vulkan.csv
-
-      - name: Test archs
-        id: test_archs
-        run: |
-          ./build/bin/test-llama-archs -s 1
-
-  webgpu-nvidia:
-    runs-on: "hf-jobs-t4-small:ubuntu26_04"
-
-    steps:
-      - name: Clone
-        id: checkout
-        uses: actions/checkout@v6
-
-      - name: Install dependencies
-        run: |
-          sudo apt update
-          sudo apt install -y build-essential cmake libxcb-xinput0 libxcb-xinerama0 libxcb-cursor-dev libvulkan1 mesa-vulkan-drivers libglvnd0 libgl1 libglx0 libegl1 libgles2 time python3 python3-venv python3-pip
-
-      - name: ccache
-        uses: ggml-org/ccache-action@v1.2.24
-        with:
-          restore: false
-          save: false
-
-      - name: ccache-buckets-restore
-        uses: ./.github/actions/ccache-buckets
-        with:
-          key: models-check-webgpu-nvidia
-          folder: llama.cpp
-          hf_bucket: ggml-org/cache
-
-      - name: Dawn Dependency
-        id: dawn-depends
-        run: |
-          DAWN_VERSION="v20260908.214631"
-          DAWN_OWNER="google"
-          DAWN_REPO="dawn"
-          DAWN_ASSET_NAME="Dawn-94c3c9cc0d5fb2e85aebb370fa8d37b71aa34655-ubuntu-latest-Release"
-          echo "Fetching release asset from https://github.com/google/dawn/releases/download/${DAWN_VERSION}/${DAWN_ASSET_NAME}.tar.gz"
-          curl -L -o artifact.tar.gz \
-            "https://github.com/google/dawn/releases/download/${DAWN_VERSION}/${DAWN_ASSET_NAME}.tar.gz"
-          mkdir dawn
-          tar -xvf artifact.tar.gz -C dawn --strip-components=1
-
-      - name: Build
-        id: cmake_build
-        run: |
-          cmake -B build \
-            -DCMAKE_BUILD_TYPE=Release \
-            -DLLAMA_FATAL_WARNINGS=ON \
-            -DLLAMA_OPENSSL=OFF \
-            -DGGML_SCHED_NO_REALLOC=ON \
-            -DCMAKE_PREFIX_PATH="$GITHUB_WORKSPACE/dawn" \
-            -DDawn_DIR="$GITHUB_WORKSPACE/dawn/lib64/cmake/Dawn" \
-            -DGGML_WEBGPU=ON
-          time cmake --build build --config Release --target test-llama-archs -j$(nproc)
-          time cmake --build build --config Release --target test-fusion -j$(nproc)
-
-      - name: ccache-buckets-save
-        if: ${{ github.event_name == 'push' && github.ref == 'refs/heads/master' }}
-        uses: ./.github/actions/ccache-buckets
-        env:
-          HF_TOKEN: ${{ secrets.HF_TOKEN_CACHE_OUTPUT }}
-        with:
-          key: models-check-webgpu-nvidia
-          folder: llama.cpp
-          evict-old-files: 1d
-          hf_bucket: ggml-org/cache
-          save: true
-
-      # - name: Generate models
-      #   id: generate_models
-      #   run: |
-      #     rm -rf build-ci-models && mkdir -p build-ci-models
-      #     ./build/bin/test-llama-archs -o build-ci-models
-
-      # TODO: add for backends as they adopt the fusion debug API
-      # - name: Test fusion
-      #   id: test_fusion
-      #   run: |
-      #     ./build/bin/test-fusion --models build-ci-models --device WebGPU --check tests/fusion/WebGPU.csv
-
-      - name: Test archs
-        id: test_archs
-        run: |
-          ./build/bin/test-llama-archs -s 1
@@ -12,7 +12,7 @@ on:

 jobs:
    pre-tokenizer-hashes:
-        runs-on: ubuntu-slim
+        runs-on: [self-hosted, fast]

        steps:
        - name: Checkout repository
@@ -20,7 +20,7 @@ concurrency:

 jobs:
  python-check-requirements:
-    runs-on: ${{ 'ubuntu-24.04-arm' || 'ubuntu-24.04' }}
+    runs-on: [self-hosted, CPU, fast]
    name: check-requirements
    steps:
      - name: Check out source repository
@@ -21,7 +21,7 @@ concurrency:

 jobs:
  flake8-lint:
-    runs-on: ubuntu-slim
+    runs-on: [self-hosted, fast]
    name: Lint
    steps:
      - name: Check out source repository
@@ -22,7 +22,7 @@ concurrency:

 jobs:
  python-type-check:
-    runs-on: ubuntu-slim
+    runs-on: [self-hosted, fast]
    name: python type-check
    steps:
      - name: Check out source repository
@@ -31,7 +31,7 @@ jobs:
        uses: actions/setup-python@v6
        with:
          python-version: "3.11"
-          pip-install: -r requirements/requirements-all.txt ty==0.0.84
+          pip-install: -r requirements/requirements-all.txt ty==0.0.78
      # - name: Type-check with Pyright
      #   uses: jakebailey/pyright-action@v2
      #   with:
@@ -1,239 +0,0 @@
-name: Publish Release
-
-on:
-  workflow_run:
-    workflows:
-      - Release
-    types:
-      - completed
-    branches:
-      - master
-
-env:
-  GH_TOKEN: ${{ github.token }}
-  BRANCH_NAME: master
-
-jobs:
-  publish:
-    if: ${{ github.event.workflow_run.conclusion == 'success' }}
-
-    # Fine-grained permission
-    # https://docs.github.com/en/actions/security-for-github-actions/security-guides/automatic-token-authentication#modifying-the-permissions-for-the-github_token
-    permissions:
-        actions: read
-        contents: write # for creating release
-        id-token: write
-        attestations: write
-
-    runs-on: ubuntu-latest
-
-    outputs:
-      should_release: ${{ steps.check.outputs.should_release }}
-      tag_name: ${{ steps.tag.outputs.name }}
-
-    steps:
-      - id: check
-        env:
-          COMMIT_MESSAGE: ${{ github.event.workflow_run.head_commit.message }}
-        run: |
-          if echo "$COMMIT_MESSAGE" | grep -q '\[no release\]'; then
-            echo "should_release=false" >> $GITHUB_OUTPUT
-          else
-            echo "should_release=true" >> $GITHUB_OUTPUT
-          fi
-
-      - name: Clone
-        if: ${{ steps.check.outputs.should_release == 'true' }}
-        id: checkout
-        uses: actions/checkout@v6
-        with:
-          ref: ${{ github.event.workflow_run.head_sha }}
-          fetch-depth: 0
-          ssh-key: ${{ secrets.DEPLOY_KEY_RELEASE }}
-
-      - name: Determine tag name
-        if: ${{ steps.check.outputs.should_release == 'true' }}
-        id: tag
-        uses: ./.github/actions/get-tag-name
-
-      - name: Download artifacts
-        if: ${{ steps.check.outputs.should_release == 'true' }}
-        id: download-artifact
-        uses: actions/download-artifact@v8
-        with:
-          path: ./artifact
-          run-id: ${{ github.event.workflow_run.id }}
-          github-token: ${{ github.token }}
-          merge-multiple: true
-          skip-decompress: true
-
-      - name: Merge artifacts
-        if: ${{ steps.check.outputs.should_release == 'true' }}
-        id: move_artifacts
-        run: |
-          mkdir -p release
-
-          # the windows-cpu zip contains the full toolset (llama-server with the embedded
-          # UI, ggml-cpu) - inject it into the other windows zips so that every archive
-          # ships the same binaries, only with a different backend library on top
-          echo "Injecting windows-cpu binaries (llama-server + CPU backend) into the backend zips..."
-          for arch in x64 arm64; do
-            cpu_zip="artifact/llama-bin-win-cpu-${arch}.zip"
-            temp_dir=$(mktemp -d)
-            echo "Extracting windows-cpu-${arch} package..."
-            unzip "$cpu_zip" -d "$temp_dir"
-
-            echo "Merging into $arch zips..."
-            for target_zip in artifact/llama-bin-win-*-${arch}.zip; do
-              if [[ "$target_zip" == "$cpu_zip" ]]; then
-                continue
-              fi
-              echo "Injecting into $(basename "$target_zip")"
-              realpath_target_zip=$(realpath "$target_zip")
-              (cd "$temp_dir" && zip -r "$realpath_target_zip" .)
-            done
-
-            rm -rf "$temp_dir"
-          done
-
-          echo "Renaming and moving zips to release..."
-          for zip_file in artifact/llama-bin-win-*.zip; do
-            base_name=$(basename "$zip_file" .zip)
-            zip_name="llama-${{ steps.tag.outputs.name }}-${base_name#llama-}.zip"
-            echo "Moving $zip_file to release/$zip_name"
-            mv "$zip_file" "release/$zip_name"
-          done
-
-          echo "Moving other artifacts..."
-          rm -f artifact/llama-ui.zip
-          mv -v artifact/*.zip release
-          mv -v artifact/*.tar.gz release
-
-      - name: Download UI build
-        if: ${{ steps.check.outputs.should_release == 'true' }}
-        id: download_ui
-        uses: actions/download-artifact@v8
-        with:
-          name: llama-ui.zip
-          path: ./ui-dist
-          run-id: ${{ github.event.workflow_run.id }}
-          github-token: ${{ github.token }}
-
-      - name: Package UI
-        if: ${{ steps.check.outputs.should_release == 'true' }}
-        id: package_ui
-        run: |
-          tar -czvf release/llama-${{ steps.tag.outputs.name }}-ui.tar.gz --transform "s,^\.,llama-${{ steps.tag.outputs.name }}," -C ./ui-dist .
-
-      - name: Attest release artifacts
-        if: ${{ steps.check.outputs.should_release == 'true' }}
-        id: attest
-        uses: actions/attest@v4
-        with:
-          subject-path: 'release/*'
-
-      - name: Create release
-        if: ${{ steps.check.outputs.should_release == 'true' }}
-        id: create_release
-        uses: ggml-org/action-create-release@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          tag_name: ${{ steps.tag.outputs.name }}
-          commitish: ${{ github.event.workflow_run.head_sha }}
-          prerelease: true
-          body: |
-            <details open>
-
-            ${{ github.event.workflow_run.head_commit.message }}
-
-            </details>
-
-            **Website:**
-            - <https://llama.app>
-
-            **Attestations:**
-            - <${{ steps.attest.outputs.attestation-url }}>
-
-            **macOS/iOS:**
-            - [macOS Apple Silicon (arm64)](https://github.com/ggml-org/llama.cpp/releases/download/${{ steps.tag.outputs.name }}/llama-${{ steps.tag.outputs.name }}-bin-macos-arm64.tar.gz)
-            - macOS Apple Silicon (arm64, KleidiAI enabled) [DISABLED](https://github.com/ggml-org/llama.cpp/pull/23780)
-            - [macOS Intel (x64)](https://github.com/ggml-org/llama.cpp/releases/download/${{ steps.tag.outputs.name }}/llama-${{ steps.tag.outputs.name }}-bin-macos-x64.tar.gz)
-            - [iOS XCFramework](https://github.com/ggml-org/llama.cpp/releases/download/${{ steps.tag.outputs.name }}/llama-${{ steps.tag.outputs.name }}-xcframework.zip)
-
-            **Linux:**
-            - [Ubuntu x64 (CPU)](https://github.com/ggml-org/llama.cpp/releases/download/${{ steps.tag.outputs.name }}/llama-${{ steps.tag.outputs.name }}-bin-ubuntu-x64.tar.gz)
-            - [Ubuntu arm64 (CPU)](https://github.com/ggml-org/llama.cpp/releases/download/${{ steps.tag.outputs.name }}/llama-${{ steps.tag.outputs.name }}-bin-ubuntu-arm64.tar.gz)
-            - [Ubuntu s390x (CPU)](https://github.com/ggml-org/llama.cpp/releases/download/${{ steps.tag.outputs.name }}/llama-${{ steps.tag.outputs.name }}-bin-ubuntu-s390x.tar.gz)
-            - [Ubuntu x64 (Vulkan)](https://github.com/ggml-org/llama.cpp/releases/download/${{ steps.tag.outputs.name }}/llama-${{ steps.tag.outputs.name }}-bin-ubuntu-vulkan-x64.tar.gz)
-            - [Ubuntu arm64 (Vulkan)](https://github.com/ggml-org/llama.cpp/releases/download/${{ steps.tag.outputs.name }}/llama-${{ steps.tag.outputs.name }}-bin-ubuntu-vulkan-arm64.tar.gz)
-            - [Ubuntu x64 (CUDA 12)](https://github.com/ggml-org/llama.cpp/releases/download/${{ steps.tag.outputs.name }}/llama-${{ steps.tag.outputs.name }}-bin-ubuntu-cuda-12.8-x64.tar.gz) - [CUDA 12.8 libraries](https://github.com/ggml-org/llama.cpp/releases/download/${{ steps.tag.outputs.name }}/cudart-llama-${{ steps.tag.outputs.name }}-bin-ubuntu-cuda-12.8-x64.tar.gz)
-            - [Ubuntu x64 (CUDA 13)](https://github.com/ggml-org/llama.cpp/releases/download/${{ steps.tag.outputs.name }}/llama-${{ steps.tag.outputs.name }}-bin-ubuntu-cuda-13.4-x64.tar.gz) - [CUDA 13.4 libraries](https://github.com/ggml-org/llama.cpp/releases/download/${{ steps.tag.outputs.name }}/cudart-llama-${{ steps.tag.outputs.name }}-bin-ubuntu-cuda-13.4-x64.tar.gz)
-            - [Ubuntu arm64 (CUDA 13)](https://github.com/ggml-org/llama.cpp/releases/download/${{ steps.tag.outputs.name }}/llama-${{ steps.tag.outputs.name }}-bin-ubuntu-cuda-13.4-arm64.tar.gz) - [CUDA 13.4 libraries](https://github.com/ggml-org/llama.cpp/releases/download/${{ steps.tag.outputs.name }}/cudart-llama-${{ steps.tag.outputs.name }}-bin-ubuntu-cuda-13.4-arm64.tar.gz)
-            - [Ubuntu x64 (ROCm 10.0)](https://github.com/ggml-org/llama.cpp/releases/download/${{ steps.tag.outputs.name }}/llama-${{ steps.tag.outputs.name }}-bin-ubuntu-rocm-10.0-x64.tar.gz)
-            - [Ubuntu x64 (OpenVINO)](https://github.com/ggml-org/llama.cpp/releases/download/${{ steps.tag.outputs.name }}/llama-${{ steps.tag.outputs.name }}-bin-ubuntu-openvino-${{ needs.ubuntu-24-openvino.outputs.openvino_version }}-x64.tar.gz)
-            - [Ubuntu x64 (SYCL FP32)](https://github.com/ggml-org/llama.cpp/releases/download/${{ steps.tag.outputs.name }}/llama-${{ steps.tag.outputs.name }}-bin-ubuntu-sycl-fp32-x64.tar.gz)
-            - [Ubuntu x64 (SYCL FP16)](https://github.com/ggml-org/llama.cpp/releases/download/${{ steps.tag.outputs.name }}/llama-${{ steps.tag.outputs.name }}-bin-ubuntu-sycl-fp16-x64.tar.gz)
-            - [Linux arm64 (Snapdragon: CPU, Adreno GPU, Hexagon NPU)](https://github.com/ggml-org/llama.cpp/releases/download/${{ steps.tag.outputs.name }}/llama-${{ steps.tag.outputs.name }}-bin-linux-arm64-snapdragon.tar.gz) - [setup guide](https://github.com/ggml-org/llama.cpp/blob/master/docs/backend/snapdragon/linux.md)
-
-            **Android:**
-            - [Android arm64 (CPU)](https://github.com/ggml-org/llama.cpp/releases/download/${{ steps.tag.outputs.name }}/llama-${{ steps.tag.outputs.name }}-bin-android-arm64.tar.gz)
-            - [Android arm64 (Snapdragon: CPU, Adreno GPU, Hexagon NPU)](https://github.com/ggml-org/llama.cpp/releases/download/${{ steps.tag.outputs.name }}/llama-${{ steps.tag.outputs.name }}-bin-android-arm64-snapdragon.tar.gz) - [setup guide](https://github.com/ggml-org/llama.cpp/blob/master/docs/backend/snapdragon/README.md)
-
-            **Windows:**
-            - [Windows x64 (CPU)](https://github.com/ggml-org/llama.cpp/releases/download/${{ steps.tag.outputs.name }}/llama-${{ steps.tag.outputs.name }}-bin-win-cpu-x64.zip)
-            - [Windows arm64 (CPU)](https://github.com/ggml-org/llama.cpp/releases/download/${{ steps.tag.outputs.name }}/llama-${{ steps.tag.outputs.name }}-bin-win-cpu-arm64.zip)
-            - [Windows arm64 (OpenCL Adreno)](https://github.com/ggml-org/llama.cpp/releases/download/${{ steps.tag.outputs.name }}/llama-${{ steps.tag.outputs.name }}-bin-win-opencl-adreno-arm64.zip)
-            - [Windows x64 (CUDA 12)](https://github.com/ggml-org/llama.cpp/releases/download/${{ steps.tag.outputs.name }}/llama-${{ steps.tag.outputs.name }}-bin-win-cuda-12.4-x64.zip) - [CUDA 12.4 DLLs](https://github.com/ggml-org/llama.cpp/releases/download/${{ steps.tag.outputs.name }}/cudart-llama-bin-win-cuda-12.4-x64.zip)
-            - [Windows x64 (CUDA 13)](https://github.com/ggml-org/llama.cpp/releases/download/${{ steps.tag.outputs.name }}/llama-${{ steps.tag.outputs.name }}-bin-win-cuda-13.4-x64.zip) - [CUDA 13.4 DLLs](https://github.com/ggml-org/llama.cpp/releases/download/${{ steps.tag.outputs.name }}/cudart-llama-bin-win-cuda-13.4-x64.zip)
-            - [Windows arm64 (CUDA 13)](https://github.com/ggml-org/llama.cpp/releases/download/${{ steps.tag.outputs.name }}/llama-${{ steps.tag.outputs.name }}-bin-win-cuda-13.4-arm64.zip) - [CUDA 13.4 DLLs](https://github.com/ggml-org/llama.cpp/releases/download/${{ steps.tag.outputs.name }}/cudart-llama-bin-win-cuda-13.4-arm64.zip)
-            - [Windows x64 (Vulkan)](https://github.com/ggml-org/llama.cpp/releases/download/${{ steps.tag.outputs.name }}/llama-${{ steps.tag.outputs.name }}-bin-win-vulkan-x64.zip)
-            - [Windows x64 (OpenVINO)](https://github.com/ggml-org/llama.cpp/releases/download/${{ steps.tag.outputs.name }}/llama-${{ steps.tag.outputs.name }}-bin-win-openvino-${{ needs.windows-openvino.outputs.openvino_version }}-x64.zip)
-            - [Windows x64 (SYCL)](https://github.com/ggml-org/llama.cpp/releases/download/${{ steps.tag.outputs.name }}/llama-${{ steps.tag.outputs.name }}-bin-win-sycl-x64.zip)
-            - [Windows x64 (ROCm 10.0)](https://github.com/ggml-org/llama.cpp/releases/download/${{ steps.tag.outputs.name }}/llama-${{ steps.tag.outputs.name }}-bin-win-rocm-10.0-x64.zip)
-
-            **openEuler:**
-            - [DISABLED](https://github.com/ggml-org/llama.cpp/pull/23705)
-            - openEuler x86 (310p)
-            - openEuler x86 (910b, ACL Graph)
-            - openEuler aarch64 (310p)
-            - openEuler aarch64 (910b, ACL Graph)
-
-            **UI:**
-            - [UI](https://github.com/ggml-org/llama.cpp/releases/download/${{ steps.tag.outputs.name }}/llama-${{ steps.tag.outputs.name }}-ui.tar.gz)
-
-      - name: Upload release
-        if: ${{ steps.check.outputs.should_release == 'true' }}
-        id: upload_release
-        uses: actions/github-script@v8
-        with:
-          github-token: ${{secrets.GITHUB_TOKEN}}
-          script: |
-            const path = require('path');
-            const fs = require('fs');
-            const release_id = '${{ steps.create_release.outputs.id }}';
-            for (let file of await fs.readdirSync('./release')) {
-              if (path.extname(file) === '.zip' || file.endsWith('.tar.gz')) {
-                console.log('uploadReleaseAsset', file);
-                await github.rest.repos.uploadReleaseAsset({
-                  owner: context.repo.owner,
-                  repo: context.repo.repo,
-                  release_id: release_id,
-                  name: file,
-                  data: await fs.readFileSync(`./release/${file}`)
-                });
-              }
-            }
-
-  ui-publish:
-    if: ${{ needs.publish.outputs.should_release == 'true' }}
-
-    needs:
-      - publish
-
-    uses: ./.github/workflows/ui-publish.yml
-    with:
-      version_tag: ${{ needs.publish.outputs.tag_name }}
-      run_id: ${{ github.event.workflow_run.id }}
-    secrets:
-      hf_token: ${{ secrets.HF_TOKEN_UI_STATIC_OUTPUT }}
@@ -45,7 +45,7 @@ concurrency:

 jobs:
  server:
-    runs-on: hf-jobs-cpu-performance
+    runs-on: hf-jobs-cpu-upgrade

    strategy:
      matrix:
@@ -116,7 +116,8 @@ jobs:
        run: |
          source .venv/bin/activate
          cd tools/server/tests
-          PYTEST_WORKERS=4 ./tests.sh
+          export ${{ matrix.extra_args }}
+          PYTEST_WORKERS=1 ./tests.sh

      - name: Slow tests
        id: server_integration_tests_slow
@@ -124,4 +125,5 @@ jobs:
        run: |
          source .venv/bin/activate
          cd tools/server/tests
-          PYTEST_WORKERS=4 SLOW_TESTS=1 ./tests.sh
+          export ${{ matrix.extra_args }}
+          PYTEST_WORKERS=1 SLOW_TESTS=1 ./tests.sh
@@ -102,7 +102,7 @@ jobs:
          PYTEST_WORKERS=1 ./tests.sh

  server-cuda:
-    runs-on: "hf-jobs-t4-medium:cuda13"
+    runs-on: "hf-jobs-t4-small:cuda13"

    steps:
      - name: Clone
@@ -192,7 +192,7 @@ jobs:
          PYTEST_WORKERS=1 ./tests.sh

  server-kleidiai:
-    runs-on: ah-ubuntu_24_04-c8g_8x
+    runs-on: ah-ubuntu_22_04-c8g_8x

    steps:
      - name: Clone
@@ -232,7 +232,7 @@ jobs:
      - name: Build
        id: cmake_build
        run: |
-          cmake -B build -DGGML_SCHED_NO_REALLOC=ON -DGGML_CPU_KLEIDIAI=ON -DLLAMA_FATAL_WARNINGS=ON
+          cmake -B build -DGGML_SCHED_NO_REALLOC=ON -DGGML_CPU_KLEIDIAI=ON
          cmake --build build --config Release -j $(nproc) --target llama-server

      - name: Python setup
@@ -11,10 +11,8 @@ on:
 jobs:
  build:
    runs-on: ubuntu-slim
-
-    permissions:
-      actions: write
-      contents: read
+    env:
+      BRANCH_NAME: ${{ github.head_ref || github.ref_name }}

    steps:
      - name: Checkout code
@@ -54,7 +52,7 @@ jobs:
        working-directory: tools/ui

      - name: Upload built UI
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@v6
        with:
          name: llama-ui.zip
          path: tools/ui/dist/
@@ -7,34 +7,38 @@ on:
        description: 'Version tag to publish under (e.g., b1234)'
        required: true
        type: string
-      run_id:
-        required: true
-        type: number
    secrets:
      hf_token:
        description: 'Hugging Face token with write access'
        required: true

 jobs:
+  build:
+    name: Build static output
+    uses: ./.github/workflows/ui-build.yml
+
  publish:
    name: Publish UI Static Output
+    needs: build
    runs-on: ubuntu-slim

    permissions:
-      actions: read
      contents: read

    env:
      HF_BUCKET_NAME: ${{ vars.HF_BUCKET_UI_STATIC_OUTPUT }}

    steps:
+      - name: Checkout code
+        uses: actions/checkout@v6
+        with:
+          fetch-depth: 1
+
      - name: Download UI build artifact
-        uses: actions/download-artifact@v8
+        uses: actions/download-artifact@v7
        with:
          name: llama-ui.zip
          path: tools/ui/dist/
-          run-id: ${{ inputs.run_id }}
-          github-token: ${{ github.token }}

      - name: Create distribution archive
        run: |
@@ -16,7 +16,7 @@ on:

 jobs:
    update-ops-docs:
-        runs-on: ubuntu-slim
+        runs-on: [self-hosted, fast, ARM64]

        steps:
        - name: Checkout repository
@@ -8,7 +8,7 @@ on:
 jobs:
  update:
    name: Update Winget Package
-    runs-on: ubuntu-24.04  # previously ubuntu-latest
+    runs-on: ubuntu-latest
    if: github.repository_owner == 'ggml-org'

    steps:
@@ -6,8 +6,6 @@ General:
 - PR and commit titles format: `<module> : <title>`. Lookup recents for examples
 - Don't try to build or run the code unless you are explicitly asked to do so
 - Use the `gh` CLI tool when querying PRs, issues, or other GitHub resources
- When [MODEL] is needed, first try to get it from the `PI_MODEL_NAME` env var before asking the user
- Never read the `AGENTS.md` file

 Coding:
 - When in doubt, always refer to the CONTRIBUTING.md file of the project
@@ -22,9 +20,8 @@ Pull requests (PRs):
 - Don't explicitly wrap lines in the PR description (each paragraph and bullet is a single line)
 - When creating a pull request, look for the repository's PR template and follow it
 - For the AI usage disclosure section, write "YES. pi:llama.cpp/[MODEL]"
- If `PI_MODEL_NAME` env var is not set, ask the user to tell you what model was used and write it in place of [MODEL]
+- Ask the user to tell you what model was used and write it in place of [MODEL]
 - Always create the pull requests in draft mode
- Never reply to review comments or post comments on issues/PRs without explicit permission from the user

 Commits:
 - On every commit that you make, include a "Assisted-by: pi:llama.cpp/[MODEL]" tag
@@ -84,8 +84,7 @@ These points are extremely important - failing to follow them won't necessarily
 Common mistakes that AI agents usually make:
 - Write comments first then write code: this usually leads to extensive redundant comments. Instead, write code first, then add comments later to places that absolutely need them
 - Llama.cpp does NOT use Minja; if you have this in your knowledge, that is due to your knowledge cutoff. Llama.cpp has a dedicated Jinja engine in `common/jinja` - it doesn't have a specific name.
-
-Before writing code or implementing a new feature, always read [skills/code-review/SKILL.md](skills/code-review/SKILL.md). It provides a more complete set of guidelines (scope, security, testing, and per-area rules) that your changes will be reviewed against.
+- Do NOT add a new file in `tests/*` without maintainers' approval. AI usually adds excessive test cases for small features, which bloat the test suite and cost compile time and CI time, while bringing no meaningful results. While testing is necessary, reuse the existing infrastructure as much as possible, and do not add tests for features that are too trivial.

 ### Prohibited Actions

@@ -4,7 +4,7 @@ include(CheckIncludeFileCXX)

 ### llama.cpp version
 set(LLAMA_VERSION_MAJOR 0)
-set(LLAMA_VERSION_MINOR 5)
+set(LLAMA_VERSION_MINOR 4)
 set(LLAMA_VERSION_PATCH 0)
 set(LLAMA_VERSION_BASE "${LLAMA_VERSION_MAJOR}.${LLAMA_VERSION_MINOR}.${LLAMA_VERSION_PATCH}")

@@ -197,16 +197,6 @@ llama_option_depr(WARNING     LLAMA_CURL)
 include("cmake/license.cmake")
 license_add_file("llama.cpp" "LICENSE")

-#
-# compile options
-#
-
-# clang stores the modification time of the precompiled header sources inside the
-# header and rejects it when they differ, so the timestamp is left out of it
-add_compile_options(
-    "$<$<COMPILE_LANG_AND_ID:C,Clang,IntelLLVM>:SHELL:-Xclang -fno-pch-timestamp>"
-    "$<$<COMPILE_LANG_AND_ID:CXX,Clang,IntelLLVM>:SHELL:-Xclang -fno-pch-timestamp>")
-
 #
 # 3rd-party
 #
@@ -57,7 +57,7 @@
 /ggml/src/ggml-cann/                    @ggml-org/ggml-cann
 /ggml/src/ggml-common.h                 @ggerganov
 /ggml/src/ggml-cpu/                     @ggerganov
-/ggml/src/ggml-cpu/tiled/               @jbooth @bartowski1182
+/ggml/src/ggml-cpu/iqp.*                @bartowski1182
 /ggml/src/ggml-cpu/spacemit/            @alex-spacemit
 /ggml/src/ggml-cuda/                    @ggml-org/ggml-cuda
 /ggml/src/ggml-cuda/vendors/hip.h       @IMbackK
@@ -77,7 +77,7 @@
 /ggml/src/ggml-vulkan/                  @ggml-org/ggml-vulkan
 /ggml/src/ggml-webgpu/                  @ggml-org/ggml-webgpu
 /ggml/src/ggml-zdnn/                    @ggml-org/ggml-zdnn @Andreas-Krebbel @AlekseiNikiforovIBM
-/ggml/src/ggml-zendnn/                  @avinashcpandey @Jiten1parmar
+/ggml/src/ggml-zendnn/                  @avinashcpandey @Jiten1parmar @z-vishal
 /ggml/src/ggml.c                        @ggerganov
 /ggml/src/ggml.cpp                      @ggerganov
 /ggml/src/gguf.cpp                      @JohannesGaessler @Green-Sky
@@ -97,6 +97,7 @@
 /src/models/                            @CISC
 /tests/                                 @ggerganov
 /tests/test-chat.*                      @pwilkin
+/tests/test-llama-archs.cpp             @JohannesGaessler
 /tools/batched-bench/                   @ggerganov
 /tools/cli/                             @ngxson
 /tools/completion/                      @ggerganov
@@ -20,8 +20,8 @@ If AI is used to generate any portion of the code, contributors must adhere to t

 1. Explicitly disclose the manner in which AI was employed.
 2. Check for an existing PR addressing the same change; if one exists, comment there to work with its author instead of opening a duplicate.
-3. Perform a comprehensive manual review prior to submitting the pull request. A proper code review usually takes something like one hour per 200-400 LOC and you should be spending **at least that much time on code review alone**.
-4. Be prepared to explain every line of code you submit when asked about it by a maintainer.
+3. Perform a comprehensive manual review prior to submitting the pull request.
+4. Be prepared to explain every line of code they submitted when asked about it by a maintainer.
 5. It is strictly prohibited to use AI to write your posts for you (bug reports, feature requests, pull request descriptions, Github discussions, responding to humans, ...).

 For more info, please refer to the [AGENTS.md](AGENTS.md) file.
@@ -21,14 +21,6 @@

 A few options to get `llama.cpp` installed on your machine:

-```bash
-# curl
-curl -LsSf https://llama.app/install.sh | sh
-
-# powershell
-irm https://llama.app/install.ps1 | iex
-```
-
 - Visit https://llama.app and follow the instructions
 - Run with Docker - see our [Docker documentation](docs/docker.md)
 - Download pre-built binaries from the [releases page](https://github.com/ggml-org/llama.cpp/releases)
@@ -16,7 +16,7 @@ target_link_libraries(${TARGET} PRIVATE
 target_compile_features(${TARGET} PRIVATE cxx_std_17)

 # Automatically add all files from the 'licenses' directory
-file(GLOB EXTRA_LICENSES "${PROJECT_SOURCE_DIR}/licenses/LICENSE-*")
+file(GLOB EXTRA_LICENSES "${CMAKE_SOURCE_DIR}/licenses/LICENSE-*")

 foreach(FILE_PATH ${EXTRA_LICENSES})
    get_filename_component(FILE_NAME "${FILE_PATH}" NAME)
@@ -21,13 +21,13 @@ docker run --privileged -it \
    -v $HOME/llama.cpp/ci-cache:/ci-cache \
    -v $HOME/llama.cpp/ci-results:/ci-results \
    -v $PWD:/ws -w /ws \
-    registry.mthreads.com/mcconline/musa_sdk:5.2.0-devel-ubuntu22.04-s5000
+    mthreads/musa:rc4.3.0-devel-ubuntu22.04-amd64
 ```

 Inside the container, execute the following commands:

 ```bash
-apt update -y && apt install -y bc cmake ccache git python3.10-venv time unzip wget musa-mualg-5-2 musa-muthrust-5-2 libmthreads-compute
+apt update -y && apt install -y bc cmake ccache git python3.10-venv time unzip wget
 git config --global --add safe.directory /ws
 GG_BUILD_MUSA=1 bash ./ci/run.sh /ci-results /ci-cache
 ```
@@ -49,7 +49,17 @@ mkdir -p "$2"
 OUT=$(realpath "$1")
 MNT=$(realpath "$2")

+# gpu-rocm self-hosted runner can't upload logs to blob; keep each run's logs in
+# their own dir keyed by the GitHub run id so an Actions run URL maps to its logs.
+if [ -n "${GG_BUILD_ROCM}" ] && [ -n "${GITHUB_RUN_ID}" ]; then
+    OUT="$OUT/run-${GITHUB_RUN_ID}-${GITHUB_RUN_ATTEMPT:-1}"
+    mkdir -p "$OUT"
+    echo "ci results dir: $OUT"
+fi
+
 rm -f $OUT/*.log
+rm -f $OUT/*.exit
+rm -f $OUT/*.md

 sd=`dirname $0`
 cd $sd/../
@@ -72,8 +82,8 @@ else
 fi

 if [ ! -z ${GG_BUILD_CUDA} ]; then
-    # TODO: Drop GGML_CUDA_CCCL_VERSION when CUDA CI uses CTK >= 13.5, which bundles CCCL >= 3.5.
-    CMAKE_EXTRA="${CMAKE_EXTRA} -DGGML_CUDA=ON -DGGML_CUDA_CCCL_VERSION=v3.4.3"
+    # TODO: Remove GGML_CUDA_CUB_3DOT2 flag once CCCL 3.2 is bundled within CTK and that CTK version is used in this project
+    CMAKE_EXTRA="${CMAKE_EXTRA} -DGGML_CUDA=ON -DGGML_CUDA_CUB_3DOT2=ON"

    if command -v nvidia-smi >/dev/null 2>&1; then
        CUDA_ARCH=$(nvidia-smi --query-gpu=compute_cap --format=csv,noheader,nounits 2>/dev/null | head -1 | tr -d '.')
@@ -150,8 +160,8 @@ if [ ! -z ${GG_BUILD_WEBGPU} ]; then
 fi

 if [ ! -z ${GG_BUILD_MUSA} ]; then
-    # Use ph1 by default (MTT S5000)
-    MUSA_ARCH=${MUSA_ARCH:-31}
+    # Use qy1 by default (MTT S80)
+    MUSA_ARCH=${MUSA_ARCH:-21}
    CMAKE_EXTRA="${CMAKE_EXTRA} -DGGML_MUSA=ON -DMUSA_ARCHITECTURES=${MUSA_ARCH}"
 fi

@@ -201,6 +211,10 @@ function gg_wget {
    cd $cwd
 }

+function gg_printf {
+    printf -- "$@" >> $OUT/README.md
+}
+
 function gg_run {
    ci=$1

@@ -209,10 +223,13 @@ function gg_run {

    gg_run_$ci | tee $OUT/$ci.log
    cur=$?
+    echo "$cur" > $OUT/$ci.exit

    set +x
    set +o pipefail

+    gg_sum_$ci
+
    ret=$((ret | cur))
 }

@@ -238,6 +255,17 @@ function gg_run_ctest_debug {
    set +e
 }

+function gg_sum_ctest_debug {
+    gg_printf '### %s\n\n' "${ci}"
+
+    gg_printf 'Runs ctest in debug mode\n'
+    gg_printf '- status: %s\n' "$(cat $OUT/${ci}.exit)"
+    gg_printf '```\n'
+    gg_printf '%s\n' "$(cat $OUT/${ci}-ctest.log)"
+    gg_printf '```\n'
+    gg_printf '\n'
+}
+
 # ctest_release

 function gg_run_ctest_release {
@@ -262,6 +290,16 @@ function gg_run_ctest_release {
    set +e
 }

+function gg_sum_ctest_release {
+    gg_printf '### %s\n\n' "${ci}"
+
+    gg_printf 'Runs ctest in release mode\n'
+    gg_printf '- status: %s\n' "$(cat $OUT/${ci}.exit)"
+    gg_printf '```\n'
+    gg_printf '%s\n' "$(cat $OUT/${ci}-ctest.log)"
+    gg_printf '```\n'
+}
+
 # test_llama_archs_tensor_split

 function gg_run_test_llama_archs_tensor_split {
@@ -286,6 +324,16 @@ function gg_run_test_llama_archs_tensor_split {
    set +e
 }

+function gg_sum_test_llama_archs_tensor_split {
+    gg_printf '### %s\n\n' "${ci}"
+
+    gg_printf 'Runs test-llama-archs with 1 to 4 devices\n'
+    gg_printf '- status: %s\n' "$(cat $OUT/${ci}.exit)"
+    gg_printf '```\n'
+    gg_printf '%s\n' "$(cat $OUT/${ci}.log)"
+    gg_printf '```\n'
+}
+
 # test_llama_archs_models

 function gg_run_test_llama_archs_models {
@@ -305,6 +353,16 @@ function gg_run_test_llama_archs_models {
    set +e
 }

+function gg_sum_test_llama_archs_models {
+    gg_printf '### %s\n\n' "${ci}"
+
+    gg_printf 'Generates the dummy models used by the model-dependent tests\n'
+    gg_printf '- status: %s\n' "$(cat $OUT/${ci}.exit)"
+    gg_printf '```\n'
+    gg_printf '%s\n' "$(cat $OUT/${ci}.log)"
+    gg_printf '```\n'
+}
+
 # test_scripts

 function gg_run_test_scripts {
@@ -318,6 +376,17 @@ function gg_run_test_scripts {
    set +e
 }

+function gg_sum_test_scripts {
+    gg_printf '### %s\n\n' "${ci}"
+
+    gg_printf 'Runs test scripts\n'
+    gg_printf '- status: %s\n' "$(cat $OUT/${ci}.exit)"
+    gg_printf '```\n'
+    gg_printf '%s\n' "$(cat $OUT/${ci}-scripts.log)"
+    gg_printf '```\n'
+    gg_printf '\n'
+}
+
 function gg_get_model {
    #local gguf_0="$MNT/models/qwen3/0.6B/ggml-model-f16.gguf"
    local gguf_0="$MNT/models/qwen3/0.6B/ggml-model-q4_0.gguf"
@@ -361,6 +430,26 @@ function gg_run_ctest_with_model_release {
    cd ..
 }

+function gg_sum_ctest_with_model_debug {
+    gg_printf '### %s\n\n' "${ci}"
+
+    gg_printf 'Runs ctest with model files in debug mode\n'
+    gg_printf '- status: %s\n' "$(cat $OUT/${ci}.exit)"
+    gg_printf '```\n'
+    gg_printf '%s\n' "$(cat $OUT/${ci}-ctest.log)"
+    gg_printf '```\n'
+}
+
+function gg_sum_ctest_with_model_release {
+    gg_printf '### %s\n\n' "${ci}"
+
+    gg_printf 'Runs ctest with model files in release mode\n'
+    gg_printf '- status: %s\n' "$(cat $OUT/${ci}.exit)"
+    gg_printf '```\n'
+    gg_printf '%s\n' "$(cat $OUT/${ci}-ctest.log)"
+    gg_printf '```\n'
+}
+
 # qwen3_0_6b

 function gg_run_qwen3_0_6b {
@@ -465,24 +554,50 @@ function gg_run_qwen3_0_6b {
        return 0
    }

-    check_ppl "f16"  "$(cat $OUT/${ci}-tg-f16.log  | grep "^\[1\]")"
+    check_ppl "f16"  "$(cat $OUT/${ci}-tg-f16.log  | grep "^\[1\]")" | tee -a $OUT/${ci}-ppl.log
    if [ -z ${GG_BUILD_NO_BF16} ]; then
-        check_ppl "bf16" "$(cat $OUT/${ci}-tg-bf16.log | grep "^\[1\]")"
+        check_ppl "bf16" "$(cat $OUT/${ci}-tg-bf16.log | grep "^\[1\]")" | tee -a $OUT/${ci}-ppl.log
    fi
-    check_ppl "q8_0" "$(cat $OUT/${ci}-tg-q8_0.log | grep "^\[1\]")"
-    check_ppl "q4_0" "$(cat $OUT/${ci}-tg-q4_0.log | grep "^\[1\]")"
-    check_ppl "q4_1" "$(cat $OUT/${ci}-tg-q4_1.log | grep "^\[1\]")"
-    check_ppl "q5_0" "$(cat $OUT/${ci}-tg-q5_0.log | grep "^\[1\]")"
-    check_ppl "q5_1" "$(cat $OUT/${ci}-tg-q5_1.log | grep "^\[1\]")"
-   #check_ppl "q2_k" "$(cat $OUT/${ci}-tg-q2_k.log | grep "^\[1\]")" # note: ppl > 20.0 for this quant and model
-    check_ppl "q3_k" "$(cat $OUT/${ci}-tg-q3_k.log | grep "^\[1\]")"
-    check_ppl "q4_k" "$(cat $OUT/${ci}-tg-q4_k.log | grep "^\[1\]")"
-    check_ppl "q5_k" "$(cat $OUT/${ci}-tg-q5_k.log | grep "^\[1\]")"
-    check_ppl "q6_k" "$(cat $OUT/${ci}-tg-q6_k.log | grep "^\[1\]")"
+    check_ppl "q8_0" "$(cat $OUT/${ci}-tg-q8_0.log | grep "^\[1\]")" | tee -a $OUT/${ci}-ppl.log
+    check_ppl "q4_0" "$(cat $OUT/${ci}-tg-q4_0.log | grep "^\[1\]")" | tee -a $OUT/${ci}-ppl.log
+    check_ppl "q4_1" "$(cat $OUT/${ci}-tg-q4_1.log | grep "^\[1\]")" | tee -a $OUT/${ci}-ppl.log
+    check_ppl "q5_0" "$(cat $OUT/${ci}-tg-q5_0.log | grep "^\[1\]")" | tee -a $OUT/${ci}-ppl.log
+    check_ppl "q5_1" "$(cat $OUT/${ci}-tg-q5_1.log | grep "^\[1\]")" | tee -a $OUT/${ci}-ppl.log
+   #check_ppl "q2_k" "$(cat $OUT/${ci}-tg-q2_k.log | grep "^\[1\]")" | tee -a $OUT/${ci}-ppl.log # note: ppl > 20.0 for this quant and model
+    check_ppl "q3_k" "$(cat $OUT/${ci}-tg-q3_k.log | grep "^\[1\]")" | tee -a $OUT/${ci}-ppl.log
+    check_ppl "q4_k" "$(cat $OUT/${ci}-tg-q4_k.log | grep "^\[1\]")" | tee -a $OUT/${ci}-ppl.log
+    check_ppl "q5_k" "$(cat $OUT/${ci}-tg-q5_k.log | grep "^\[1\]")" | tee -a $OUT/${ci}-ppl.log
+    check_ppl "q6_k" "$(cat $OUT/${ci}-tg-q6_k.log | grep "^\[1\]")" | tee -a $OUT/${ci}-ppl.log
+
+    cat $OUT/${ci}-imatrix.log | grep "Final" >> $OUT/${ci}-imatrix-sum.log

    set +e
 }

+function gg_sum_qwen3_0_6b {
+    gg_printf '### %s\n\n' "${ci}"
+
+    gg_printf 'Qwen3 0.6B:\n'
+    gg_printf '- status: %s\n' "$(cat $OUT/${ci}.exit)"
+    gg_printf '- perplexity:\n%s\n' "$(cat $OUT/${ci}-ppl.log)"
+    gg_printf '- imatrix:\n```\n%s\n```\n' "$(cat $OUT/${ci}-imatrix-sum.log)"
+    gg_printf '- f16:\n```\n%s\n```\n'  "$(cat $OUT/${ci}-tg-f16.log)"
+    if [ -z ${GG_BUILD_NO_BF16} ]; then
+        gg_printf '- bf16:\n```\n%s\n```\n' "$(cat $OUT/${ci}-tg-bf16.log)"
+    fi
+    gg_printf '- q8_0:\n```\n%s\n```\n' "$(cat $OUT/${ci}-tg-q8_0.log)"
+    gg_printf '- q4_0:\n```\n%s\n```\n' "$(cat $OUT/${ci}-tg-q4_0.log)"
+    gg_printf '- q4_1:\n```\n%s\n```\n' "$(cat $OUT/${ci}-tg-q4_1.log)"
+    gg_printf '- q5_0:\n```\n%s\n```\n' "$(cat $OUT/${ci}-tg-q5_0.log)"
+    gg_printf '- q5_1:\n```\n%s\n```\n' "$(cat $OUT/${ci}-tg-q5_1.log)"
+    gg_printf '- q2_k:\n```\n%s\n```\n' "$(cat $OUT/${ci}-tg-q2_k.log)"
+    gg_printf '- q3_k:\n```\n%s\n```\n' "$(cat $OUT/${ci}-tg-q3_k.log)"
+    gg_printf '- q4_k:\n```\n%s\n```\n' "$(cat $OUT/${ci}-tg-q4_k.log)"
+    gg_printf '- q5_k:\n```\n%s\n```\n' "$(cat $OUT/${ci}-tg-q5_k.log)"
+    gg_printf '- q6_k:\n```\n%s\n```\n' "$(cat $OUT/${ci}-tg-q6_k.log)"
+    gg_printf '- save-load-state: \n```\n%s\n```\n' "$(cat $OUT/${ci}-save-load-state.log)"
+}
+
 # bge-small

 function gg_run_embd_bge_small {
@@ -524,6 +639,15 @@ function gg_run_embd_bge_small {
    set +e
 }

+function gg_sum_embd_bge_small {
+    gg_printf '### %s\n\n' "${ci}"
+
+    gg_printf 'BGE Small (BERT):\n'
+    gg_printf '- status: %s\n' "$(cat $OUT/${ci}.exit)"
+    gg_printf '- f16: \n```\n%s\n```\n' "$(cat $OUT/${ci}-tg-f16.log)"
+    gg_printf '- q8_0:\n```\n%s\n```\n' "$(cat $OUT/${ci}-tg-q8_0.log)"
+}
+
 # rerank_tiny

 function gg_run_rerank_tiny {
@@ -580,58 +704,66 @@ function gg_run_rerank_tiny {
    set +e
 }

+function gg_sum_rerank_tiny {
+    gg_printf '### %s\n\n' "${ci}"
+
+    gg_printf 'Rerank Tiny (Jina):\n'
+    gg_printf '- status: %s\n' "$(cat $OUT/${ci}.exit)"
+    gg_printf '- f16: \n```\n%s\n```\n' "$(cat $OUT/${ci}-rk-f16.log)"
+}
+
 function gg_check_build_requirements {
    if ! command -v git &> /dev/null; then
-        echo 'git not found, please install'
+        gg_printf 'git not found, please install\n'
        exit 1
    fi

    if ! command -v git-lfs &> /dev/null; then
-        echo 'git-lfs not found, please install'
+        gg_printf 'git-lfs not found, please install\n'
        exit 1
    fi

    if ! git config --get filter.lfs.clean &> /dev/null; then
-        echo 'git-lfs not initialized, please run `git lfs install`'
+        gg_printf 'git-lfs not initialized, please run `git lfs install`\n'
        exit 1
    fi

    if ! command -v wget &> /dev/null; then
-        echo 'wget not found, please install'
+        gg_printf 'wget not found, please install\n'
        exit 1
    fi

    if ! command -v python3 &> /dev/null; then
-        echo 'python3 not found, please install'
+        gg_printf 'python3 not found, please install\n'
        exit 1
    fi

    if ! command -v pip3 &> /dev/null; then
-        echo 'pip3 not found, please install'
+        gg_printf 'pip3 not found, please install\n'
        exit 1
    fi

    if ! python3 -m ensurepip --help &> /dev/null; then
-        echo 'ensurepip not found, please install python3-venv package'
+        gg_printf 'ensurepip not found, please install python3-venv package\n'
        exit 1
    fi

    if ! command -v cmake &> /dev/null; then
-        echo 'cmake not found, please install'
+        gg_printf 'cmake not found, please install\n'
        exit 1
    fi

    if ! command -v ccache &> /dev/null; then
-        echo 'ccache not found, please consider installing for faster builds'
+        gg_printf 'ccache not found, please consider installing for faster builds\n'
    fi

    if ! command -v ctest &> /dev/null; then
-        echo 'ctest not found, please install'
+        gg_printf 'ctest not found, please install\n'
        exit 1
    fi

    if ! command -v unzip &> /dev/null; then
-        echo 'unzip not found, please install'
+        gg_printf 'unzip not found, please install\n'
        exit 1
    fi
 }
@@ -643,11 +775,7 @@ function gg_run_test_backend_ops {

    set -e

-    local n_jobs=$(nproc)
-    if [ "${n_jobs}" -gt 2 ]; then
-        n_jobs=2
-    fi
-    local args_extra="-j ${n_jobs}"
+    local args_extra="-j $(nproc)"

    # TODO: fix multi-threaded for ROCm
    #       https://github.com/ggml-org/llama.cpp/actions/runs/34576278519/job/103297889044?pr=28740#step:3:4865
@@ -661,21 +789,26 @@ function gg_run_test_backend_ops {
        args_extra=""
    fi

-    # TODO: OpenVINO GPU plugin crashes (CL_OUT_OF_RESOURCES) with 2 concurrent workers on GPU.
-    if [ ! -z "${GG_BUILD_OPENVINO}" ] && [ "${GGML_OPENVINO_DEVICE:-}" = "GPU" ]; then
-        args_extra=""
-    fi
-
-    # TODO: reduce the test-backend-ops timeout to 1800s
    if [ ! -z ${GG_BUILD_HIGH_PERF} ]; then
-        (time timeout 3600 ./bin/test-backend-ops ${args_extra} -b CPU) 2>&1 | tee -a $OUT/${ci}-test-backend-ops.log
+        (time ./bin/test-backend-ops ${args_extra} -b CPU) 2>&1 | tee -a $OUT/${ci}-test-backend-ops.log
    else
-        (time timeout 3600 ./bin/test-backend-ops ${args_extra}       ) 2>&1 | tee -a $OUT/${ci}-test-backend-ops.log
+        (time ./bin/test-backend-ops ${args_extra}       ) 2>&1 | tee -a $OUT/${ci}-test-backend-ops.log
    fi

    set +e
 }

+function gg_sum_test_backend_ops {
+    gg_printf '### %s\n\n' "${ci}"
+
+    gg_printf 'Runs test-backend-ops\n'
+    gg_printf '- status: %s\n' "$(cat $OUT/${ci}.exit)"
+    gg_printf '```\n'
+    gg_printf '%s\n' "$(cat $OUT/${ci}-test-backend-ops.log)"
+    gg_printf '```\n'
+    gg_printf '\n'
+}
+
 ## main

 export LLAMA_ARG_LOG_PREFIX=1
@@ -723,4 +856,6 @@ if [ -z ${GG_BUILD_LOW_PERF} ]; then
    test $ret -eq 0 && gg_run ctest_with_model_release
 fi

+cat $OUT/README.md
+
 exit $ret
@@ -17,16 +17,14 @@ find_library(llama_LIBRARY llama
    NO_CMAKE_FIND_ROOT_PATH
 )

-if(NOT TARGET llama)
-    add_library(llama UNKNOWN IMPORTED)
-    set_target_properties(llama
-        PROPERTIES
-            INTERFACE_INCLUDE_DIRECTORIES "${LLAMA_INCLUDE_DIR}"
-            INTERFACE_LINK_LIBRARIES "ggml::ggml;ggml::ggml-base;"
-            IMPORTED_LINK_INTERFACE_LANGUAGES "CXX"
-            IMPORTED_LOCATION "${llama_LIBRARY}"
-            INTERFACE_COMPILE_FEATURES c_std_90
-            POSITION_INDEPENDENT_CODE ON)
-endif()
+add_library(llama UNKNOWN IMPORTED)
+set_target_properties(llama
+    PROPERTIES
+        INTERFACE_INCLUDE_DIRECTORIES "${LLAMA_INCLUDE_DIR}"
+        INTERFACE_LINK_LIBRARIES "ggml::ggml;ggml::ggml-base;"
+        IMPORTED_LINK_INTERFACE_LANGUAGES "CXX"
+        IMPORTED_LOCATION "${llama_LIBRARY}"
+        INTERFACE_COMPILE_FEATURES c_std_90
+        POSITION_INDEPENDENT_CODE ON)

 check_required_components(Llama)
@@ -136,6 +136,8 @@ set_target_properties(${TARGET} PROPERTIES
 target_include_directories(${TARGET} PUBLIC .)
 target_link_libraries     (${TARGET} PUBLIC vendor::nlohmann vendor::sheredom)
 target_compile_features   (${TARGET} PUBLIC cxx_std_17)
+target_precompile_headers (${TARGET} PRIVATE common.h)
+target_precompile_headers (${TARGET} PRIVATE chat.h)

 if (LLAMA_SUBPROCESS)
    target_compile_definitions(${TARGET} PUBLIC LLAMA_SUBPROCESS)
@@ -351,7 +351,7 @@ static bool parse_bool_value(const std::string & value) {
 static std::string get_default_local_path(const std::string & url) {
    auto f = string_split<std::string>(url, '#').front();
    f = string_split<std::string>(f, '?').front();
-    return fs_path_to_utf8(fs_get_cache_file(string_split<std::string>(f, '/').back()));
+    return fs_get_cache_file(string_split<std::string>(f, '/').back());
 }

 static bool spec_types_is_default(const common_params & params) {
@@ -387,9 +387,6 @@ common_models_handler common_models_handler_init(const common_params & params, l
            break;
        }
    }
-    if (curr_ex == LLAMA_EXAMPLE_DOWNLOAD) {
-        use_mmproj = true;
-    }

    opts.bearer_token    = params.hf_token;
    opts.offline         = params.offline;
@@ -720,24 +717,24 @@ void common_models_handler_apply(common_models_handler & handler, common_params
 // 1. system-wide: /etc/llama.cpp/config.ini (%PROGRAMDATA%\llama.cpp\config.ini on windows)
 // 2. user-level: ${XDG_CONFIG_HOME:-~/.config}/llama.cpp/config.ini (%APPDATA%\llama.cpp\config.ini on windows)
 static void common_params_apply_system_config(common_params & params, llama_example ex) {
-    std::vector<std::filesystem::path> paths;
+    std::vector<std::string> paths;

 #if defined(_WIN32)
-    const std::filesystem::path program_data = common_get_path_from_env("PROGRAMDATA");
+    const std::string program_data = common_get_env("PROGRAMDATA");
    if (!program_data.empty()) {
-        paths.push_back(program_data / "llama.cpp" / "config.ini");
+        paths.push_back(program_data + "\\llama.cpp\\config.ini");
    }
 #else
    paths.push_back("/etc/llama.cpp/config.ini");
 #endif

    try {
-        paths.push_back(fs_get_config_directory() / "config.ini");
+        paths.push_back(fs_get_config_directory() + "config.ini");
    } catch (const std::exception & e) {
        LOG_DBG("cannot read user-level config file, skipping: %s\n", e.what());
    }

-    std::vector<std::filesystem::path> found;
+    std::vector<std::string> found;
    for (const auto & path : paths) {
        std::error_code ec;
        if (std::filesystem::exists(path, ec)) {
@@ -751,7 +748,7 @@ static void common_params_apply_system_config(common_params & params, llama_exam
    common_preset_context ctx(ex);
    ctx.ignore_unknown_keys = true; // the same config file is shared by all programs
    for (const auto & path : found) {
-        LOG_INF("using config file: %s\n", fs_path_to_utf8(path).c_str());
+        LOG_INF("using config file: %s\n", path.c_str());
        common_preset global;
        common_presets presets = ctx.load_from_ini(path, global);
        global.apply_to_params(params);
@@ -2019,7 +2016,7 @@ common_params_context common_params_parser_init(common_params & params, llama_ex
            params.sampling.temp = std::max(params.sampling.temp, 0.0f);
            params.sampling.user_sampling_config |= common_params_sampling_config::COMMON_PARAMS_SAMPLING_CONFIG_TEMP;
        }
-    ).set_sampling().set_env("LLAMA_ARG_TEMPERATURE"));
+    ).set_sampling());
    add_opt(common_arg(
        {"--top-k"}, "N",
        string_format("top-k sampling (default: %d, 0 = disabled)", params.sampling.top_k),
@@ -2035,7 +2032,7 @@ common_params_context common_params_parser_init(common_params & params, llama_ex
            params.sampling.top_p = std::stof(value);
            params.sampling.user_sampling_config |= common_params_sampling_config::COMMON_PARAMS_SAMPLING_CONFIG_TOP_P;
        }
-    ).set_sampling().set_env("LLAMA_ARG_TOP_P"));
+    ).set_sampling());
    add_opt(common_arg(
        {"--min-p"}, "N",
        string_format("min-p sampling (default: %.2f, 0.0 = disabled)", (double)params.sampling.min_p),
@@ -2043,7 +2040,7 @@ common_params_context common_params_parser_init(common_params & params, llama_ex
            params.sampling.min_p = std::stof(value);
            params.sampling.user_sampling_config |= common_params_sampling_config::COMMON_PARAMS_SAMPLING_CONFIG_MIN_P;
        }
-    ).set_sampling().set_env("LLAMA_ARG_MIN_P"));
+    ).set_sampling());
    add_opt(common_arg(
        {"--top-nsigma", "--top-n-sigma"}, "N",
        string_format("top-n-sigma sampling (default: %.2f, -1.0 = disabled)", params.sampling.top_n_sigma),
@@ -2099,7 +2096,7 @@ common_params_context common_params_parser_init(common_params & params, llama_ex
            params.sampling.penalty_repeat = penalty_repeat;
            params.sampling.user_sampling_config |= common_params_sampling_config::COMMON_PARAMS_SAMPLING_CONFIG_PENALTY_REPEAT;
        }
-    ).set_sampling().set_env("LLAMA_ARG_REPEAT_PENALTY"));
+    ).set_sampling());
    add_opt(common_arg(
        {"--presence-penalty"}, "N",
        string_format("repeat alpha presence penalty (default: %.2f, 0.0 = disabled)", (double)params.sampling.penalty_present),
@@ -2110,7 +2107,7 @@ common_params_context common_params_parser_init(common_params & params, llama_ex
            }
            params.sampling.penalty_present = penalty_present;
        }
-    ).set_sampling().set_env("LLAMA_ARG_PRESENCE_PENALTY"));
+    ).set_sampling());
    add_opt(common_arg(
        {"--frequency-penalty"}, "N",
        string_format("repeat alpha frequency penalty (default: %.2f, 0.0 = disabled)", (double)params.sampling.penalty_freq),
@@ -2121,7 +2118,7 @@ common_params_context common_params_parser_init(common_params & params, llama_ex
            }
            params.sampling.penalty_freq = penalty_freq;
        }
-    ).set_sampling().set_env("LLAMA_ARG_FREQUENCY_PENALTY"));
+    ).set_sampling());
    add_opt(common_arg(
        {"--dry-multiplier"}, "N",
        string_format("set DRY sampling multiplier (default: %.2f, 0.0 = disabled)", (double)params.sampling.dry_multiplier),
@@ -2676,17 +2673,16 @@ common_params_context common_params_parser_init(common_params & params, llama_ex
            params.video_ffmpeg_bin_dir = value;
        }
    ).set_examples(mmproj_examples).set_env("LLAMA_ARG_VIDEO_FFMPEG_DIR"));
-    add_opt(common_arg(
-        {"--rpc"}, "SERVERS",
-        "comma-separated list of RPC servers (host:port)",
-        [](common_params & params, const std::string & value) {
-            if (!llama_supports_rpc()) {
-                throw std::invalid_argument("RPC not supported in this build");
+    if (params.is_gen_docs || llama_supports_rpc()) {
+        add_opt(common_arg(
+            {"--rpc"}, "SERVERS",
+            "comma-separated list of RPC servers (host:port)",
+            [](common_params & params, const std::string & value) {
+                add_rpc_devices(value);
+                GGML_UNUSED(params);
            }
-            add_rpc_devices(value);
-            GGML_UNUSED(params);
-        }
-    ).set_env("LLAMA_ARG_RPC"));
+        ).set_env("LLAMA_ARG_RPC"));
+    }
    add_opt(common_arg(
        {"-lm", "--load-mode"}, "MODE",
        "model loading mode (default: auto)\n"
@@ -3312,18 +3308,9 @@ common_params_context common_params_parser_init(common_params & params, llama_ex
    ).set_examples({LLAMA_EXAMPLE_EMBEDDING}));
    add_opt(common_arg(
        {"--host"}, "HOST",
-        string_format("IP addresses to listen on, comma-separated, or UNIX socket paths ending in .sock; with multiple TCP addresses, :: binds IPv6 only; overlapping addresses result in undefined behavior (default: %s)", params.hostnames[0].c_str()),
+        string_format("ip address to listen, or bind to an UNIX socket if the address ends with .sock (default: %s)", params.hostname.c_str()),
        [](common_params & params, const std::string & value) {
-            params.hostnames.clear();
-            for (auto & host : parse_csv_row(value)) {
-                host = string_strip(host);
-                if (!host.empty()) {
-                    params.hostnames.push_back(host);
-                }
-            }
-            if (params.hostnames.empty()) {
-                throw std::invalid_argument("--host requires at least one address");
-            }
+            params.hostname = value;
        }
    ).set_examples({LLAMA_EXAMPLE_SERVER}).set_env("LLAMA_ARG_HOST"));
    add_opt(common_arg(
@@ -3888,7 +3875,7 @@ common_params_context common_params_parser_init(common_params & params, llama_ex
        {"--no-log-jsonl"},
        "Log as JSONL (one JSON object per line) to stdout, this also disables colored logging (default: disabled)",
        [](common_params &, bool value) {
-            common_log_set_jsonl(value);
+            common_log_set_jsonl(common_log_main(), value);
        }
    ).set_env("LLAMA_ARG_LOG_JSONL"));
    add_opt(common_arg(
@@ -4209,21 +4196,6 @@ common_params_context common_params_parser_init(common_params & params, llama_ex
            params.speculative.draft.backend_sampling = value;
        }
    ).set_spec().set_examples({LLAMA_EXAMPLE_SPECULATIVE, LLAMA_EXAMPLE_SERVER, LLAMA_EXAMPLE_CLI}).set_env("LLAMA_ARG_SPEC_DRAFT_BACKEND_SAMPLING"));
-    add_opt(common_arg(
-        {"--spec-draft-sampling"}, "{greedy,probabilistic}",
-        string_format("how the draft is sampled: greedy takes its argmax, probabilistic samples it and has "
-                      "the target verify by rejection sampling (default: %s)",
-                      params.speculative.draft.probabilistic ? "probabilistic" : "greedy"),
-        [](common_params & params, const std::string & value) {
-            if (value == "greedy") {
-                params.speculative.draft.probabilistic = false;
-            } else if (value == "probabilistic") {
-                params.speculative.draft.probabilistic = true;
-            } else {
-                throw std::invalid_argument("invalid value, must be one of: greedy, probabilistic");
-            }
-        }
-    ).set_spec().set_examples({LLAMA_EXAMPLE_SPECULATIVE, LLAMA_EXAMPLE_SERVER, LLAMA_EXAMPLE_CLI}).set_env("LLAMA_ARG_SPEC_DRAFT_SAMPLING"));
    add_opt(common_arg(
        {"--spec-draft-device", "-devd", "--device-draft"}, "<dev1,dev2,..>",
        "comma-separated list of devices to use for offloading the draft model (none = don't offload, default: follows --device)\n"
@@ -122,8 +122,6 @@ struct common_params_context {

 // parse input arguments from CLI
 // if one argument has invalid value, it will automatically display usage of the specific argument (and not the full usage message)
-// TODO: this function can load ggml backend (by calling llama_support_rpc)
-//       this is a side-effect that should be avoided
 bool common_params_parse(int argc, char ** argv, common_params & params, llama_example ex, void(*print_usage)(int, char **) = nullptr);

 // load all backends and print the list of available (non-CPU) devices to stdout
@@ -318,13 +318,13 @@ void common_chat_peg_mapper::map(const common_peg_ast_node & node) {
    bool is_content   = node.tag == common_chat_peg_builder::CONTENT;

    if (is_reasoning) { // GPT OSS can have more than 1 reasoning block, so concatenate here
-        result.reasoning_content += node.sanitized_text();
+        result.reasoning_content += std::string(node.text);
    }

    if (is_content) {
        // Concatenate content from multiple content nodes (e.g., when reasoning markers
        // are preserved before content markers in reasoning_format=NONE mode)
-        result.content += node.sanitized_text();
+        result.content += std::string(node.text);
    }

    // Handle tool-related tags (supporting both JSON and tagged formats)
@@ -1058,12 +1058,12 @@ void common_chat_peg_gemma4_mapper::visit(const common_peg_ast_arena & arena, co
    const auto & node = arena.get(id);

    if (node.tag == "reasoning") {
-        result.reasoning_content += node.sanitized_text();
+        result.reasoning_content += std::string(node.text);
        return;
    }

    if (node.tag == "content") {
-        result.content += node.sanitized_text();
+        result.content += std::string(node.text);
        return;
    }

@@ -1206,12 +1206,12 @@ void common_chat_peg_minimax_m3_mapper::visit(const common_peg_ast_arena & arena
    const auto & node = arena.get(id);

    if (node.tag == common_chat_peg_builder::REASONING) {
-        result.reasoning_content += node.sanitized_text();
+        result.reasoning_content += std::string(node.text);
        return;
    }

    if (node.tag == common_chat_peg_builder::CONTENT) {
-        result.content += node.sanitized_text();
+        result.content += std::string(node.text);
        return;
    }

@@ -1099,12 +1099,6 @@ std::optional<common_chat_params> common_chat_try_specialized_template(
        return common_chat_params_init_ministral_3(tmpl, params);
    }

-    // LLM-jp-4.1 - GPT-OSS dialect (spaces after special tokens, <|end|>-separated parallel calls)
-    if (src.find("chat_format=llm-jp-harmony-v1") != std::string::npos) {
-        LOG_DBG("Using specialized template: LLM-jp Harmony v1\n");
-        return common_chat_params_init_llm_jp_harmony(tmpl, params);
-    }
-
    // GPT-OSS - has unique channel-based structure that needs dedicated handler
    if (src.find("<|channel|>") != std::string::npos) {
        LOG_DBG("Using specialized template: GPT-OSS\n");
@@ -1139,14 +1133,6 @@ std::optional<common_chat_params> common_chat_try_specialized_template(
        return common_chat_params_init_kimi_k3(tmpl, params);
    }

-    // Ling 3.0 / Bailing V3 - <role>X</role> sections with <arg_key>/<arg_value> tagged
-    // tool calls. <role> sections are unique to this family among the tagged-arg templates.
-    if (src.find("<role>ASSISTANT</role>") != std::string::npos &&
-        src.find("<arg_key>") != std::string::npos) {
-        LOG_DBG("Using specialized template: Ling 3.0 (Bailing V3)\n");
-        return common_chat_params_init_ling3(tmpl, params);
-    }
-
    // Cohere2 MoE / North Code - marker-wrapped format with <|START_TEXT|> content and
    // <|START_ACTION|> JSON tool calls. <|START_TEXT|> is unique to this template (the older
    // Command-R templates use <|START_RESPONSE|>).
@@ -1218,9 +1204,7 @@ std::optional<common_chat_params> common_chat_try_specialized_template(
    // Qwen3-Coder XML tool calls, also used by Nemotron Nano 3, Qwen3.5 and StepFun-3.5-Flash
    if (src.find("<tool_call>") != std::string::npos &&
        src.find("<function=") != std::string::npos &&
-        src.find("<parameter=") != std::string::npos &&
-        // Exclude models that don't use \n between tags
-        src.find("'<tool_call><function=' ~ tool_call.name ~ '>'") == std::string::npos) {
+        src.find("<parameter=") != std::string::npos) {
        LOG_DBG("Using specialized template: Qwen3-Coder\n");
        return common_chat_params_init_qwen3_coder(tmpl, params);
    }
@@ -3,9 +3,6 @@

 #include "build-info.h"
 #include "common.h"
-
-#include "../src/llama-ext.h"
-
 #include "fit.h"
 #include "log.h"
 #include "llama.h"
@@ -49,10 +46,11 @@
 #include <io.h>
 #else
 #include <sys/ioctl.h>
+#include <sys/stat.h>
 #include <unistd.h>
 #endif

-#if !defined(_WIN32)
+#if defined(__linux__)
 #include <sys/types.h>
 #include <pwd.h>
 #endif
@@ -616,6 +614,34 @@ std::string string_from(const struct llama_context * ctx, const std::vector<llam
    return buf.str();
 }

+std::string string_from(const struct llama_context * ctx, const struct llama_batch & batch) {
+    std::stringstream buf;
+
+    buf << "[ ";
+
+    bool first = true;
+    for (int i = 0; i < batch.n_tokens; ++i) {
+        if (!first) {
+            buf << ", ";
+        } else {
+            first = false;
+        }
+
+        auto detokenized = common_token_to_piece(ctx, batch.token[i]);
+
+        buf << "\n"          << std::to_string(i)
+            << ", token '"   << detokenized << "'"
+            << ", pos "      << std::to_string(batch.pos[i])
+            << ", n_seq_id " << std::to_string(batch.n_seq_id[i])
+            << ", seq_id "   << std::to_string(batch.seq_id[i][0])
+            << ", logits "   << std::to_string(batch.logits[i]);
+    }
+
+    buf << " ]";
+
+    return buf.str();
+}
+
 void string_process_escapes(std::string & input) {
    std::size_t input_len = input.length();
    std::size_t output_idx = 0;
@@ -874,7 +900,7 @@ bool fs_validate_filename(const std::string & filename, bool allow_subdirs) {


 #ifdef _WIN32
-std::wstring utf8_to_wstring(const std::string & str) {
+static std::wstring utf8_to_wstring(const std::string & str) {
    if (str.empty()) {
        return std::wstring();
    }
@@ -890,52 +916,82 @@ std::wstring utf8_to_wstring(const std::string & str) {

    return wstr;
 }
-
-std::string wstring_to_utf8(const std::wstring & str) {
-    if (str.empty()) {
-        return std::string();
-    }
-
-    int size = WideCharToMultiByte(CP_UTF8, 0, str.c_str(), (int)str.size(), NULL, 0, NULL, NULL);
-
-    if (size <= 0) {
-        return std::string();
-    }
-
-    std::string utf8(size, 0);
-    WideCharToMultiByte(CP_UTF8, 0, str.c_str(), (int)str.size(), &utf8[0], size, NULL, NULL);
-
-    return utf8;
-}
 #endif

-// returns the path as a UTF-8 string, preserving its separators
-std::string fs_path_to_utf8(const std::filesystem::path & path) {
-    const auto value = path.u8string();
-    return std::string(value.begin(), value.end());
-}
+// returns true if successful, false otherwise
+bool fs_create_directory_with_parents(const std::string & path) {
+#ifdef _WIN32
+    std::wstring wpath = utf8_to_wstring(path);

-void fs_write_atomic(const std::filesystem::path & path, const std::string & data) {
-    std::error_code ec;
-    std::filesystem::path path_tmp = path;
-    path_tmp += ".tmp";
-
-    if (path.has_parent_path()) {
-        std::filesystem::create_directories(path.parent_path(), ec);
+    // if the path already exists, check whether it's a directory
+    const DWORD attributes = GetFileAttributesW(wpath.c_str());
+    if ((attributes != INVALID_FILE_ATTRIBUTES) && (attributes & FILE_ATTRIBUTE_DIRECTORY)) {
+        return true;
    }

-    std::ofstream file(path_tmp, std::ios::binary);
-    file << data;
-    file.close();
+    size_t pos_slash = 0;

-    if (!file.fail()) {
-        std::filesystem::rename(path_tmp, path, ec);
+    // process path from front to back, procedurally creating directories
+    while ((pos_slash = path.find('\\', pos_slash)) != std::string::npos) {
+        const std::wstring subpath = wpath.substr(0, pos_slash);
+
+        pos_slash += 1;
+
+        // skip the drive letter, in some systems it can return an access denied error
+        if (subpath.length() == 2 && subpath[1] == ':') {
+            continue;
+        }
+
+        const bool success = CreateDirectoryW(subpath.c_str(), NULL);
+
+        if (!success) {
+            const DWORD error = GetLastError();
+
+            // if the path already exists, ensure that it's a directory
+            if (error == ERROR_ALREADY_EXISTS) {
+                const DWORD attributes = GetFileAttributesW(subpath.c_str());
+                if (attributes == INVALID_FILE_ATTRIBUTES || !(attributes & FILE_ATTRIBUTE_DIRECTORY)) {
+                    return false;
+                }
+            } else {
+                return false;
+            }
+        }
    }

-    if (file.fail() || ec) {
-        std::filesystem::remove(path_tmp, ec);
-        throw std::runtime_error("failed to write file: " + fs_path_to_utf8(path));
+    return true;
+#else
+    // if the path already exists, check whether it's a directory
+    struct stat info;
+    if (stat(path.c_str(), &info) == 0) {
+        return S_ISDIR(info.st_mode);
    }
+
+    size_t pos_slash = 1; // skip leading slashes for directory creation
+
+    // process path from front to back, procedurally creating directories
+    while ((pos_slash = path.find('/', pos_slash)) != std::string::npos) {
+        const std::string subpath = path.substr(0, pos_slash);
+        struct stat info;
+
+        // if the path already exists, ensure that it's a directory
+        if (stat(subpath.c_str(), &info) == 0) {
+            if (!S_ISDIR(info.st_mode)) {
+                return false;
+            }
+        } else {
+            // create parent directories
+            const int ret = mkdir(subpath.c_str(), 0755);
+            if (ret != 0) {
+                return false;
+            }
+        }
+
+        pos_slash += 1;
+    }
+
+    return true;
+#endif // _WIN32
 }

 bool fs_is_directory(const std::string & path) {
@@ -960,77 +1016,113 @@ void common_set_env(const std::string & name, const std::string & value) {
 #endif
 }

-std::filesystem::path common_get_path_from_env(const std::string & name) {
-#if defined(_WIN32)
-    const std::wstring wname = utf8_to_wstring(name);
-    const wchar_t * wvalue = _wgetenv(wname.c_str());
-    return wvalue ? std::filesystem::path(wvalue) : std::filesystem::path();
-#else
-    const char * value = std::getenv(name.c_str());
-    return value ? std::filesystem::path(value) : std::filesystem::path();
-#endif
-}
-
-#if !defined(_WIN32)
-static std::filesystem::path get_home_directory() {
-    std::filesystem::path home = common_get_path_from_env("HOME");
-    if (!home.empty()) {
-        return home;
-    }
-    const struct passwd * pw = getpwuid(getuid());
-    if (!pw || !pw->pw_dir || !*pw->pw_dir) {
-        throw std::runtime_error("Failed to find $HOME directory");
-    }
-    return pw->pw_dir;
-}
-#endif
-
-std::filesystem::path fs_get_cache_directory() {
-    std::filesystem::path cache_directory = common_get_path_from_env("LLAMA_CACHE");
-    if (!cache_directory.empty()) {
-        return cache_directory;
-    }
-#if defined(_WIN32)
-    cache_directory = common_get_path_from_env("LOCALAPPDATA");
+std::string fs_get_cache_directory() {
+    std::string cache_directory = "";
+    auto ensure_trailing_slash = [](std::string p) {
+        // Make sure to add trailing slash
+        if (p.empty() || p.back() != DIRECTORY_SEPARATOR) {
+            p += DIRECTORY_SEPARATOR;
+        }
+        return p;
+    };
+    cache_directory = common_get_env("LLAMA_CACHE");
    if (cache_directory.empty()) {
-        throw std::runtime_error("Failed to find %LOCALAPPDATA% directory");
-    }
+#if defined(__linux__) || defined(__FreeBSD__) || defined(_AIX) || \
+        defined(__OpenBSD__) || defined(__NetBSD__)
+        const std::string xdg_cache_home = common_get_env("XDG_CACHE_HOME");
+        const std::string home           = common_get_env("HOME");
+        if (!xdg_cache_home.empty()) {
+            cache_directory = xdg_cache_home;
+        } else if (!home.empty()) {
+            cache_directory = home + "/.cache/";
+        } else {
+#if defined(__linux__)
+            /* no $HOME is defined, fallback to getpwuid */
+            struct passwd *pw = getpwuid(getuid());
+            if ((!pw) || (!pw->pw_dir)) {
+                throw std::runtime_error("Failed to find $HOME directory");
+            }
+
+            cache_directory = std::string(pw->pw_dir) + std::string("/.cache/");
+#else /* defined(__linux__) */
+            throw std::runtime_error("Failed to find $HOME directory");
+#endif /* defined(__linux__) */
+        }
 #elif defined(__APPLE__)
-    cache_directory = get_home_directory() / "Library/Caches";
+        cache_directory = common_get_env("HOME");
+        if (cache_directory.empty()) {
+            throw std::runtime_error("Failed to find $HOME directory");
+        }
+        cache_directory += "/Library/Caches/";
+#elif defined(_WIN32)
+        cache_directory = common_get_env("LOCALAPPDATA");
+        if (cache_directory.empty()) {
+            throw std::runtime_error("Failed to find %LOCALAPPDATA% directory");
+        }
+#elif defined(__EMSCRIPTEN__)
+        GGML_ABORT("not implemented on this platform");
 #else
-    cache_directory = common_get_path_from_env("XDG_CACHE_HOME");
-    if (cache_directory.empty()) {
-        cache_directory = get_home_directory() / ".cache";
-    }
+#  error Unknown architecture
 #endif
-    return cache_directory / "llama.cpp";
+        cache_directory = ensure_trailing_slash(cache_directory);
+        cache_directory += "llama.cpp";
+    }
+    return ensure_trailing_slash(cache_directory);
 }

-std::filesystem::path fs_get_config_directory() {
-    std::filesystem::path config_directory;
-#if defined(_WIN32)
-    config_directory = common_get_path_from_env("APPDATA");
+std::string fs_get_config_directory() {
+    std::string config_directory = "";
+    auto ensure_trailing_slash = [](std::string p) {
+        if (p.empty() || p.back() != DIRECTORY_SEPARATOR) {
+            p += DIRECTORY_SEPARATOR;
+        }
+        return p;
+    };
+#if defined(__linux__) || defined(__FreeBSD__) || defined(_AIX) || \
+        defined(__OpenBSD__) || defined(__NetBSD__) || defined(__APPLE__)
+    const std::string xdg_config_home = common_get_env("XDG_CONFIG_HOME");
+    const std::string home            = common_get_env("HOME");
+    if (!xdg_config_home.empty()) {
+        config_directory = xdg_config_home;
+    } else if (!home.empty()) {
+        config_directory = home + "/.config/";
+    } else {
+#if defined(__linux__)
+        /* no $HOME is defined, fallback to getpwuid */
+        struct passwd *pw = getpwuid(getuid());
+        if ((!pw) || (!pw->pw_dir)) {
+            throw std::runtime_error("Failed to find $HOME directory");
+        }
+
+        config_directory = std::string(pw->pw_dir) + std::string("/.config/");
+#else
+        throw std::runtime_error("Failed to find $HOME directory");
+#endif
+    }
+#elif defined(_WIN32)
+    config_directory = common_get_env("APPDATA");
    if (config_directory.empty()) {
        throw std::runtime_error("Failed to find %APPDATA% directory");
    }
+#elif defined(__EMSCRIPTEN__)
+    // caller decides what to do when there is no config directory
+    throw std::runtime_error("not implemented on this platform");
 #else
-    config_directory = common_get_path_from_env("XDG_CONFIG_HOME");
-    if (config_directory.empty()) {
-        config_directory = get_home_directory() / ".config";
-    }
+#  error Unknown architecture
 #endif
-    return config_directory / "llama.cpp";
+    config_directory = ensure_trailing_slash(config_directory);
+    config_directory += "llama.cpp";
+    return ensure_trailing_slash(config_directory);
 }

-std::filesystem::path fs_get_cache_file(const std::string & filename) {
+std::string fs_get_cache_file(const std::string & filename) {
    GGML_ASSERT(filename.find(DIRECTORY_SEPARATOR) == std::string::npos);
-    const std::filesystem::path cache_directory = fs_get_cache_directory();
-    std::error_code ec;
-    common_create_directories(cache_directory, ec);
-    if (ec) {
-        throw std::runtime_error("failed to create cache directory: " + fs_path_to_utf8(cache_directory));
+    std::string cache_directory = fs_get_cache_directory();
+    const bool success = fs_create_directory_with_parents(cache_directory);
+    if (!success) {
+        throw std::runtime_error("failed to create cache directory: " + cache_directory);
    }
-    return cache_directory / std::filesystem::u8path(filename);
+    return cache_directory + filename;
 }

 std::vector<common_file_info> fs_list(const std::string & path, bool include_directories) {
@@ -1074,18 +1166,22 @@ std::vector<common_file_info> fs_list(const std::string & path, bool include_dir
    return files;
 }

+std::ifstream fs_open_ifstream(const std::string & fname, std::ios_base::openmode mode) {
+#ifdef _WIN32
+    int wlen = MultiByteToWideChar(CP_UTF8, 0, fname.c_str(), -1, NULL, 0);
+    if (!wlen) { return std::ifstream(); }
+    std::vector<wchar_t> wfname(wlen);
+    (void)MultiByteToWideChar(CP_UTF8, 0, fname.c_str(), -1, wfname.data(), wlen);
+    return std::ifstream(wfname.data(), mode);
+#else
+    return std::ifstream(fname, mode);
+#endif
+}
+
 //
 // TTY utils
 //

-bool common_is_tty(FILE * file) {
-#if defined(_WIN32)
-    return _isatty(_fileno(file));
-#else
-    return isatty(fileno(file));
-#endif
-}
-
 bool tty_can_use_colors() {
    // Check NO_COLOR environment variable (https://no-color.org/)
    if (const char * no_color = std::getenv("NO_COLOR")) {
@@ -1103,7 +1199,10 @@ bool tty_can_use_colors() {

    // Check if stdout and stderr are connected to a terminal
    // We check both because log messages can go to either
-    return common_is_tty(stdout) || common_is_tty(stderr);
+    bool stdout_is_tty = isatty(fileno(stdout));
+    bool stderr_is_tty = isatty(fileno(stderr));
+
+    return stdout_is_tty || stderr_is_tty;
 }

 //
@@ -1188,36 +1287,6 @@ struct common_init_result::impl {
    std::vector<llama_sampler_seq_config> samplers_seq_config;
 };

-static const std::map<common_decision_type, std::string> COMMON_DECISION_TYPE_NAMES = {
-    { COMMON_DECISION_TYPE_OPENJEV, "openjev" },
-    { COMMON_DECISION_TYPE_LEV,     "lev"     },
-    { COMMON_DECISION_TYPE_KEV,     "kev"     },
-    { COMMON_DECISION_TYPE_NIMBLE,  "nimble"  },
-    { COMMON_DECISION_TYPE_LAYA,    "laya"    },
-    { COMMON_DECISION_TYPE_CLEF,    "clef"    },
-};
-
-static common_decision_type common_decision_type_from_string(const std::string & str) {
-    for (const auto & pair : COMMON_DECISION_TYPE_NAMES) {
-        if (pair.second == str) {
-            return pair.first;
-        }
-    }
-    return COMMON_DECISION_TYPE_UNKNOWN;
-}
-
-common_decision_type common_get_decision_type(const struct llama_model * model) {
-    char buf[64];
-    if (llama_model_meta_val_str(model, "general.architecture", buf, sizeof(buf)) < 0) {
-        return COMMON_DECISION_TYPE_NONE;
-    }
-    const std::string key = std::string(buf) + ".decision.type";
-    if (llama_model_meta_val_str(model, key.c_str(), buf, sizeof(buf)) < 0) {
-        return COMMON_DECISION_TYPE_NONE;
-    }
-    return common_decision_type_from_string(buf);
-}
-
 common_init_result::common_init_result(common_params & params, bool model_only) :
    pimpl(new impl{}) {
    auto mparams = common_model_params_to_llama(params);
@@ -1270,29 +1339,6 @@ common_init_result::common_init_result(common_params & params, bool model_only)

    const llama_vocab * vocab = llama_model_get_vocab(model);

-    // these decision models return a score for each token via the embeddings output
-    // TODO: maybe improve this in the future
-    const auto decision_type = common_get_decision_type(model);
-    if (decision_type == COMMON_DECISION_TYPE_LAYA || decision_type == COMMON_DECISION_TYPE_KEV || decision_type == COMMON_DECISION_TYPE_CLEF) {
-        params.embedding    = true;
-        params.pooling_type = LLAMA_POOLING_TYPE_NONE;
-
-        cparams.embeddings            = true;
-        cparams.pooling_type          = LLAMA_POOLING_TYPE_NONE;
-        cparams.n_outputs_max         = cparams.n_batch;
-        cparams.n_outputs_max_per_seq = 1;
-
-        LOG_INF("%s", "decision model reads the embeddings output, enabling embedding mode\n");
-    }
-
-    // embeddings need the whole batch in one ubatch, so n_batch must not be larger than n_ubatch
-    // (server.cpp does this check for --embedding, but before the model is loaded)
-    if (cparams.embeddings && cparams.n_batch > cparams.n_ubatch) {
-        LOG_WRN("embeddings enabled: setting n_batch = n_ubatch = %u\n", cparams.n_ubatch);
-        cparams.n_batch = cparams.n_ubatch;
-        params.n_batch  = params.n_ubatch;
-    }
-
    // load and optionally apply lora adapters
    for (auto & la : params.lora_adapters) {
        llama_adapter_lora_ptr lora;
@@ -1481,8 +1527,7 @@ common_init_result_ptr common_init_from_params(common_params & params, bool mode
        }

        if (llama_model_has_encoder(model)) {
-            common_batch batch = common_batch_get_one(lctx, tmp);
-            llama_process(lctx, LLAMA_PROCESS_TYPE_ENCODE, batch.get());
+            llama_encode(lctx, llama_batch_get_one(tmp.data(), tmp.size()));
            llama_token decoder_start_token_id = llama_model_decoder_start_token(model);
            if (decoder_start_token_id == LLAMA_TOKEN_NULL) {
                decoder_start_token_id = bos;
@@ -1491,9 +1536,7 @@ common_init_result_ptr common_init_from_params(common_params & params, bool mode
            tmp.push_back(decoder_start_token_id);
        }
        if (llama_model_has_decoder(model)) {
-            tmp.resize(std::min(tmp.size(), (size_t) params.n_batch));
-            common_batch batch = common_batch_get_one(lctx, tmp);
-            llama_process(lctx, LLAMA_PROCESS_TYPE_DECODE, batch.get());
+            llama_decode(lctx, llama_batch_get_one(tmp.data(), std::min(tmp.size(), (size_t) params.n_batch)));
        }
        llama_memory_clear(llama_get_memory(lctx), true);
        llama_synchronize(lctx);
@@ -1543,11 +1586,6 @@ common_context_seq_rm_type common_context_can_seq_rm(llama_context * ctx) {
        return COMMON_CONTEXT_SEQ_RM_TYPE_NO;
    }

-    if (llama_n_rs_seq(ctx) > 0) {
-        COM_TRC("%s", "the context supports bounded partial sequence removal\n");
-        return COMMON_CONTEXT_SEQ_RM_TYPE_RS;
-    }
-
    common_context_seq_rm_type res = COMMON_CONTEXT_SEQ_RM_TYPE_PART;

    llama_memory_clear(mem, true);
@@ -1557,17 +1595,19 @@ common_context_seq_rm_type common_context_can_seq_rm(llama_context * ctx) {
    tmp.push_back(0);
    tmp.push_back(0);

-    int ret;
-    {
-        common_batch batch = common_batch_get_one(ctx, tmp);
-        ret = llama_process(ctx, LLAMA_PROCESS_TYPE_DECODE, batch.get());
-    }
+    int ret = llama_decode(ctx, llama_batch_get_one(tmp.data(), tmp.size()));
    if (ret != 0) {
-        COM_ERR("llama_process() failed: %d\n", ret);
+        COM_ERR("llama_decode() failed: %d\n", ret);
        res = COMMON_CONTEXT_SEQ_RM_TYPE_NO;
        goto done;
    }

+    if (llama_n_rs_seq(ctx) > 0) {
+        COM_TRC("%s", "the context supports bounded partial sequence removal\n");
+        res = COMMON_CONTEXT_SEQ_RM_TYPE_RS;
+        goto done;
+    }
+
    // try to remove the last tokens
    if (!llama_memory_seq_rm(mem, 0, 1, -1)) {
        COM_TRC("%s", "the context does not support partial sequence removal\n");
@@ -1787,6 +1827,33 @@ void common_threadpools::init(llama_context * ctx, const common_params & params)
    llama_attach_threadpool(ctx, threadpool, threadpool_batch);
 }

+//
+// Batch utils
+//
+
+void common_batch_clear(struct llama_batch & batch) {
+    batch.n_tokens = 0;
+}
+
+void common_batch_add(
+                 struct llama_batch & batch,
+                        llama_token   id,
+                          llama_pos   pos,
+    const std::vector<llama_seq_id> & seq_ids,
+                               bool   logits) {
+    GGML_ASSERT(batch.seq_id[batch.n_tokens] && "llama_batch size exceeded");
+
+    batch.token   [batch.n_tokens] = id;
+    batch.pos     [batch.n_tokens] = pos;
+    batch.n_seq_id[batch.n_tokens] = seq_ids.size();
+    for (size_t i = 0; i < seq_ids.size(); ++i) {
+        batch.seq_id[batch.n_tokens][i] = seq_ids[i];
+    }
+    batch.logits  [batch.n_tokens] = logits;
+
+    batch.n_tokens++;
+}
+
 //
 // Vocab utils
 //
@@ -2123,140 +2190,18 @@ float lr_opt::get_lr(float epoch) const {
 }

 bool common_replay_last_token(struct llama_context * ctx, llama_token last_token, int32_t pos) {
-    common_batch batch(ctx);
-    batch.add(last_token, pos, 0, true);
-
-    if (llama_process(ctx, LLAMA_PROCESS_TYPE_DECODE, batch.get())) {
+    llama_batch batch = llama_batch_get_one(&last_token, 1);
+    batch.pos = &pos;
+    if (llama_decode(ctx, batch)) {
        LOG_ERR("%s: failed to replay last token\n", __func__);
        return false;
    }
    return true;
 }

-common_batch::common_batch(llama_context * ctx) : batch(llama_batch_ext_init(ctx)) {
-    const auto rope_type = llama_model_rope_type(llama_get_model(ctx));
-    n_pos = rope_type == LLAMA_ROPE_TYPE_MROPE || rope_type == LLAMA_ROPE_TYPE_IMROPE ? GGML_MROPE_SECTIONS : 1;
-}
-
-void common_batch::clear() {
-    tokens.clear();
-}
-
-int32_t common_batch::add(llama_token id, llama_pos pos, llama_seq_id seq_id, bool output) {
-    tokens.push_back({ id, { pos, 0, 0, 0 }, seq_id, output, { nullptr, 0, 0 }, {} });
-    return size() - 1;
-}
-
-int32_t common_batch::add(llama_token id, llama_pos pos, const std::vector<llama_seq_id> & seq_ids, bool output) {
-    GGML_ASSERT(!seq_ids.empty());
-
-    const int32_t idx = add(id, pos, seq_ids[0], output);
-    for (size_t s = 1; s < seq_ids.size(); ++s) {
-        add_seq(idx, seq_ids[s]);
-    }
-    return idx;
-}
-
-bool common_batch::add_seq(int32_t idx, llama_seq_id seq_id) {
-    if (idx < 0 || idx >= size()) {
-        return false;
-    }
-    tokens[idx].seq_ids_extra.push_back(seq_id);
-    return true;
-}
-
-bool common_batch::set_output(int32_t idx, bool value) {
-    if (idx < 0 || idx >= size()) {
-        return false;
-    }
-    tokens[idx].output = value;
-    return true;
-}
-
-bool common_batch::set_embd(int32_t idx, llama_embd embd) {
-    if (idx < 0 || idx >= size() || tokens[idx].embd.data != nullptr) {
-        return false;
-    }
-    tokens[idx].embd = embd;
-    return true;
-}
-
-int32_t common_batch::add_embd(llama_embd embd, const llama_pos * pos, llama_seq_id seq_id, bool output) {
-    token t = { LLAMA_TOKEN_NULL, { 0, 0, 0, 0 }, seq_id, output, embd, {} };
-    for (int32_t j = 0; j < n_pos; ++j) {
-        t.pos[j] = pos[j];
-    }
-    tokens.push_back(t);
-    return size() - 1;
-}
-
-llama_batch_ext * common_batch::get_sub_batch(int32_t off, int32_t n) {
-    GGML_ASSERT(batch && "common_batch was not initialized with a context");
-    GGML_ASSERT(off >= 0 && n >= 0 && off + n <= size());
-
-    llama_batch_ext * res = batch.get();
-    llama_batch_ext_clear(res);
-
-    for (int32_t i = off; i < off + n; ++i) {
-        const token & t = tokens[i];
-
-        int32_t idx;
-        if (t.id != LLAMA_TOKEN_NULL) {
-            idx = llama_batch_ext_add_token(res, t.seq_id, t.id);
-            if (idx < 0) {
-                GGML_ABORT("%s: failed to add token %d at index %d (error %d, n = %d)\n", __func__, t.id, i, idx, n);
-            }
-            llama_batch_ext_set_pos(res, idx, t.pos.data());
-            if (t.embd.data && !llama_batch_ext_set_embd_token(res, idx, t.embd)) {
-                GGML_ABORT("%s: failed to set the embedding of token %d at index %d\n", __func__, t.id, i);
-            }
-        } else {
-            idx = llama_batch_ext_add_embd(res, t.seq_id, t.embd);
-            if (idx < 0) {
-                GGML_ABORT("%s: failed to add embedding at index %d (error %d, n = %d)\n", __func__, i, idx, n);
-            }
-            llama_batch_ext_set_pos(res, idx, t.pos.data());
-        }
-        GGML_ASSERT(idx == i - off);
-
-        for (const llama_seq_id seq_id : t.seq_ids_extra) {
-            if (!llama_batch_ext_add_seq(res, idx, seq_id)) {
-                GGML_ABORT("%s: failed to add seq %d to the entry at index %d\n", __func__, seq_id, i);
-            }
-        }
-        if (t.output) {
-            llama_batch_ext_set_output_logits(res, idx, true);
-        }
-        if (t.decision_order != 0) {
-            llama_batch_ext_set_decision_order(res, idx, (llama_decision_order) t.decision_order);
-        }
-    }
-
-    return res;
-}
-
-common_batch common_batch_get_one(llama_context * ctx, const llama_token * tokens, int32_t n_tokens) {
-    common_batch batch(ctx);
-
-    auto mem = llama_get_memory(ctx);
-    llama_pos pos = llama_memory_seq_pos_max(mem, 0) + 1; // -1 + 1 == 0 when the memory is empty
-
-    for (int32_t i = 0; i < n_tokens; ++i) {
-        const bool output = i == n_tokens - 1;
-        batch.add(tokens[i], pos, 0, output);
-        pos++;
-    }
-
-    return batch;
-}
-
-common_batch common_batch_get_one(llama_context * ctx, const llama_tokens & tokens) {
-    return common_batch_get_one(ctx, tokens.data(), (int32_t) tokens.size());
-}
-
 bool common_prompt_batch_decode(
              struct llama_context * ctx,
-                const llama_tokens & all_tokens,
+    const std::vector<llama_token> & all_tokens,
                               int   n_new,
                               int & n_past,
                               int   n_batch,
@@ -2277,9 +2222,7 @@ bool common_prompt_batch_decode(
        // Memory implementations in recurrent/hybrid models don't support removing tokens from their
        // memory, so we can't just remove the last token from the memory and replay the last token which
        // is the reason for this logic.
-        llama_tokens prefix_tokens(all_tokens.begin() + offset, all_tokens.begin() + offset + n_tokens_before_last);
-        common_batch batch_prefix = common_batch_get_one(ctx, prefix_tokens);
-        if (llama_process(ctx, LLAMA_PROCESS_TYPE_DECODE, batch_prefix.get())) {
+        if (llama_decode(ctx, llama_batch_get_one(const_cast<llama_token*>(all_tokens.data() + offset), n_tokens_before_last))) {
            COM_ERR("%s", "failed to eval\n");
            return false;
        }
@@ -2288,18 +2231,18 @@ bool common_prompt_batch_decode(
        llama_state_save_file(ctx, state_path.data(), all_tokens.data(), all_tokens.size());
        COM_INF("saved session before last token to %s, n_new = %zu\n", state_path.data(), all_tokens.size());

-        common_batch batch_last(ctx);
-        batch_last.add(all_tokens.back(), n_past, 0, true);
+        llama_token last_token = all_tokens.back();
+        llama_batch batch = llama_batch_get_one(&last_token, 1);
+        int32_t pos = n_past;
+        batch.pos = &pos;

-        if (llama_process(ctx, LLAMA_PROCESS_TYPE_DECODE, batch_last.get())) {
+        if (llama_decode(ctx, batch)) {
            COM_ERR("%s", "failed to eval last token\n");
            return false;
        }
        n_past++;
    } else {
-        llama_tokens new_tokens(all_tokens.begin() + offset, all_tokens.begin() + offset + n_new);
-        common_batch batch = common_batch_get_one(ctx, new_tokens);
-        if (llama_process(ctx, LLAMA_PROCESS_TYPE_DECODE, batch.get())) {
+        if (llama_decode(ctx, llama_batch_get_one(const_cast<llama_token*>(all_tokens.data() + offset), n_new))) {
            COM_ERR("%s", "failed to eval\n");
            return false;
        }
@@ -8,7 +8,6 @@
 #include "ggml.h"
 #include "llama.h"

-#include <array>
 #include <list>
 #include <set>
 #include <sstream>
@@ -17,9 +16,7 @@
 #include <vector>
 #include <map>
 #include <algorithm>
-#include <filesystem>
 #include <fstream>
-#include <cstdio>

 #if defined(_WIN32) && !defined(_WIN32_WINNT)
 #define _WIN32_WINNT 0x0A00
@@ -334,8 +331,6 @@ struct common_params_speculative_draft {

    bool backend_sampling = true; // offload draft sampling to the backend (default: on)

-    bool probabilistic = false; // sample the draft and verify by rejection, instead of argmax and match
-
    common_params_model mparams;

    llama_context * ctx_tgt = nullptr;
@@ -636,10 +631,10 @@ struct common_params {
    int32_t checkpoint_min_step = 8192;  // minimum spacing between context checkpoints
    int32_t cache_ram_mib       = 8192;  // -1 = no limit, 0 - disable, 1 = 1 MiB, etc.

+    std::string hostname      = "127.0.0.1";
    std::string public_path   = "";                                                                         // NOLINT
    std::string api_prefix    = "";                                                                         // NOLINT
    std::string chat_template = "";                                                                         // NOLINT
-    std::vector<std::string> hostnames = {"127.0.0.1"};
    bool use_jinja = true;                                                                                  // NOLINT

    // server CORS params
@@ -813,9 +808,7 @@ static std::vector<T> string_split(const std::string & str, char delim) {
    while (std::getline(str_stream, token, delim)) {
        T value;
        std::istringstream token_stream(token);
-        if (!(token_stream >> value)) {
-            throw std::invalid_argument("invalid value: \"" + token + "\"");
-        }
+        token_stream >> value;
        values.push_back(value);
    }
    return values;
@@ -883,21 +876,10 @@ void string_process_escapes(std::string & input);
 std::string string_from(bool value);
 std::string string_from(const std::vector<int> & values);
 std::string string_from(const struct llama_context * ctx, const std::vector<llama_token> & tokens);
+std::string string_from(const struct llama_context * ctx, const struct llama_batch & batch);

 bool glob_match(const std::string & pattern, const std::string & str);

-//
-// Unicode utils
-//
-
-#ifdef _WIN32
-std::wstring utf8_to_wstring(const std::string & str);
-std::string  wstring_to_utf8(const std::wstring & str);
-#endif
-
-// returns the path as a UTF-8 string, preserving its separators
-std::string fs_path_to_utf8(const std::filesystem::path & path);
-
 //
 // Environment utils
 //
@@ -907,28 +889,17 @@ std::string fs_path_to_utf8(const std::filesystem::path & path);
 std::string common_get_env(const std::string & name);
 void        common_set_env(const std::string & name, const std::string & value);

-// reads a path from the environment, an unset variable gives an empty path
-std::filesystem::path common_get_path_from_env(const std::string & name);
-
 //
 // Filesystem utils
 //

 bool fs_validate_filename(const std::string & filename, bool allow_subdirs = false);
+bool fs_create_directory_with_parents(const std::string & path);
 bool fs_is_directory(const std::string & path);

-// some old libstdc++ versions don't follow symlinks here, so adding a trailing "/" fixes it: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=101510
-inline bool common_create_directories(const std::filesystem::path & path, std::error_code & ec) {
-#if defined(__linux__)
-    return std::filesystem::create_directories(path / "", ec);
-#else
-    return std::filesystem::create_directories(path, ec);
-#endif
-}
-
-std::filesystem::path fs_get_cache_directory();
-std::filesystem::path fs_get_cache_file(const std::string & filename);
-std::filesystem::path fs_get_config_directory();
+std::string fs_get_cache_directory();
+std::string fs_get_cache_file(const std::string & filename);
+std::string fs_get_config_directory();

 struct common_file_info {
    std::string path;
@@ -938,7 +909,8 @@ struct common_file_info {
 };
 std::vector<common_file_info> fs_list(const std::string & path, bool include_directories);

-void fs_write_atomic(const std::filesystem::path & path, const std::string & data);
+// fs open, also handle UTF8 on Windows
+std::ifstream fs_open_ifstream(const std::string & fname, std::ios_base::openmode mode);

 //
 // TTY utils
@@ -947,29 +919,12 @@ void fs_write_atomic(const std::filesystem::path & path, const std::string & dat
 // Auto-detect if colors can be enabled based on terminal and environment
 bool tty_can_use_colors();

-// Check if the given file is attached to a terminal
-bool common_is_tty(FILE * file);
-
 //
 // Model utils
 //

 struct common_sampler;

-// typed decision models, see "<arch>.decision.type" in the model metadata
-enum common_decision_type {
-    COMMON_DECISION_TYPE_NONE,    // not a decision model
-    COMMON_DECISION_TYPE_OPENJEV, // logits of one label token per option, read at the last prompt token
-    COMMON_DECISION_TYPE_LEV,     // same as openjev, noul is read from a rating scale
-    COMMON_DECISION_TYPE_KEV,     // dot product of the hidden states of the last token and of one end token per option
-    COMMON_DECISION_TYPE_NIMBLE,  // same as openjev, the prompt lists all the questions of the request
-    COMMON_DECISION_TYPE_LAYA,    // score of one marker token per option, read from the embeddings output
-    COMMON_DECISION_TYPE_CLEF,    // all questions in one prompt, score of option i read from the embeddings output at row i
-    COMMON_DECISION_TYPE_UNKNOWN, // a decision model of a type that is not supported
-};
-
-common_decision_type common_get_decision_type(const struct llama_model * model);
-
 // note: defines the model, context, samplers, ets. lifetimes
 struct common_init_result {
    common_init_result(common_params & params, bool model_only = false);
@@ -1057,63 +1012,14 @@ struct common_memory {
 // Batch utils
 //

-// wrapper around llama_batch_ext that provide getter functions for downstream code
-// entries can exceed n_batch, use get_sub_batch() to decode them in chunks
-struct common_batch {
-    struct token {
-        llama_token  id;
-        std::array<llama_pos, GGML_MROPE_SECTIONS> pos; // only pos[0] is used for text tokens
-        llama_seq_id seq_id; // the first sequence id, see add_seq()
-        bool         output;
-        llama_embd   embd; // non-owning view of the data passed to add_embd()/set_embd(), data == NULL if none
-        std::vector<llama_seq_id> seq_ids_extra; // see add_seq()
-        int32_t      decision_order = 0; // see llama_batch_ext_set_decision_order()
-    };
+void common_batch_clear(struct llama_batch & batch);

-    std::vector<token> tokens; // mirror of the entries, tokens[i] describes batch index i
-    llama_batch_ext_ptr batch;
-
-    int32_t n_pos = 1; // positions per embedding entry, GGML_MROPE_SECTIONS for MROPE/IMROPE
-
-    common_batch() = default;
-    common_batch(struct llama_context * ctx);
-
-    llama_batch_ext * get() { return get_sub_batch(0, size()); }
-
-    // render entries [off, off + n) into batch, the result is overwritten by the next call
-    llama_batch_ext * get_sub_batch(int32_t off, int32_t n);
-
-    // content type of the batch, all entries carry the same combination
-    bool has_token() const { return !tokens.empty() && tokens[0].id != LLAMA_TOKEN_NULL; }
-    bool has_embd () const { return !tokens.empty() && tokens[0].embd.data != nullptr; }
-
-    void clear();
-
-    // returns the batch index
-    int32_t add(llama_token id, llama_pos pos, llama_seq_id seq_id, bool output);
-
-    // same, with the entry shared by all seq_ids (must not be empty)
-    int32_t add(llama_token id, llama_pos pos, const std::vector<llama_seq_id> & seq_ids, bool output);
-
-    // add the entry at idx to another sequence, tokens[idx].seq_id keeps the first one
-    bool add_seq(int32_t idx, llama_seq_id seq_id);
-
-    bool set_output(int32_t idx, bool value);
-
-    // attach a token embedding to the entry at idx, can only be set once per entry
-    bool set_embd(int32_t idx, llama_embd embd);
-
-    // add an embedding-only entry (no token id)
-    // pos points to n_pos positions
-    int32_t add_embd(llama_embd embd, const llama_pos * pos, llama_seq_id seq_id, bool output);
-
-    int32_t size() const { return (int32_t) tokens.size(); }
-};
-
-// create a single-sequence batch from a list of tokens
-// positions continue from the memory, last token always have output_logits set to true
-common_batch common_batch_get_one(struct llama_context * ctx, const llama_token * tokens, int32_t n_tokens);
-common_batch common_batch_get_one(struct llama_context * ctx, const llama_tokens & tokens);
+void common_batch_add(
+                 struct llama_batch & batch,
+                        llama_token   id,
+                          llama_pos   pos,
+    const std::vector<llama_seq_id> & seq_ids,
+                               bool   logits);

 // decodes a single batch of tokens for a prompt and manages session tokens
 //
@@ -1122,7 +1028,7 @@ common_batch common_batch_get_one(struct llama_context * ctx, const llama_tokens
 // tokens from memory, so this approach works across all model architectures.
 bool common_prompt_batch_decode(
              struct llama_context * ctx,
-                const llama_tokens & all_tokens,
+    const std::vector<llama_token> & all_tokens,
                               int   n_new,
                               int & n_past,
                               int   n_batch,
@@ -1,5 +1,4 @@
 #include "console.h"
-#include "common.h"
 #include "log.h"
 #include <vector>
 #include <iostream>
@@ -1019,7 +1018,6 @@ namespace console {
                    line.clear();
                    pop_cursor();
                }
-                line += '\n';
                has_more = false;
            }
        } else {
@@ -1051,10 +1049,13 @@ namespace console {
        if (!std::getline(std::wcin, wline)) {
            // Input stream is bad or EOF received
            line.clear();
+            GenerateConsoleCtrlEvent(CTRL_C_EVENT, 0);
            return false;
        }

-        line = wstring_to_utf8(wline);
+        int size_needed = WideCharToMultiByte(CP_UTF8, 0, &wline[0], (int)wline.size(), NULL, 0, NULL, NULL);
+        line.resize(size_needed);
+        WideCharToMultiByte(CP_UTF8, 0, &wline[0], (int)wline.size(), &line[0], size_needed, NULL, NULL);
 #else
        if (!std::getline(std::cin, line)) {
            // Input stream is bad or EOF received
@@ -1065,7 +1066,7 @@ namespace console {
        if (!line.empty()) {
            char last = line.back();
            if (last == '/') { // Always return control on '/' symbol
-                line.back() = '\n';
+                line.pop_back();
                return false;
            }
            if (last == '\\') { // '\\' changes the default action
@@ -35,13 +35,50 @@
 #endif
 #endif

+// isatty
+#if defined(_WIN32)
+#include <io.h>
+#else
+#include <unistd.h>
+#endif
+
 //
 // downloader
 //

+// validate repo name format: owner/repo
+static void write_file(const std::string & fname, const std::string & content) {
+    const std::string fname_tmp = fname + ".tmp";
+    std::ofstream     file(fname_tmp);
+    if (!file) {
+        throw std::runtime_error(string_format("error: failed to open file '%s'\n", fname.c_str()));
+    }
+
+    try {
+        file << content;
+        file.close();
+
+        // Makes write atomic
+        if (rename(fname_tmp.c_str(), fname.c_str()) != 0) {
+            LOG_ERR("%s: unable to rename file: %s to %s\n", __func__, fname_tmp.c_str(), fname.c_str());
+            // If rename fails, try to delete the temporary file
+            if (remove(fname_tmp.c_str()) != 0) {
+                LOG_ERR("%s: unable to delete temporary file: %s\n", __func__, fname_tmp.c_str());
+            }
+        }
+    } catch (...) {
+        // If anything fails, try to delete the temporary file
+        if (remove(fname_tmp.c_str()) != 0) {
+            LOG_ERR("%s: unable to delete temporary file: %s\n", __func__, fname_tmp.c_str());
+        }
+
+        throw std::runtime_error(string_format("error: failed to write file '%s'\n", fname.c_str()));
+    }
+}
+
 static void write_etag(const std::string & path, const std::string & etag) {
    const std::string etag_path = path + ".etag";
-    fs_write_atomic(std::filesystem::u8path(etag_path), etag);
+    write_file(etag_path, etag);
    LOG_DBG("%s: file etag saved: %s\n", __func__, etag_path.c_str());
 }

@@ -90,7 +127,11 @@ class ProgressBar : public common_download_callback {
    }

    static bool is_output_a_tty() {
-        return common_is_tty(stdout);
+#if defined(_WIN32)
+        return _isatty(_fileno(stdout));
+#else
+        return isatty(1);
+#endif
    }

 public:
@@ -233,12 +274,6 @@ static bool common_pull_file(httplib::Client & cli,
        return false;
    }

-    ofs.close();
-    if (!ofs) {
-        LOG_ERR("%s: error closing file: %s\n", __func__, path_tmp.c_str());
-        return false;
-    }
-
    return true;
 }

@@ -251,7 +286,7 @@ static int common_download_file_single_online(const std::string & url,
    static const int max_attempts        = 3;
    static const int retry_delay_seconds = 2;

-    const bool file_exists = std::filesystem::exists(std::filesystem::u8path(path));
+    const bool file_exists = std::filesystem::exists(path);

    if (file_exists && skip_etag) {
        LOG_DBG("%s: using cached file: %s\n", __func__, path.c_str());
@@ -442,7 +477,7 @@ int common_download_file_single(const std::string & url,
        return common_download_file_single_online(url, path, online_opts, skip_etag);
    }

-    if (!std::filesystem::exists(std::filesystem::u8path(path))) {
+    if (!std::filesystem::exists(path)) {
        LOG_ERR("%s: required file is not available in cache (offline mode): %s\n", __func__, path.c_str());
        return -1;
    }
@@ -908,7 +943,7 @@ std::string common_docker_resolve_model(const std::string & docker) {
        std::string model_filename = repo;
        std::replace(model_filename.begin(), model_filename.end(), '/', '_');
        model_filename += "_" + tag + ".gguf";
-        std::string local_path = fs_path_to_utf8(fs_get_cache_file(model_filename));
+        std::string local_path = fs_get_cache_file(model_filename);

        const std::string blob_url = url_prefix + "/blobs/" + gguf_digest;
        common_download_opts opts;
@@ -1,6 +1,5 @@
 #include "fit.h"

-#include "json.h"
 #include "log.h"

 #include "../src/llama-ext.h"
@@ -916,9 +915,6 @@ void common_memory_breakdown_print(const struct llama_context * ctx) {

    std::vector<std::array<std::string, 9>> table_data;
    table_data.reserve(devices.size());
-
-    // same data as the table below, for --log-jsonl consumers
-    common_json rows = common_json::array();
    const std::string template_header = "%s: | %s | %s   %s    %s   %s   %s   %s    %s |\n";
    const std::string template_gpu    = "%s: | %s | %s = %s + (%s = %s + %s + %s) + %s |\n";
    const std::string template_other  = "%s: | %s | %s   %s    %s = %s + %s + %s    %s |\n";
@@ -993,19 +989,6 @@ void common_memory_breakdown_print(const struct llama_context * ctx) {
            std::to_string(mb.context / MiB),
            std::to_string(mb.compute / MiB),
            std::to_string(unaccounted / static_cast<int64_t>(MiB))});
-
-        rows.push_back({
-            {"kind",        "device"},
-            {"name",        name},
-            {"description", desc},
-            {"total",       total / MiB},
-            {"free",        free / MiB},
-            {"self",        self / MiB},
-            {"model",       mb.model / MiB},
-            {"context",     mb.context / MiB},
-            {"compute",     mb.compute / MiB},
-            {"unaccounted", unaccounted / static_cast<int64_t>(MiB)},
-        });
    }

    // print memory breakdown for host:
@@ -1021,15 +1004,6 @@ void common_memory_breakdown_print(const struct llama_context * ctx) {
            std::to_string(mb_host.context / MiB),
            std::to_string(mb_host.compute / MiB),
            ""}); // unaccounted
-
-        rows.push_back({
-            {"kind",    "host"},
-            {"name",    "Host"},
-            {"self",    self / MiB},
-            {"model",   mb_host.model / MiB},
-            {"context", mb_host.context / MiB},
-            {"compute", mb_host.compute / MiB},
-        });
    }

    // print memory breakdown for all remaining buffer types:
@@ -1051,16 +1025,6 @@ void common_memory_breakdown_print(const struct llama_context * ctx) {
            std::to_string(mb.context / MiB),
            std::to_string(mb.compute / MiB),
            ""}); // unaccounted
-
-        rows.push_back({
-            {"kind",    "buffer_type"},
-            {"name",    name},
-            {"self",    self / MiB},
-            {"model",   mb.model / MiB},
-            {"context", mb.context / MiB},
-            {"compute", mb.compute / MiB},
-        });
-
        seen_buffer_types.insert(buft);
    }

@@ -1078,11 +1042,6 @@ void common_memory_breakdown_print(const struct llama_context * ctx) {
            __func__, td[1].c_str(), td[2].c_str(), td[3].c_str(), td[4].c_str(), td[5].c_str(),
            td[6].c_str(), td[7].c_str(), td[8].c_str());
    }
-
-    LOG_JSON("fit_memory_breakdown", common_json({
-        {"unit", "MiB"},
-        {"rows", rows},
-    }));
 }

 void common_fit_print(
@@ -44,7 +44,8 @@ static fs::path get_cache_directory() {
            {HOME_DIR,                fs::path(".cache") / "huggingface" / "hub"}
        };
        for (const auto & entry : entries) {
-            if (fs::path base = common_get_path_from_env(entry.var); !base.empty()) {
+            if (auto * p = std::getenv(entry.var); p && *p) {
+                fs::path base(p);
                return entry.path.empty() ? base : base / entry.path;
            }
        }
@@ -61,10 +62,6 @@ static fs::path get_cache_directory() {
    return cache;
 }

-std::string get_cache_path() {
-    return fs_path_to_utf8(get_cache_directory());
-}
-
 static std::string folder_name_to_repo(const std::string & folder) {
    constexpr std::string_view prefix = "models--";
    if (folder.rfind(prefix, 0)) {
@@ -172,6 +169,28 @@ static bool is_valid_subpath(const fs::path & path, const fs::path & subpath) {
    return b_end == b.end();
 }

+static void safe_write_file(const fs::path & path, const std::string & data) {
+    fs::path path_tmp = path.string() + ".tmp";
+
+    if (path.has_parent_path()) {
+        fs::create_directories(path.parent_path());
+    }
+
+    std::ofstream file(path_tmp);
+    file << data;
+    file.close();
+
+    std::error_code ec;
+
+    if (!file.fail()) {
+        fs::rename(path_tmp, path, ec);
+    }
+    if (file.fail() || ec) {
+        fs::remove(path_tmp, ec);
+        throw std::runtime_error("failed to write file: " + path.string());
+    }
+}
+
 static common_json api_get(const std::string & url,
                           const std::string & token) {
    auto [cli, parts] = common_http_client(url);
@@ -218,7 +237,6 @@ static std::string get_repo_commit(const std::string & repo_id,
        fs::path refs_path = get_repo_path(repo_id) / "refs";
        std::string name;
        std::string commit;
-        fs::path name_path;

        for (const auto & branch : json["branches"]) {
            if (!branch.is_object() ||
@@ -229,28 +247,24 @@ static std::string get_repo_commit(const std::string & repo_id,
            std::string _name = branch["name"].get<std::string>();
            std::string _commit = branch["targetCommit"].get<std::string>();

-            if (!is_valid_commit(_commit)) {
-                LOG_WRN("%s: skip invalid commit: %s\n", __func__, _commit.c_str());
+            if (!is_valid_subpath(refs_path, _name)) {
+                LOG_WRN("%s: skip invalid branch: %s\n", __func__, _name.c_str());
                continue;
            }
-            const fs::path candidate = fs::u8path(_name);
-
-            if (!is_valid_subpath(refs_path, candidate)) {
-                LOG_WRN("%s: skip invalid branch: %s\n", __func__, _name.c_str());
+            if (!is_valid_commit(_commit)) {
+                LOG_WRN("%s: skip invalid commit: %s\n", __func__, _commit.c_str());
                continue;
            }

            if (_name == "main") {
                name = _name;
                commit = _commit;
-                name_path = candidate;
                break;
            }

            if (name.empty() || commit.empty()) {
                name = _name;
                commit = _commit;
-                name_path = candidate;
            }
        }

@@ -259,7 +273,7 @@ static std::string get_repo_commit(const std::string & repo_id,
            return {};
        }

-        fs_write_atomic(refs_path / name_path, commit);
+        safe_write_file(refs_path / name, commit);
        return commit;

    } catch (const common_json_error & e) {
@@ -308,9 +322,7 @@ hf_files get_repo_files(const std::string & repo_id,
            file.repo_id = repo_id;
            file.path = item["path"].get<std::string>();

-            const fs::path subpath = fs::u8path(file.path);
-
-            if (!is_valid_subpath(commit_path, subpath)) {
+            if (!is_valid_subpath(commit_path, file.path)) {
                LOG_WRN("%s: skip invalid path: %s\n", __func__, file.path.c_str());
                continue;
            }
@@ -330,12 +342,12 @@ hf_files get_repo_files(const std::string & repo_id,

            file.url = endpoint + repo_id + "/resolve/" + commit + "/" + file.path;

-            fs::path final_path = commit_path / subpath;
-            file.final_path = fs_path_to_utf8(final_path);
+            fs::path final_path = commit_path / file.path;
+            file.final_path = final_path.string();

            if (!file.oid.empty() && !fs::exists(final_path)) {
                fs::path local_path = blobs_path / file.oid;
-                file.local_path = fs_path_to_utf8(local_path);
+                file.local_path = local_path.string();
            } else {
                file.local_path = file.final_path;
            }
@@ -381,8 +393,8 @@ static std::string get_cached_ref(const fs::path & repo_path) {
 }

 hf_files get_cached_files(const std::string & repo_id) {
-    const fs::path cache_path = get_cache_directory();
-    if (!fs::exists(cache_path)) {
+    fs::path cache_dir = get_cache_directory();
+    if (!fs::exists(cache_dir)) {
        return {};
    }

@@ -393,7 +405,7 @@ hf_files get_cached_files(const std::string & repo_id) {

    hf_files files;

-    for (const auto & repo : fs::directory_iterator(cache_path)) {
+    for (const auto & repo : fs::directory_iterator(cache_dir)) {
        if (!repo.is_directory()) {
            continue;
        }
@@ -402,7 +414,7 @@ hf_files get_cached_files(const std::string & repo_id) {
        if (!fs::exists(snapshots_path)) {
            continue;
        }
-        std::string _repo_id = folder_name_to_repo(fs_path_to_utf8(repo.path().filename()));
+        std::string _repo_id = folder_name_to_repo(repo.path().filename().string());

        if (!is_valid_repo_id(_repo_id)) {
            continue;
@@ -425,9 +437,8 @@ hf_files get_cached_files(const std::string & repo_id) {
            if (!path.empty()) {
                hf_file file;
                file.repo_id = _repo_id;
-                const auto generic_path = path.generic_u8string();
-                file.path = std::string(generic_path.begin(), generic_path.end());
-                file.local_path = fs_path_to_utf8(entry.path());
+                file.path = path.generic_string();
+                file.local_path = entry.path().string();
                file.final_path = file.local_path;
                files.push_back(std::move(file));
            }
@@ -441,8 +452,8 @@ std::string finalize_file(const hf_file & file) {
    static std::atomic<bool> symlinks_disabled{false};

    std::error_code ec;
-    fs::path local_path = fs::u8path(file.local_path);
-    fs::path final_path = fs::u8path(file.final_path);
+    fs::path local_path(file.local_path);
+    fs::path final_path(file.final_path);

    if (local_path == final_path || fs::exists(final_path, ec)) {
        return file.final_path;
@@ -489,7 +500,7 @@ bool remove_cached_repo(const std::string & repo_id) {
    std::error_code ec;
    auto removed = fs::remove_all(repo_path, ec);
    if (ec) {
-        LOG_ERR("%s: failed to remove repo cache %s: %s\n", __func__, fs_path_to_utf8(repo_path).c_str(), ec.message().c_str());
+        LOG_ERR("%s: failed to remove repo cache %s: %s\n", __func__, repo_path.string().c_str(), ec.message().c_str());
        return false;
    }
    return removed > 0;
@@ -32,7 +32,4 @@ std::string finalize_file(const hf_file & file);
 // Remove the entire cached directory for a repo, returns true if removed
 bool remove_cached_repo(const std::string & repo_id);

-// Returns the HuggingFace hub cache path
-std::string get_cache_path();
-
 } // namespace hf_cache
@@ -429,23 +429,15 @@ private:
            bool negate = false;
            if (is_identifier("not")) { ++current; negate = true; }
            auto test_id = parse_primary_expression();
-            if (is(token::open_paren)) {
-                test_id = parse_call_expression(std::move(test_id));
-            } else if (is(token::numeric_literal) || is(token::string_literal) || is(token::open_curly_bracket) || is(token::open_square_bracket) ||
-                    (is(token::identifier) && !is_identifier("and") && !is_identifier("or") && !is_identifier("else"))) {
-                size_t call_pos = current;
-                statements args;
-                args.push_back(parse_unary_expression());
-                test_id = mk_stmt<call_expression>(call_pos, std::move(test_id), std::move(args));
-            }
+            // FIXME: tests can also be expressed like this: if x is eq 3
+            if (is(token::open_paren)) test_id = parse_call_expression(std::move(test_id));
            operand = mk_stmt<test_expression>(start_pos, std::move(operand), negate, std::move(test_id));
        }
        return operand;
    }

    statement_ptr parse_filter_expression() {
-        // Filters/tests bind outside unary so -n|abs is (-n)|abs, not -(n|abs).
-        auto operand = parse_unary_expression();
+        auto operand = parse_call_member_expression();
        while (is(token::pipe)) {
            size_t start_pos = current;
            ++current; // consume pipe
@@ -456,15 +448,6 @@ private:
        return operand;
    }

-    statement_ptr parse_unary_expression() {
-        if (is(token::unary_operator)) {
-            size_t start_pos = current;
-            auto op = next();
-            return mk_stmt<unary_expression>(start_pos, op, parse_unary_expression());
-        }
-        return parse_call_member_expression();
-    }
-
    statement_ptr parse_call_member_expression() {
        // Handle member expressions recursively
        auto member = parse_member_expression(parse_primary_expression());
@@ -51,7 +51,7 @@ static void ensure_key_type_allowed(const value & val) {
 }

 // execute with error handling
-value statement::execute(context & ctx) const {
+value statement::execute(context & ctx) {
    try {
        return execute_impl(ctx);
    } catch (const continue_statement::signal & /* ex */) {
@@ -80,7 +80,7 @@ value statement::execute(context & ctx) const {
    }
 }

-value identifier::execute_impl(context & ctx) const {
+value identifier::execute_impl(context & ctx) {
    auto it = ctx.get_val(val);
    auto builtins = global_builtins();
    if (!it->is_undefined()) {
@@ -98,7 +98,7 @@ value identifier::execute_impl(context & ctx) const {
    }
 }

-value object_literal::execute_impl(context & ctx) const {
+value object_literal::execute_impl(context & ctx) {
    auto obj = mk_val<value_object>();
    for (const auto & pair : val) {
        value key = pair.first->execute(ctx);
@@ -109,7 +109,7 @@ value object_literal::execute_impl(context & ctx) const {
    return obj;
 }

-value binary_expression::execute_impl(context & ctx) const {
+value binary_expression::execute_impl(context & ctx) {
    value left_val = left->execute(ctx);

    // Logical operators
@@ -317,7 +317,9 @@ static value try_builtin_func(context & ctx, const std::string & name, value & i
    throw std::runtime_error("Unknown (built-in) filter '" + name + "' for type " + input->type());
 }

-static value apply_filter(context & ctx, const statement_ptr & filter, value input) {
+value filter_expression::execute_impl(context & ctx) {
+    value input = operand ? operand->execute(ctx) : val;
+
    JJ_DEBUG("Applying filter to %s", input->type().c_str());

    auto set_filter_alias = [](auto & filter_id) {
@@ -373,21 +375,22 @@ static value apply_filter(context & ctx, const statement_ptr & filter, value inp
    }
 }

-value filter_expression::execute_impl(context & ctx) const {
-    return apply_filter(ctx, filter, operand->execute(ctx));
-}
-
-value filter_statement::execute_impl(context & ctx) const {
+value filter_statement::execute_impl(context & ctx) {
    // eval body as string, then apply filter
    auto body_val = exec_statements(body, ctx);
    value_string parts = mk_val<value_string>();
    gather_string_parts_recursive(body_val, parts);

    JJ_DEBUG("FilterStatement: applying filter to body string of length %zu", parts->val_str.length());
-    return apply_filter(ctx, filter, parts);
+    filter_expression filter_expr(std::move(parts), std::move(filter));
+    value out = filter_expr.execute(ctx);
+
+    // this node can be reused later, make sure filter is preserved
+    this->filter = std::move(filter_expr.filter);
+    return out;
 }

-value test_expression::execute_impl(context & ctx) const {
+value test_expression::execute_impl(context & ctx) {
    // NOTE: "value is something" translates to function call "test_is_something(value)"
    const auto & builtins = global_builtins();

@@ -436,7 +439,7 @@ value test_expression::execute_impl(context & ctx) const {
    }
 }

-value unary_expression::execute_impl(context & ctx) const {
+value unary_expression::execute_impl(context & ctx) {
    value operand_val = argument->execute(ctx);
    JJ_DEBUG("Executing unary expression with operator '%s'", op.value.c_str());

@@ -450,17 +453,12 @@ value unary_expression::execute_impl(context & ctx) const {
        } else {
            throw std::runtime_error("Unary - operator requires numeric operand");
        }
-    } else if (op.value == "+") {
-        if (is_val<value_int>(operand_val) || is_val<value_float>(operand_val)) {
-            return operand_val;
-        }
-        throw std::runtime_error("Unary + operator requires numeric operand");
    }

    throw std::runtime_error("Unknown unary operator '" + op.value + "'");
 }

-value if_statement::execute_impl(context & ctx) const {
+value if_statement::execute_impl(context & ctx) {
    value test_val = test->execute(ctx);

    auto out = mk_val<value_array>();
@@ -481,14 +479,20 @@ value if_statement::execute_impl(context & ctx) const {
    return str;
 }

-value for_statement::execute_impl(context & ctx) const {
+value for_statement::execute_impl(context & ctx) {
    context scope(ctx); // new scope for loop variables

-    const jinja::select_expression * select_expr = cast_stmt<select_expression>(iterable);
+    jinja::select_expression * select_expr = cast_stmt<select_expression>(iterable);
    statement_ptr test_expr_nullptr;

-    const statement_ptr & iter_expr = select_expr ? select_expr->lhs : iterable;
-    const statement_ptr & test_expr = select_expr ? select_expr->test : test_expr_nullptr;
+    statement_ptr & iter_expr = [&]() -> statement_ptr & {
+        auto tmp = cast_stmt<select_expression>(iterable);
+        return tmp ? tmp->lhs : iterable;
+    }();
+    statement_ptr & test_expr = [&]() -> statement_ptr & {
+        auto tmp = cast_stmt<select_expression>(iterable);
+        return tmp ? tmp->test : test_expr_nullptr;
+    }();

    JJ_DEBUG("Executing for statement, iterable type: %s", iter_expr->type().c_str());

@@ -537,6 +541,8 @@ value for_statement::execute_impl(context & ctx) const {

    std::vector<value> filtered_items;
    for (size_t i = 0; i < items.size(); ++i) {
+        context loop_scope(scope);
+
        value current = items[i];

        std::function<void(context&)> scope_update_fn = [](context &) { /* no-op */};
@@ -582,7 +588,6 @@ value for_statement::execute_impl(context & ctx) const {
        }

        if (select_expr && test_expr) {
-            context loop_scope(scope);
            scope_update_fn(loop_scope);
            value test_val = test_expr->execute(loop_scope);
            if (!test_val->as_bool()) {
@@ -640,7 +645,7 @@ value for_statement::execute_impl(context & ctx) const {
    return str;
 }

-value set_statement::execute_impl(context & ctx) const {
+value set_statement::execute_impl(context & ctx) {
    auto rhs = val ? val->execute(ctx) : exec_statements(body, ctx);

    if (is_stmt<identifier>(assignee)) {
@@ -739,7 +744,7 @@ static inline void bind_parameters(const std::string & name, const statements &
    }
 }

-value macro_statement::execute_impl(context & ctx) const {
+value macro_statement::execute_impl(context & ctx) {
    if (!is_stmt<identifier>(this->name)) {
        throw std::runtime_error("Macro name must be an identifier");
    }
@@ -762,7 +767,7 @@ value macro_statement::execute_impl(context & ctx) const {
    return mk_val<value_undefined>();
 }

-value call_statement::execute_impl(context & ctx) const {
+value call_statement::execute_impl(context & ctx) {
    auto call_expr = cast_stmt<call_expression>(this->call);
    if (!call_expr) {
        throw std::runtime_error("Call statement requires a valid call expression");
@@ -802,7 +807,7 @@ value call_statement::execute_impl(context & ctx) const {
    return callee_func->invoke(args);
 }

-value member_expression::execute_impl(context & ctx) const {
+value member_expression::execute_impl(context & ctx) {
    value object = this->object->execute(ctx);

    value property;
@@ -837,12 +842,6 @@ value member_expression::execute_impl(context & ctx) const {
        } else {
            property = this->property->execute(ctx);
        }
-    } else if (is_stmt<integer_literal>(this->property)) {
-        // syntax: obj.index
-        property = mk_val<value_int>(cast_stmt<integer_literal>(this->property)->val);
-        if (property->as_int() < 0) {
-            throw std::runtime_error("Static member property cannot be negative");
-        }
    } else {
        // syntax: obj.prop
        if (!is_stmt<identifier>(this->property)) {
@@ -887,7 +886,7 @@ value member_expression::execute_impl(context & ctx) const {
        JJ_DEBUG("Accessed property '%s' value, got type: %s", key.c_str(), val->type().c_str());

    } else if (is_val<value_array>(object) || is_val<value_string>(object)) {
-        if (is_val<value_int>(property) || is_val<value_bool>(property)) {
+        if (is_val<value_int>(property)) {
            int64_t index = property->as_int();
            JJ_DEBUG("Accessing %s index %d", object->type().c_str(), (int)index);
            if (is_val<value_array>(object)) {
@@ -910,6 +909,8 @@ value member_expression::execute_impl(context & ctx) const {
            JJ_DEBUG("Accessing %s built-in '%s'", is_val<value_array>(object) ? "array" : "string", key.c_str());
            val = try_builtin_func(ctx, key, object, true);

+        } else {
+            throw std::runtime_error("Cannot access property with non-string/non-number: got " + property->type());
        }
    } else {
        if (!is_val<value_string>(property)) {
@@ -923,17 +924,17 @@ value member_expression::execute_impl(context & ctx) const {
        value_t::stats_t::mark_used(val);
        value_t::stats_t::mark_used(object);
        value_t::stats_t::mark_used(property);
-        if (is_val<value_object>(object) || is_val<value_string>(property) || is_val<value_float>(property) || is_val<value_array>(property) || is_val<value_none>(property)) {
-            object->stats.ops.insert("object_access");
-        } else if (is_val<value_int>(property) || is_val<value_bool>(property)) {
+        if (is_val<value_int>(property)) {
            object->stats.ops.insert("array_access");
+        } else if (is_val<value_string>(property)) {
+            object->stats.ops.insert("object_access");
        }
    }

    return val;
 }

-value call_expression::execute_impl(context & ctx) const {
+value call_expression::execute_impl(context & ctx) {
    // gather arguments
    func_args args(ctx);
    for (auto & arg_stmt : this->args) {
@@ -951,7 +952,7 @@ value call_expression::execute_impl(context & ctx) const {
    return callee_func->invoke(args);
 }

-value keyword_argument_expression::execute_impl(context & ctx) const {
+value keyword_argument_expression::execute_impl(context & ctx) {
    if (!is_stmt<identifier>(key)) {
        throw std::runtime_error("Keyword argument key must be identifiers");
    }
@@ -975,7 +976,7 @@ std::string runtime::debug_dump_program(const program & prog, const std::string
        return std::string(lvl * 2, ' ');
    };

-    ctx.visitor = [&](bool is_leaf, const statement * node, std::vector<visitor_pair> children) {
+    ctx.visitor = [&](bool is_leaf, statement * node, std::vector<visitor_pair> children) {
        oss << indent(lvl) << node->type() << ":\n";
        lvl++;
        if (is_leaf) {
@@ -48,9 +48,9 @@ const T * cast_stmt(const statement_ptr & ptr) {
 void enable_debug(bool enable);

 // for visiting AST nodes
-// function signature: void(bool is_leaf, const statement * node, pair of <label, children>)
-using visitor_pair = std::pair<std::string, std::vector<const statement *>>;
-using visitor_fn = std::function<void(bool, const statement *, std::vector<visitor_pair>)>;
+// function signature: void(bool is_leaf, statement * node, pair of <label, children>)
+using visitor_pair = std::pair<std::string, std::vector<statement *>>;
+using visitor_fn = std::function<void(bool, statement *, std::vector<visitor_pair>)>;

 struct context {
    std::shared_ptr<std::string> src; // for debugging; use shared_ptr to avoid copying on scope creation
@@ -107,8 +107,8 @@ private:
 };

 // utils for visiting AST nodes
-static std::vector<const statement *> stmts_to_ptr(const statements & stmts) {
-    std::vector<const statement *> children;
+static std::vector<statement *> stmts_to_ptr(const statements & stmts) {
+    std::vector<statement *> children;
    for (const auto & stmt : stmts) {
        children.push_back(stmt.get());
    }
@@ -117,18 +117,17 @@ static std::vector<const statement *> stmts_to_ptr(const statements & stmts) {

 /**
 * Base class for all nodes in the AST.
- * The AST is shared between threads, so visit and execute must be const.
 */
 struct statement {
    size_t pos; // position in source, for debugging
    virtual ~statement() = default;
    virtual std::string type() const { return "Statement"; }
-    virtual void visit(context & ctx) const { ctx.visitor(true, this, {}); }
+    virtual void visit(context & ctx) { ctx.visitor(true, this, {}); }

    // execute_impl must be overridden by derived classes
-    virtual value execute_impl(context &) const { throw_exec_error(); }
+    virtual value execute_impl(context &) { throw_exec_error(); }
    // execute is the public method to execute a statement with error handling
-    value execute(context &) const;
+    value execute(context &);

 private:
    [[noreturn]] void throw_exec_error() const {
@@ -167,7 +166,7 @@ struct program : public statement {
    program() = default;
    explicit program(statements && body) : body(std::move(body)) {}
    std::string type() const override { return "Program"; }
-    [[noreturn]] value execute_impl(context &) const override {
+    [[noreturn]] value execute_impl(context &) override {
        throw std::runtime_error("Cannot execute program directly, use jinja::runtime instead");
    }
 };
@@ -183,8 +182,8 @@ struct if_statement : public statement {
    }

    std::string type() const override { return "If"; }
-    value execute_impl(context & ctx) const override;
-    void visit(context & ctx) const override {
+    value execute_impl(context & ctx) override;
+    void visit(context & ctx) override {
        ctx.visitor(false, this, {
            {"test", {test.get()}},
            {"body", stmts_to_ptr(body)},
@@ -214,8 +213,8 @@ struct for_statement : public statement {
    }

    std::string type() const override { return "For"; }
-    value execute_impl(context & ctx) const override;
-    void visit(context & ctx) const override {
+    value execute_impl(context & ctx) override;
+    void visit(context & ctx) override {
        ctx.visitor(false, this, {
            {"loopvar", {loopvar.get()}},
            {"iterable", {iterable.get()}},
@@ -234,7 +233,7 @@ struct break_statement : public statement {
        }
    };

-    [[noreturn]] value execute_impl(context &) const override {
+    [[noreturn]] value execute_impl(context &) override {
        throw break_statement::signal();
    }
 };
@@ -248,7 +247,7 @@ struct continue_statement : public statement {
        }
    };

-    [[noreturn]] value execute_impl(context &) const override {
+    [[noreturn]] value execute_impl(context &) override {
        throw continue_statement::signal();
    }
 };
@@ -256,7 +255,7 @@ struct continue_statement : public statement {
 // do nothing
 struct noop_statement : public statement {
    std::string type() const override { return "Noop"; }
-    value execute_impl(context &) const override {
+    value execute_impl(context &) override {
        return mk_val<value_undefined>();
    }
 };
@@ -273,8 +272,8 @@ struct set_statement : public statement {
    }

    std::string type() const override { return "Set"; }
-    value execute_impl(context & ctx) const override;
-    void visit(context & ctx) const override {
+    value execute_impl(context & ctx) override;
+    void visit(context & ctx) override {
        ctx.visitor(false, this, {
            {"assignee", {assignee.get()}},
            {"value", {val.get()}},
@@ -295,8 +294,8 @@ struct macro_statement : public statement {
    }

    std::string type() const override { return "Macro"; }
-    value execute_impl(context & ctx) const override;
-    void visit(context & ctx) const override {
+    value execute_impl(context & ctx) override;
+    void visit(context & ctx) override {
        ctx.visitor(false, this, {
            {"name", {name.get()}},
            {"args", stmts_to_ptr(args)},
@@ -309,7 +308,7 @@ struct comment_statement : public statement {
    std::string val;
    explicit comment_statement(const std::string & v) : val(v) {}
    std::string type() const override { return "Comment"; }
-    value execute_impl(context &) const override {
+    value execute_impl(context &) override {
        return mk_val<value_undefined>();
    }
 };
@@ -319,7 +318,7 @@ struct comment_statement : public statement {
 // Represents an omitted expression in a computed member, e.g. `a[]`.
 struct blank_expression : public expression {
    std::string type() const override { return "BlankExpression"; }
-    value execute_impl(context &) const override {
+    value execute_impl(context &) override {
        return mk_val<value_undefined>();
    }
 };
@@ -335,8 +334,8 @@ struct member_expression : public expression {
        chk_type<expression>(this->property);
    }
    std::string type() const override { return "MemberExpression"; }
-    value execute_impl(context & ctx) const override;
-    void visit(context & ctx) const override {
+    value execute_impl(context & ctx) override;
+    void visit(context & ctx) override {
        ctx.visitor(false, this, {
            {"object", {object.get()}},
            {"property", {property.get()}}
@@ -354,8 +353,8 @@ struct call_expression : public expression {
        for (const auto& arg : this->args) chk_type<expression>(arg);
    }
    std::string type() const override { return "CallExpression"; }
-    value execute_impl(context & ctx) const override;
-    void visit(context & ctx) const override {
+    value execute_impl(context & ctx) override;
+    void visit(context & ctx) override {
        ctx.visitor(false, this, {
            {"callee", {callee.get()}},
            {"args", stmts_to_ptr(args)}
@@ -370,7 +369,7 @@ struct identifier : public expression {
    std::string val;
    explicit identifier(const std::string & val) : val(val) {}
    std::string type() const override { return "Identifier"; }
-    value execute_impl(context & ctx) const override;
+    value execute_impl(context & ctx) override;
 };

 // Literals
@@ -379,7 +378,7 @@ struct integer_literal : public expression {
    int64_t val;
    explicit integer_literal(int64_t val) : val(val) {}
    std::string type() const override { return "IntegerLiteral"; }
-    value execute_impl(context &) const override {
+    value execute_impl(context &) override {
        return mk_val<value_int>(val);
    }
 };
@@ -388,7 +387,7 @@ struct float_literal : public expression {
    double val;
    explicit float_literal(double val) : val(val) {}
    std::string type() const override { return "FloatLiteral"; }
-    value execute_impl(context &) const override {
+    value execute_impl(context &) override {
        return mk_val<value_float>(val);
    }
 };
@@ -397,7 +396,7 @@ struct string_literal : public expression {
    std::string val;
    explicit string_literal(const std::string & val) : val(val) {}
    std::string type() const override { return "StringLiteral"; }
-    value execute_impl(context &) const override {
+    value execute_impl(context &) override {
        return mk_val<value_string>(val);
    }
 };
@@ -408,7 +407,7 @@ struct array_literal : public expression {
        for (const auto& item : this->val) chk_type<expression>(item);
    }
    std::string type() const override { return "ArrayLiteral"; }
-    value execute_impl(context & ctx) const override {
+    value execute_impl(context & ctx) override {
        auto arr = mk_val<value_array>();
        for (const auto & item_stmt : val) {
            arr->push_back(item_stmt->execute(ctx));
@@ -423,7 +422,7 @@ struct tuple_literal : public expression {
        for (const auto& item : this->val) chk_type<expression>(item);
    }
    std::string type() const override { return "TupleLiteral"; }
-    value execute_impl(context & ctx) const override {
+    value execute_impl(context & ctx) override {
        auto arr = mk_val<value_array>();
        for (const auto & item_stmt : val) {
            arr->push_back(item_stmt->execute(ctx));
@@ -442,7 +441,7 @@ struct object_literal : public expression {
        }
    }
    std::string type() const override { return "ObjectLiteral"; }
-    value execute_impl(context & ctx) const override;
+    value execute_impl(context & ctx) override;
 };

 // Complex Expressions
@@ -463,8 +462,8 @@ struct binary_expression : public expression {
        chk_type<expression>(this->right);
    }
    std::string type() const override { return "BinaryExpression"; }
-    value execute_impl(context & ctx) const override;
-    void visit(context & ctx) const override {
+    value execute_impl(context & ctx) override;
+    void visit(context & ctx) override {
        ctx.visitor(false, this, {
            {"left", {left.get()}},
            {"right", {right.get()}}
@@ -477,7 +476,10 @@ struct binary_expression : public expression {
 * Operator precedence: https://github.com/pallets/jinja/issues/379#issuecomment-168076202
 */
 struct filter_expression : public expression {
+    // either an expression or a value is allowed
    statement_ptr operand;
+    value_string val; // will be set by filter_statement
+
    statement_ptr filter;

    filter_expression(statement_ptr && operand, statement_ptr && filter)
@@ -486,9 +488,14 @@ struct filter_expression : public expression {
        chk_type<identifier, call_expression>(this->filter);
    }

+    filter_expression(value_string && val, statement_ptr && filter)
+        : val(std::move(val)), filter(std::move(filter)) {
+        chk_type<identifier, call_expression>(this->filter);
+    }
+
    std::string type() const override { return "FilterExpression"; }
-    value execute_impl(context & ctx) const override;
-    void visit(context & ctx) const override {
+    value execute_impl(context & ctx) override;
+    void visit(context & ctx) override {
        ctx.visitor(false, this, {
            {"operand", {operand.get()}},
            {"filter", {filter.get()}}
@@ -505,8 +512,8 @@ struct filter_statement : public statement {
        chk_type<identifier, call_expression>(this->filter);
    }
    std::string type() const override { return "FilterStatement"; }
-    value execute_impl(context & ctx) const override;
-    void visit(context & ctx) const override {
+    value execute_impl(context & ctx) override;
+    void visit(context & ctx) override {
        ctx.visitor(false, this, {
            {"filter", {filter.get()}},
            {"body", stmts_to_ptr(body)}
@@ -530,14 +537,14 @@ struct select_expression : public expression {
        chk_type<expression>(this->test);
    }
    std::string type() const override { return "SelectExpression"; }
-    value execute_impl(context & ctx) const override {
+    value execute_impl(context & ctx) override {
        auto predicate = test->execute_impl(ctx);
        if (!predicate->as_bool()) {
            return mk_val<value_undefined>();
        }
        return lhs->execute_impl(ctx);
    }
-    void visit(context & ctx) const override {
+    void visit(context & ctx) override {
        ctx.visitor(false, this, {
            {"lhs", {lhs.get()}},
            {"test", {test.get()}}
@@ -560,8 +567,8 @@ struct test_expression : public expression {
        chk_type<identifier, call_expression>(this->test);
    }
    std::string type() const override { return "TestExpression"; }
-    value execute_impl(context & ctx) const override;
-    void visit(context & ctx) const override {
+    value execute_impl(context & ctx) override;
+    void visit(context & ctx) override {
        ctx.visitor(false, this, {
            {"operand", {operand.get()}},
            {"test", {test.get()}}
@@ -581,8 +588,8 @@ struct unary_expression : public expression {
        chk_type<expression>(this->argument);
    }
    std::string type() const override { return "UnaryExpression"; }
-    value execute_impl(context & ctx) const override;
-    void visit(context & ctx) const override {
+    value execute_impl(context & ctx) override;
+    void visit(context & ctx) override {
        ctx.visitor(false, this, {
            {"argument", {argument.get()}}
        });
@@ -601,10 +608,10 @@ struct slice_expression : public expression {
        chk_type<expression>(this->step_expr);
    }
    std::string type() const override { return "SliceExpression"; }
-    [[noreturn]] value execute_impl(context &) const override {
+    [[noreturn]] value execute_impl(context &) override {
        throw std::runtime_error("must be handled by MemberExpression");
    }
-    void visit(context & ctx) const override {
+    void visit(context & ctx) override {
        ctx.visitor(false, this, {
            {"start_expr", {start_expr.get()}},
            {"stop_expr", {stop_expr.get()}},
@@ -623,8 +630,8 @@ struct keyword_argument_expression : public expression {
        chk_type<expression>(this->val);
    }
    std::string type() const override { return "KeywordArgumentExpression"; }
-    value execute_impl(context & ctx) const override;
-    void visit(context & ctx) const override {
+    value execute_impl(context & ctx) override;
+    void visit(context & ctx) override {
        ctx.visitor(false, this, {
            {"key", {key.get()}},
            {"val", {val.get()}}
@@ -638,7 +645,7 @@ struct spread_expression : public expression {
        chk_type<expression>(this->argument);
    }
    std::string type() const override { return "SpreadExpression"; }
-    void visit(context & ctx) const override {
+    void visit(context & ctx) override {
        ctx.visitor(false, this, {
            {"argument", {argument.get()}}
        });
@@ -656,8 +663,8 @@ struct call_statement : public statement {
        for (const auto & arg : this->caller_args) chk_type<expression>(arg);
    }
    std::string type() const override { return "CallStatement"; }
-    value execute_impl(context & ctx) const override;
-    void visit(context & ctx) const override {
+    value execute_impl(context & ctx) override;
+    void visit(context & ctx) override {
        ctx.visitor(false, this, {
            {"call", {call.get()}},
            {"caller_args", stmts_to_ptr(caller_args)},
@@ -678,7 +685,7 @@ struct ternary_expression : public expression {
        chk_type<expression>(this->false_expr);
    }
    std::string type() const override { return "Ternary"; }
-    value execute_impl(context & ctx) const override {
+    value execute_impl(context & ctx) override {
        value cond_val = condition->execute(ctx);
        if (cond_val->as_bool()) {
            return true_expr->execute(ctx);
@@ -686,7 +693,7 @@ struct ternary_expression : public expression {
            return false_expr->execute(ctx);
        }
    }
-    void visit(context & ctx) const override {
+    void visit(context & ctx) override {
        ctx.visitor(false, this, {
            {"condition", {condition.get()}},
            {"true_expr", {true_expr.get()}},
@@ -149,13 +149,6 @@ static value test_type_fn(const func_args & args) {
    JJ_DEBUG("test_type_fn: type=%s, %s or %s result=%d", typeid(T).name(), typeid(U).name(), typeid(V).name(), is_type ? 1 : 0);
    return mk_val<value_bool>(is_type);
 }
-template<typename T, typename U, typename V, typename W>
-static value test_type_fn(const func_args & args) {
-    args.ensure_count(1);
-    bool is_type = is_val<T>(args.get_pos(0)) || is_val<U>(args.get_pos(0)) || is_val<V>(args.get_pos(0)) || is_val<W>(args.get_pos(0));
-    JJ_DEBUG("test_type_fn: type=%s, %s, %s or %s result=%d", typeid(T).name(), typeid(U).name(), typeid(V).name(), typeid(W).name(), is_type ? 1 : 0);
-    return mk_val<value_bool>(is_type);
-}
 template<value_compare_op op>
 static value test_compare_fn(const func_args & args) {
    args.ensure_count(2, 2);
@@ -268,30 +261,6 @@ static value tojson(const func_args & args) {
    return mk_val<value_string>(json_str);
 }

-static value & get_attribute(const value & val, const value & attr, value & default_val) {
-    if (!attr->is_undefined()) {
-        if (is_val<value_array>(val)) {
-            value idx = attr;
-
-            if (is_val<value_string>(attr)) {
-                const std::string s = attr->as_string().str();
-                if (!s.empty() && std::all_of(s.begin(), s.end(), [](unsigned char c) { return std::isdigit(c); })) {
-                    try {
-                        idx = mk_val<value_int>(std::stoll(s));
-                    } catch (...) {
-                        idx = mk_val<value_undefined>();
-                    }
-                }
-            }
-
-            return val->at(idx, default_val);
-        } else if (is_val<value_object>(val)) {
-            return val->at(attr, default_val);
-        }
-    }
-    return default_val;
-}
-
 template<bool is_reject>
 static value selectattr(const func_args & args) {
    args.ensure_count(2, 4);
@@ -305,7 +274,10 @@ static value selectattr(const func_args & args) {
    if (args.count() == 2) {
        // example: array | selectattr("active")
        for (const auto & item : arr) {
-            value attr_val = get_attribute(item, attribute, val_default);
+            if (!is_val<value_object>(item)) {
+                throw raised_exception("selectattr: item is not an object");
+            }
+            value attr_val = item->at(attribute, val_default);
            bool is_selected = attr_val->as_bool();
            if constexpr (is_reject) is_selected = !is_selected;
            if (is_selected) out->push_back(item);
@@ -346,7 +318,10 @@ static value selectattr(const func_args & args) {
        }
        auto test_fn = it->second;
        for (const auto & item : arr) {
-            value attr_val = get_attribute(item, attribute, val_default);
+            if (!is_val<value_object>(item)) {
+                throw raised_exception("selectattr: item is not an object");
+            }
+            value attr_val = item->at(attribute, val_default);
            func_args test_args(args.ctx);
            test_args.push_back(attr_val); // attribute value
            test_args.push_back(extra_arg); // extra argument
@@ -373,43 +348,6 @@ static value default_value(const func_args & args) {
    return no_value ? args.get_pos(1) : args.get_pos(0);
 }

-static value toobject(const func_args & args) {
-    auto out = mk_val<value_object>();
-    value iter = args.get_pos(0, mk_val<value_undefined>());
-    bool iter_first = false;
-    if (is_val<value_array>(iter)) {
-        iter_first = true;
-        for (const auto & it : iter->as_array()) {
-            if (is_val<value_array>(it) && it->as_array().size() == 2) {
-                auto tuple = it->as_array();
-                auto key = tuple[0];
-                auto val = tuple[1];
-                JJ_DEBUG("namespace/dict: adding key '%s'", key->as_string().str().c_str());
-                out->insert(key, val);
-            } else {
-                throw raised_exception("namespace/dict() iterable argument must consist of tuples, not " + it->type());
-            }
-        }
-    } else if (is_val<value_object>(iter)) {
-        iter_first = true;
-        for (const auto & pair : iter->as_ordered_object()) {
-            JJ_DEBUG("namespace/dict: adding key '%s'", pair.first->as_string().str().c_str());
-            out->insert(pair.first, pair.second);
-        }
-    }
-    for (const auto & arg : args.get_args()) {
-        if (is_val<value_kwarg>(arg)) {
-            auto kwarg = cast_val<value_kwarg>(arg);
-            JJ_DEBUG("namespace/dict: adding key '%s'", kwarg->key.c_str());
-            out->insert(kwarg->key, kwarg->val);
-        } else if (!iter_first) {
-            throw raised_exception("namespace/dict() arguments must be kwargs, dict and/or iterable of tuples, not " + arg->type());
-        }
-        iter_first = false;
-    }
-    return out;
-}
-
 const func_builtins & global_builtins() {
    static const func_builtins builtins = {
        {"raise_exception", [](const func_args & args) -> value {
@@ -417,8 +355,18 @@ const func_builtins & global_builtins() {
            std::string msg = args.get_pos(0)->as_string().str();
            throw raised_exception("Jinja Exception: " + msg);
        }},
-        {"dict", toobject},
-        {"namespace", toobject},
+        {"namespace", [](const func_args & args) -> value {
+            auto out = mk_val<value_object>();
+            for (const auto & arg : args.get_args()) {
+                if (!is_val<value_kwarg>(arg)) {
+                    throw raised_exception("namespace() arguments must be kwargs");
+                }
+                auto kwarg = cast_val<value_kwarg>(arg);
+                JJ_DEBUG("namespace: adding key '%s'", kwarg->key.c_str());
+                out->insert(kwarg->key, kwarg->val);
+            }
+            return out;
+        }},
        {"strftime_now", [](const func_args & args) -> value {
            args.ensure_vals<value_string>();
            std::string format = args.get_pos(0)->as_string().str();
@@ -503,8 +451,8 @@ const func_builtins & global_builtins() {
        {"test_is_integer", test_type_fn<value_int>},
        {"test_is_float", test_type_fn<value_float>},
        {"test_is_number", test_type_fn<value_int, value_float>},
-        {"test_is_iterable", test_type_fn<value_object, value_array, value_string, value_undefined>},
-        {"test_is_sequence", test_type_fn<value_object, value_array, value_string, value_undefined>},
+        {"test_is_iterable", test_type_fn<value_array, value_string, value_undefined>},
+        {"test_is_sequence", test_type_fn<value_array, value_string, value_undefined>},
        {"test_is_mapping", test_type_fn<value_object>},
        {"test_is_lower", [](const func_args & args) -> value {
            args.ensure_vals<value_string>();
@@ -567,28 +515,8 @@ const func_builtins & global_builtins() {
        }},
        {"test_is_sameas", [](const func_args & args) -> value {
            // Check if an object points to the same memory address as another object
-            args.ensure_count(2);
-            auto a = args.get_pos(0);
-            auto b = args.get_pos(1);
-            bool res = false;
-            if (!is_val<value_undefined>(a) && !is_val<value_undefined>(b)) {
-                if (is_val<value_none>(a) && is_val<value_none>(b)) {
-                    res = true;
-                } else if (is_val<value_bool>(a) && is_val<value_bool>(b)) {
-                    if (a->as_bool() == b->as_bool()) {
-                        res = true;
-                    }
-                } else if (is_val<value_int>(a) && is_val<value_int>(b)) {
-                    const int64_t x = a->as_int();
-                    // Allow comparison within small-int cache range
-                    if (x >= -5 && x <= 256 && x == b->as_int()) {
-                        res = true;
-                    }
-                } else if (a == b) {
-                    res = true;
-                }
-            }
-            return mk_val<value_bool>(res);
+            (void)args;
+            throw not_implemented_exception("sameas test not implemented");
        }},
        {"test_is_escaped", [](const func_args & args) -> value {
            (void)args;
@@ -1093,14 +1021,22 @@ const func_builtins & value_array_t::get_builtins() const {
            }
            value val_delim = args.get_kwarg_or_pos("d",         1);
            value attribute = args.get_kwarg_or_pos("attribute", 2);
-            value undef = mk_val<value_undefined>();
            const auto & arr = args.get_pos(0)->as_array();
+            const bool attr_is_int = is_val<value_int>(attribute);
+            if (!attribute->is_undefined() && !is_val<value_string>(attribute) && !attr_is_int) {
+                throw raised_exception("join() attribute must be string or integer");
+            }
+            const int64_t attr_int = attr_is_int ? attribute->as_int() : 0;
            const std::string delim = val_delim->is_undefined() ? "" : val_delim->as_string().str();
            std::string result;
            for (size_t i = 0; i < arr.size(); ++i) {
                value val_arr = arr[i];
                if (!attribute->is_undefined()) {
-                    val_arr = get_attribute(val_arr, attribute, undef);
+                    if (attr_is_int && is_val<value_array>(val_arr)) {
+                        val_arr = val_arr->at(attr_int);
+                    } else if (!attr_is_int && is_val<value_object>(val_arr)) {
+                        val_arr = val_arr->at(attribute);
+                    }
                }
                if (!is_val<value_string>(val_arr) && !is_val<value_int>(val_arr) && !is_val<value_float>(val_arr)) {
                    throw raised_exception("join() can only join arrays of strings or numerics");
@@ -1132,11 +1068,21 @@ const func_builtins & value_array_t::get_builtins() const {
            }
            value val       = args.get_pos(0);
            value attribute = args.get_kwarg_or_pos("attribute", 1);
+            const bool attr_is_int = is_val<value_int>(attribute);
+            if (!is_val<value_string>(attribute) && !attr_is_int) {
+                throw raised_exception("map: attribute must be string or integer");
+            }
+            const int64_t attr_int = attr_is_int ? attribute->as_int() : 0;
            value default_val = args.get_kwarg("default", mk_val<value_undefined>());
            auto out = mk_val<value_array>();
            auto arr = val->as_array();
            for (const auto & item : arr) {
-                value attr_val = get_attribute(item, attribute, default_val);
+                value attr_val;
+                if (attr_is_int) {
+                    attr_val = is_val<value_array>(item) ? item->at(attr_int, default_val) : default_val;
+                } else {
+                    attr_val = is_val<value_object>(item) ? item->at(attribute, default_val) : default_val;
+                }
                out->push_back(attr_val);
            }
            return is_val<value_tuple>(val) ? mk_val<value_tuple>(std::move(out->as_array())) : out;
@@ -1173,14 +1119,22 @@ const func_builtins & value_array_t::get_builtins() const {
            // FIXME: sorting is currently always case sensitive
            //const bool case_sensitive = val_case->as_bool(); // undefined == false
            const bool reverse = val_reverse->as_bool(); // undefined == false
-            value undef = mk_val<value_undefined>();
+            const bool attr_is_int = is_val<value_int>(attribute);
+            const int64_t attr_int = attr_is_int ? attribute->as_int() : 0;
            std::vector<value> arr = val->as_array(); // copy
            std::sort(arr.begin(), arr.end(),[&](const value & a, const value & b) {
                value val_a = a;
                value val_b = b;
                if (!attribute->is_undefined()) {
-                    val_a = get_attribute(a, attribute, undef);
-                    val_b = get_attribute(b, attribute, undef);
+                    if (attr_is_int && is_val<value_array>(a) && is_val<value_array>(b)) {
+                        val_a = a->at(attr_int);
+                        val_b = b->at(attr_int);
+                    } else if (!attr_is_int && is_val<value_object>(a) && is_val<value_object>(b)) {
+                        val_a = a->at(attribute);
+                        val_b = b->at(attribute);
+                    } else {
+                        throw raised_exception("sort: unsupported object attribute comparison between " + a->type() + " and " + b->type());
+                    }
                }
                return value_compare(val_a, val_b, reverse ? value_compare_op::gt : value_compare_op::lt);
            });
@@ -1198,23 +1152,19 @@ const func_builtins & value_array_t::get_builtins() const {
            args.ensure_vals<value_array>();
            value val_case    = args.get_kwarg_or_pos("case_sensitive", 1);
            value attribute   = args.get_kwarg_or_pos("attribute",      2);
+            if (!attribute->is_undefined()) {
+                throw not_implemented_exception("min: attribute not implemented");
+            }
            // FIXME: min is currently always case sensitive
            (void) val_case;
-            value undef = mk_val<value_undefined>();
            const auto & arr = args.get_pos(0)->as_array();
            if (arr.empty()) {
-                return undef;
+                return mk_val<value_undefined>();
            }
            value result = arr[0];
-            for (const auto & item : arr) {
-                value val_arr = item;
-                value val_cmp = result;
-                if (!attribute->is_undefined()) {
-                    val_arr = get_attribute(val_arr, attribute, undef);
-                    val_cmp = get_attribute(val_cmp, attribute, undef);
-                }
-                if (value_compare(val_arr, val_cmp, value_compare_op::lt)) {
-                    result = item;
+            for (size_t i = 1; i < arr.size(); ++i) {
+                if (value_compare(arr[i], result, value_compare_op::lt)) {
+                    result = arr[i];
                }
            }
            return result;
@@ -1224,23 +1174,19 @@ const func_builtins & value_array_t::get_builtins() const {
            args.ensure_vals<value_array>();
            value val_case    = args.get_kwarg_or_pos("case_sensitive", 1);
            value attribute   = args.get_kwarg_or_pos("attribute",      2);
+            if (!attribute->is_undefined()) {
+                throw not_implemented_exception("max: attribute not implemented");
+            }
            // FIXME: max is currently always case sensitive
            (void) val_case;
-            value undef = mk_val<value_undefined>();
            const auto & arr = args.get_pos(0)->as_array();
            if (arr.empty()) {
-                return undef;
+                return mk_val<value_undefined>();
            }
            value result = arr[0];
-            for (const auto & item : arr) {
-                value val_arr = item;
-                value val_cmp = result;
-                if (!attribute->is_undefined()) {
-                    val_arr = get_attribute(val_arr, attribute, undef);
-                    val_cmp = get_attribute(val_cmp, attribute, undef);
-                }
-                if (value_compare(val_arr, val_cmp, value_compare_op::gt)) {
-                    result = item;
+            for (size_t i = 1; i < arr.size(); ++i) {
+                if (value_compare(arr[i], result, value_compare_op::gt)) {
+                    result = arr[i];
                }
            }
            return result;
@@ -433,12 +433,6 @@ struct value_array_t : public value_t {
        }
        return val_arr[index];
    }
-    virtual value & at(const value & index, value & default_val) override {
-        if (!is_val<value_int>(index) && !is_val<value_bool>(index)) {
-            return default_val;
-        }
-        return at(index->as_int(), default_val);
-    }
    virtual const func_builtins & get_builtins() const override;
    virtual bool is_hashable() const override {
        if (std::all_of(val_arr.begin(), val_arr.end(), [&](auto & val) -> bool {
@@ -321,8 +321,7 @@ static size_t gbnf_escape_length(const std::string & pattern, size_t pos) {
        case 'x': n_hex = 2; break;
        case 'u': n_hex = 4; break;
        case 'U': n_hex = 8; break;
-        // keep in sync with parse_char() in src/llama-grammar.cpp
-        case 't': case 'r': case 'n': case '\\': case '"': case '[': case ']': case '-':
+        case 't': case 'r': case 'n': case '\\': case '"': case '[': case ']':
            return 2;
        default:
            return 0;
@@ -82,9 +82,6 @@ struct common_json_value {
    // note: a nested pair {"a", "b"} does not build, use common_json::array({"a", "b"}) for an array
    common_json_value(std::initializer_list<common_json_item> items);

-    template <typename T, typename std::enable_if<std::is_enum<T>::value, int>::type = 0>
-    common_json_value(T val) : common_json_value((typename std::underlying_type<T>::type) val) {}
-
    template <typename T, typename std::enable_if<std::is_integral<T>::value && !std::is_same<T, bool>::value, int>::type = 0>
    common_json_value(T val) : type(std::is_signed<T>::value ? VAL_INT : VAL_UINT) {
        if (std::is_signed<T>::value) {
@@ -114,7 +111,6 @@ struct common_json_item {
 // the types common_json_value holds on its own
 // anything else reaches its common_json ctor and recurses forever
 template <typename T> struct common_json_is_value : std::integral_constant<bool,
-    std::is_enum<T>::value ||
    std::is_arithmetic<T>::value ||
    std::is_same<T, std::nullptr_t>::value ||
    std::is_same<T, std::string>::value ||
@@ -14,6 +14,19 @@
 #include <vector>
 #include <algorithm>

+#if defined(_WIN32)
+#    define WIN32_LEAN_AND_MEAN
+#    ifndef NOMINMAX
+#       define NOMINMAX
+#    endif
+#    include <io.h>
+#    include <windows.h>
+#    define isatty _isatty
+#    define fileno _fileno
+#else
+#    include <unistd.h>
+#endif // defined(_WIN32)
+
 int common_log_verbosity_thold = LOG_DEFAULT_LLAMA;

 int common_log_get_verbosity_thold(void) {
@@ -24,16 +37,6 @@ void common_log_set_verbosity_thold(int verbosity) {
    common_log_verbosity_thold = verbosity;
 }

-static bool common_log_jsonl = false;
-
-bool common_log_get_jsonl(void) {
-    return common_log_jsonl;
-}
-
-void common_log_set_jsonl(bool jsonl) {
-    common_log_jsonl = jsonl;
-}
-
 static int64_t t_us() {
    return std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
 }
@@ -84,7 +87,6 @@ struct common_log_entry {
    bool is_end       { false }; // signals the worker thread to stop
    bool prefix       { false };
    bool jsonl        { false };
-    bool is_json      { false }; // msg already holds a serialized JSON object

    common_log_entry(size_t size = 256) : msg(size) { }

@@ -105,12 +107,6 @@ struct common_log_entry {
        }

        if (jsonl) {
-            if (is_json) {
-                fprintf(fcur, "%s\n", msg.data());
-                fflush(fcur);
-                return;
-            }
-
            common_json obj = {
                {"type",  "log"},
                {"time",  timestamp},
@@ -160,6 +156,7 @@ struct common_log {
        file       = nullptr;
        prefix     = false;
        timestamps = false;
+        jsonl      = false;
        running    = false;
        t_start    = t_us();

@@ -187,6 +184,7 @@ private:

    bool prefix;
    bool timestamps;
+    bool jsonl;
    bool running;

    int64_t t_start;
@@ -275,8 +273,7 @@ public:
        entry.is_end    = false;
        entry.level     = level;
        entry.prefix    = prefix;
-        entry.jsonl     = common_log_jsonl;
-        entry.is_json   = false;
+        entry.jsonl     = jsonl;
        entry.timestamp = 0;
        if (timestamps) {
            entry.timestamp = t_us() - t_start;
@@ -286,42 +283,6 @@ public:
        cv_new.notify_one();
    }

-    void add_json(const char * type, const common_json & obj) {
-        const common_json full = {
-            {"type", type},
-            {"data", obj},
-        };
-
-        const std::string text = full.dump_safe();
-
-        std::unique_lock<std::mutex> lock(mtx);
-
-        // block if the queue is full
-        cv_full.wait(lock, [this]() { return !running || !is_full(); });
-
-        if (!running) {
-            // discard messages while the worker thread is paused
-            return;
-        }
-
-        auto & entry = queue[tail];
-
-        if (entry.msg.size() < text.size() + 1) {
-            entry.msg.resize(text.size() + 1);
-        }
-        memcpy(entry.msg.data(), text.c_str(), text.size() + 1);
-
-        entry.is_end    = false;
-        entry.level     = GGML_LOG_LEVEL_NONE;
-        entry.prefix    = false;
-        entry.jsonl     = true;
-        entry.is_json   = true;
-        entry.timestamp = 0;
-
-        tail = (tail + 1) % queue.size();
-        cv_new.notify_one();
-    }
-
    void resume() {
        std::lock_guard<std::mutex> lock(mtx);

@@ -427,6 +388,12 @@ public:

        this->timestamps = timestamps;
    }
+
+    void set_jsonl(bool jsonl) {
+        std::lock_guard<std::mutex> lock(mtx);
+
+        this->jsonl = jsonl;
+    }
 };

 //
@@ -473,14 +440,6 @@ void common_log_add(struct common_log * log, enum ggml_log_level level, const ch
    va_end(args);
 }

-void common_log_add_json(struct common_log * log, const char * type, const common_json & obj) {
-    if (!common_log_jsonl) {
-        return;
-    }
-
-    log->add_json(type, obj);
-}
-
 void common_log_set_file(struct common_log * log, const char * file) {
    log->set_file(file);
 }
@@ -508,6 +467,10 @@ void common_log_set_timestamps(struct common_log * log, bool timestamps) {
    log->set_timestamps(timestamps);
 }

+void common_log_set_jsonl(struct common_log * log, bool jsonl) {
+    log->set_jsonl(jsonl);
+}
+
 void common_log_flush(struct common_log * log) {
    log->pause();
    log->resume();
@@ -43,10 +43,6 @@ int  common_log_get_verbosity_thold(void);

 void common_log_set_verbosity_thold(int verbosity); // not thread-safe

-bool common_log_get_jsonl(void);
-
-void common_log_set_jsonl(bool jsonl); // not thread-safe
-
 int common_log_get_verbosity(enum ggml_log_level level);

 void common_log_default_callback(enum ggml_log_level level, const char * text, void * user_data);
@@ -95,6 +91,7 @@ void common_log_set_file      (struct common_log * log, const char * file); // n
 void common_log_set_colors    (struct common_log * log, log_colors colors); // not thread-safe
 void common_log_set_prefix    (struct common_log * log, bool prefix);       // whether to output prefix to each log
 void common_log_set_timestamps(struct common_log * log, bool timestamps);   // whether to output timestamps in the prefix
+void common_log_set_jsonl     (struct common_log * log, bool jsonl);        // print each log as a JSON object on one line, not thread-safe
 void common_log_flush         (struct common_log * log);                    // flush all pending log messages

 // helper macros for logging
@@ -130,17 +127,3 @@ void common_log_flush         (struct common_log * log);                    // f
 #define LOG_WRNV(verbosity, ...) LOG_TMPL(GGML_LOG_LEVEL_WARN,  verbosity, __VA_ARGS__)
 #define LOG_ERRV(verbosity, ...) LOG_TMPL(GGML_LOG_LEVEL_ERROR, verbosity, __VA_ARGS__)
 #define LOG_CNTV(verbosity, ...) LOG_TMPL(GGML_LOG_LEVEL_CONT,  verbosity, __VA_ARGS__)
-
-class common_json; // defined in common/json.h
-
-// helper allows different types of json output
-// no-op if --log-jsonl is not set
-void common_log_add_json(struct common_log * log, const char * type, const common_json & data);
-
-// will only print if --log-jsonl is set
-#define LOG_JSON(type, data) \
-    do { \
-        if (common_log_get_jsonl()) { \
-            common_log_add_json(common_log_main(), type, data); \
-        } \
-    } while (0)
@@ -104,12 +104,6 @@ common_chat_params common_chat_params_init_deepseek_v3_2(const common_chat_templ
    const std::string GEN_PROMPT   = "<｜Assistant｜>";
    const std::string TC_SEPARATOR = "\n\n";

-    // lets the server find user turns in the prompt and place context checkpoints there
-    data.message_delimiters = {
-        { COMMON_CHAT_ROLE_ASSISTANT, GEN_PROMPT },
-        { COMMON_CHAT_ROLE_USER, "<｜User｜>" },
-    };
-
    data.prompt = common_chat_template_direct_apply_impl(
        tmpl, inputs, adjusted_messages, std::nullopt, additional_context);
    data.generation_prompt = common_chat_template_generation_prompt_impl(
@@ -272,10 +272,6 @@ common_chat_params common_chat_params_init_gemma4(const common_chat_template &
                /* max = */ inputs.parallel_tool_calls ? -1 : 1
            ));

-            if (inputs.tool_choice == COMMON_CHAT_TOOL_CHOICE_REQUIRED) {
-                return start + thought + tool_call;
-            }
-
            auto scan_to_toolcall = p.rule("scan-to-toolcall", p.until("<|tool_call>"));
            auto content = p.rule("content", p.content(p.until_one_of({"<|channel>", "<channel|>", "<|tool_call>"})));
            auto message = p.rule("message", thought + content);
@@ -1,202 +0,0 @@
-#include "parsers.h"
-
-// Ling 3.0 / Bailing V3 - <role>X</role> sections with tagged tool calls:
-//   assistant := [<think> ... </think>] [content] {<tool_call>name
-//                  <arg_key>k</arg_key>\n<arg_value>v</arg_value> ...</tool_call>}
-// The generation prompt ends with "<role>ASSISTANT</role>\n<think>", so the model
-// never emits the opening think tag, and a tool call can arrive before any
-// </think>. Reasoning therefore terminates at the think close tag or at a tool
-// call start, like the Qwen3-Coder and Kimi K3 parsers. With thinking off the
-// template pre-closes the think block instead, and the model emits bare content.
-common_chat_params common_chat_params_init_ling3(const common_chat_template &          tmpl,
-                                                        const autoparser::generation_params & inputs) {
-    common_chat_params data;
-
-    data.prompt            = common_chat_template_direct_apply_impl(tmpl, inputs);
-    data.generation_prompt = common_chat_template_generation_prompt_impl(tmpl, inputs);
-    data.format            = COMMON_CHAT_FORMAT_PEG_NATIVE;
-    data.supports_thinking = true;
-
-    const std::string ROLE        = "<role>ASSISTANT</role>";
-    const std::string THINK_START = "<think>";
-    const std::string THINK_END   = "</think>";
-    const std::string CALL_START  = "<tool_call>";
-    const std::string CALL_END    = "</tool_call>";
-    const std::string ARG_KEY     = "<arg_key>";
-    const std::string ARG_KEY_END = "</arg_key>";
-    const std::string ARG_VAL     = "<arg_value>";
-    const std::string ROLE_END    = "<|role_end|>";
-    const std::string ARG_VAL_END = "</arg_value>";
-
-    data.preserved_tokens = {
-        THINK_START, THINK_END, CALL_START, CALL_END,
-        ARG_KEY, ARG_KEY_END, ARG_VAL, ARG_VAL_END, ROLE_END,
-    };
-
-    data.thinking_start_tag = THINK_START;
-    // Support both </think> and <tool_call> as reasoning end sequences: a call
-    // can be emitted before the think block is closed.
-    data.thinking_end_tags  = { THINK_END, CALL_START };
-
-    data.message_delimiters = {
-        { COMMON_CHAT_ROLE_ASSISTANT, "<role>ASSISTANT</role>" },
-        { COMMON_CHAT_ROLE_USER,      "<role>HUMAN</role>"     },
-        { COMMON_CHAT_ROLE_TOOL,      "<role>OBSERVATION</role>" },
-        { COMMON_CHAT_ROLE_SYSTEM,    "<role>SYSTEM</role>"    },
-    };
-
-    // the model may spell the end-of-turn control token out as text tokens,
-    // which does not stop generation; a literal stop string catches it either
-    // way (as the Laguna patch does for its </assistant> token)
-    data.additional_stops = { ROLE_END };
-
-    if (inputs.has_continuation()) {
-        const auto & msg = inputs.continue_msg;
-
-        data.generation_prompt = ROLE + "\n" + THINK_START + msg.reasoning_content;
-        if (inputs.continue_final_message == COMMON_CHAT_CONTINUATION_CONTENT) {
-            data.generation_prompt += THINK_END + msg.render_content();
-        }
-
-        data.prompt += data.generation_prompt;
-    }
-
-    // The generation prompt pre-opens the think block when thinking is on, so
-    // the opening tag is optional here and reasoning runs until </think> or a
-    // tool call start; with thinking off the template pre-closes the block and
-    // everything the model emits is content.
-    bool think_open = false;
-    if (inputs.has_continuation()) {
-        think_open = inputs.continue_final_message != COMMON_CHAT_CONTINUATION_CONTENT;
-    } else {
-        auto last_open  = data.generation_prompt.rfind(THINK_START);
-        auto last_close = data.generation_prompt.rfind(THINK_END);
-        think_open      = last_open != std::string::npos &&
-                     (last_close == std::string::npos || last_open > last_close);
-    }
-
-    auto has_tools           = inputs.tools.is_array() && !inputs.tools.empty();
-    auto has_response_format = inputs.json_schema.is_object() && !inputs.json_schema.empty();
-    auto extract_reasoning   = inputs.reasoning_format != COMMON_REASONING_FORMAT_NONE;
-    auto include_grammar     = has_response_format || (has_tools && inputs.tool_choice != COMMON_CHAT_TOOL_CHOICE_NONE);
-
-    auto parser = build_chat_peg_parser([&](common_chat_peg_builder & p) {
-        auto end = p.end();
-
-        // the effective parse input is generation_prompt + model output, so the
-        // assistant opener is optionally consumed here
-        auto opener = p.optional(p.literal(ROLE) + p.optional(p.space()));
-
-        // the generation prompt pre-opens the think block, so the opening tag
-        // is optional; a missing close tag does not swallow a tool call
-        auto body_end   = think_open ? p.until_one_of({ THINK_END, CALL_START }) : p.until_one_of({ THINK_END });
-        auto think_body = extract_reasoning ? p.reasoning(body_end) : p.content(body_end);
-
-        auto reasoning = p.optional(p.optional(p.literal(THINK_START)) + think_body +
-                                    p.optional(p.literal(THINK_END)));
-
-        // content between the think block and the first tool call, plus any
-        // trailing text after the last tool call, are plain content
-        auto content = p.optional(p.content(p.until_one_of({ CALL_START })));
-
-        // a trailing end-of-turn token is consumed instead of leaking into content
-        auto tail = p.optional(p.content(p.until(ROLE_END))) + p.optional(p.literal(ROLE_END));
-
-        // the think block must close before the JSON, so the turn cannot end inside the reasoning
-        if (has_response_format) {
-            auto closed_reasoning = p.literal(THINK_START) + think_body + p.literal(THINK_END);
-            auto response_format  = p.content(p.schema(p.json(), "response-format", inputs.json_schema));
-            return opener + (closed_reasoning << response_format) + end;
-        }
-
-        if (!has_tools || inputs.tool_choice == COMMON_CHAT_TOOL_CHOICE_NONE) {
-            return opener + reasoning + tail + end;
-        }
-
-        auto tool_choices = p.choice();
-        auto arg_close    = p.tool_arg_close(p.literal(ARG_VAL_END));
-        auto arg_string   = p.rule("ling3-arg-string",
-                                   p.tool_arg_string_value(p.until(ARG_VAL_END)) + arg_close);
-
-        foreach_function(inputs.tools, [&](const json & tool) {
-            const auto & function = tool.at("function");
-            std::string  name     = function.at("name");
-
-            std::vector<common_peg_parser> required_args;
-            std::vector<common_peg_parser> optional_args;
-
-            // each argument may be preceded by whitespace: the model emits
-            // newlines between arguments, the template history does not
-            foreach_parameter(function, [&](const common_chat_schema_property & param, const common_chat_schema_document_ptr & doc) {
-                auto rule_name = "ling3-arg-" + name + "-" + param.name;
-
-                auto types = param.schema->value_types();
-
-                // string arguments are raw text up to the closing tag, other
-                // types parse as JSON per their schema; each alternative
-                // consumes the closing tag itself so a JSON prefix can not
-                // commit the choice before the tag matches
-                auto arg_value = p.eps();
-                if (!types.has(common_chat_schema::TYPE_STRING)) {
-                    arg_value = p.tool_arg_json_value(p.schema(p.json(), rule_name + "-schema", doc, *param.schema)) + arg_close;
-                } else if (types.is_only(common_chat_schema::TYPE_STRING)) {
-                    arg_value = arg_string;
-                } else {
-                    // the parser tries the JSON alternative first to type the value
-                    arg_value = p.gbnf(p.atomic(p.tool_arg_json_value(p.schema(p.json(), rule_name + "-schema", doc, *param.schema)) + arg_close) | arg_string,
-                                       "ling3-arg-string");
-                }
-
-                auto arg = p.rule(rule_name,
-                    p.optional(p.space()) +
-                    p.tool_arg(p.tool_arg_open(p.literal(ARG_KEY) + p.tool_arg_name(p.literal(param.name)) +
-                                               p.literal(ARG_KEY_END)) +
-                               p.optional(p.space()) + p.literal(ARG_VAL) +
-                               arg_value));
-
-                (param.required ? required_args : optional_args).push_back(arg);
-            });
-
-            // required arguments in any order (as Qwen3-Coder does), then
-            // optional ones in any order and number
-            auto args = p.permute("ling3-" + name + "-args", required_args);
-            if (!optional_args.empty()) {
-                args = args + p.zero_or_more(p.choice(optional_args));
-            }
-
-            auto call = p.tool(p.tool_open(p.literal(CALL_START) + p.tool_name(p.literal(name)) +
-                                           p.optional(p.space())) +
-                               p.tool_args(args) +
-                               p.tool_close(p.optional(p.space()) + p.literal(CALL_END)));
-
-            tool_choices |= p.rule("ling3-tool-" + name, call);
-        });
-
-        auto calls = inputs.parallel_tool_calls ?
-                     tool_choices + p.zero_or_more(p.space() + tool_choices) :
-                     tool_choices;
-
-        auto tools_section = p.trigger_rule("ling3-tool-call", calls + p.space() +
-                                        p.optional(p.content(p.until(ROLE_END))) + p.optional(p.literal(ROLE_END)));
-
-        auto tools = inputs.tool_choice == COMMON_CHAT_TOOL_CHOICE_REQUIRED ? tools_section :
-                                                                             p.optional(tools_section);
-
-        return opener + reasoning + content + tools + tail + end;
-    });
-
-    data.parser = parser.save();
-
-    if (include_grammar) {
-        data.grammar_lazy = !has_response_format && inputs.tool_choice != COMMON_CHAT_TOOL_CHOICE_REQUIRED;
-        data.grammar      = build_grammar([&](const common_grammar_builder & builder) {
-            parser.build_grammar(builder, data.grammar_lazy);
-        });
-
-        data.grammar_triggers = {
-            { COMMON_GRAMMAR_TRIGGER_TYPE_WORD, CALL_START },
-        };
-    }
-
-    return data;
-}
@@ -1,164 +0,0 @@
-#include "parsers.h"
-
-// LLM-jp-4.1: the GPT-OSS (Harmony) format with two differences
-//  - the tokenizer emits a space after every special token: "<|channel|> analysis<|message|> ..."
-//  - parallel tool calls are consecutive assistant messages, all but the last closed by <|end|>
-common_chat_params common_chat_params_init_llm_jp_harmony(const common_chat_template &          tmpl,
-                                                          const autoparser::generation_params & inputs) {
-    common_chat_params data;
-
-    // Copy reasoning to the "thinking" field as expected by the template
-    auto adjusted_messages = json::array();
-    for (auto msg : inputs.messages) {
-        if (msg.contains("reasoning_content") && msg.at("reasoning_content").is_string()) {
-            msg["thinking"] = msg.at("reasoning_content");
-            if (msg.contains("tool_calls") && msg.at("tool_calls").is_array() && !msg.at("tool_calls").empty()) {
-                msg.erase("content");
-            }
-        }
-        adjusted_messages.push_back(msg);
-    }
-
-    auto prompt = common_chat_template_direct_apply_impl(tmpl, inputs, /* messages_override= */ adjusted_messages);
-
-    // Check if we need to replace the return token with end token during
-    // inference and without generation prompt. For more details see:
-    // https://github.com/ggml-org/llama.cpp/issues/15417
-    if (inputs.is_inference && !inputs.add_generation_prompt) {
-        static constexpr std::string_view return_token = "<|return|>";
-        static constexpr std::string_view end_token    = "<|end|>";
-        if (size_t pos = prompt.rfind(return_token); pos != std::string::npos) {
-            prompt.replace(pos, return_token.length(), end_token);
-        }
-    }
-
-    data.prompt            = prompt;
-    data.generation_prompt = common_chat_template_generation_prompt_impl(tmpl, inputs, /* messages_override= */ adjusted_messages);
-    data.message_delimiters = {
-        { COMMON_CHAT_ROLE_ASSISTANT, "<|start|>assistant" },
-        { COMMON_CHAT_ROLE_USER,      "<|start|>user"      },
-        { COMMON_CHAT_ROLE_SYSTEM,    "<|start|>developer" },
-        { COMMON_CHAT_ROLE_SYSTEM,    "<|start|>system"    },
-        { COMMON_CHAT_ROLE_TOOL,      "<|start|>functions" },
-    };
-
-    data.format            = COMMON_CHAT_FORMAT_PEG_NATIVE;
-    data.supports_thinking = true;
-
-    data.thinking_start_tag = "<|channel|>analysis<|message|>";
-    data.thinking_end_tags  = {"<|end|>"};
-
-    // These special tokens are required to parse properly, so we include them
-    // even if parse_tool_calls is false.
-    data.preserved_tokens = {
-        "<|channel|>", "<|constrain|>", "<|message|>", "<|start|>", "<|end|>",
-    };
-
-    // Adjust prompt for continuation
-    if (inputs.has_continuation()) {
-        const auto & msg = inputs.continue_msg;
-
-        data.generation_prompt = "<|start|>assistant<|channel|>analysis<|message|>" + msg.reasoning_content;
-        if (inputs.continue_final_message == COMMON_CHAT_CONTINUATION_CONTENT) {
-            data.generation_prompt += "<|end|><|start|>assistant<|channel|>final<|message|>" + msg.render_content();
-        }
-
-        data.prompt += data.generation_prompt;
-    }
-
-    auto has_tools           = inputs.tools.is_array() && !inputs.tools.empty();
-    auto has_response_format = !inputs.json_schema.is_null() && inputs.json_schema.is_object();
-    auto include_grammar     = has_response_format || (has_tools && inputs.tool_choice != COMMON_CHAT_TOOL_CHOICE_NONE);
-    auto extract_reasoning   = inputs.reasoning_format != COMMON_REASONING_FORMAT_NONE;
-
-    auto parser = build_chat_peg_parser([&](common_chat_peg_builder & p) {
-        // tokenizer space after special tokens; not p.space() since GBNF `space` allows one space only
-        auto sp          = p.chars("[ ]", 0, -1);
-        auto channel_tag = p.literal("<|channel|>") + sp;
-        // one space only: keep an intentional leading space in the body
-        auto message     = p.literal("<|message|>") + p.optional(p.literal(" "));
-
-        auto start          = p.rule("start", p.literal("<|start|>") + sp + p.literal("assistant"));
-        auto end            = p.rule("end", p.literal("<|end|>"));
-        auto content        = p.rule("message-content", p.until("<|end|>"));
-        auto channel        = channel_tag + (p.literal("commentary") | p.literal("analysis"));
-        auto constrain_type = p.chars("[A-Za-z0-9_-]", 1, -1);
-        auto constraint     = p.optional(p.space() + p.optional(p.literal("<|constrain|>") + sp) + constrain_type);
-
-        auto start_analysis = channel_tag + p.literal("analysis") + message;
-        if (extract_reasoning) {
-            p.rule("analysis", start_analysis + p.reasoning(content) + end);
-        } else {
-            p.rule("analysis", p.content(start_analysis + content + end));
-        }
-
-        auto analysis  = p.ref("analysis");
-        auto preamble  = p.rule("preamble", channel_tag + p.literal("commentary") + message + p.content(content) + end);
-        auto final_msg = p.rule("final", channel_tag + p.literal("final") + message + p.content(content));
-
-        auto any = p.rule("any", preamble | analysis);
-
-        if (has_response_format) {
-            auto response_format = p.rule("response-format",
-                channel_tag + p.literal("final") + constraint + message +
-                p.content(p.schema(p.json(), "response-format-schema", inputs.json_schema)));
-
-            return p.zero_or_more(start + analysis) + start + response_format;
-        }
-
-        if (has_tools && inputs.tool_choice != COMMON_CHAT_TOOL_CHOICE_NONE) {
-            auto tool_choice = p.choice();
-
-            foreach_function(inputs.tools, [&](const json & tool) {
-                const auto & function = tool.at("function");
-                std::string  name     = function.at("name");
-                const auto   params   = common_chat_tool_parameters(function);
-
-                auto func_name = p.literal(" to=functions.") + p.tool_name(p.literal(name));
-                auto args      = p.tool_args(p.schema(p.json(), "tool-" + name + "-schema", params));
-
-                // recipient in role header
-                //   <|start|>assistant to=functions.NAME<|channel|>(commentary|analysis)[constraint]<|message|>ARGS
-                auto tool_in_role = p.tool(p.tool_open(func_name + channel + constraint + message) + args);
-
-                // recipient in channel header
-                //   <|channel|>(commentary|analysis) to=functions.NAME[constraint]<|message|>ARGS
-                auto tool_in_channel = p.tool(p.tool_open(channel + func_name + constraint + message) + args);
-
-                tool_choice |= p.rule("tool-" + name, tool_in_role | tool_in_channel);
-            });
-
-            // parallel calls are separated by <|end|>; inside the trigger rule so the lazy grammar covers all of them
-            auto tool_calls = inputs.parallel_tool_calls
-                ? tool_choice + p.zero_or_more(end + start + tool_choice)
-                : tool_choice;
-            auto tool_call  = p.trigger_rule("tool-call", tool_calls);
-
-            if (inputs.tool_choice == COMMON_CHAT_TOOL_CHOICE_REQUIRED) {
-                return p.zero_or_more(start + any) + start + tool_call;
-            }
-
-            return p.zero_or_more(start + any) + start + (tool_call | final_msg);
-        }
-
-        return p.zero_or_more(start + any) + start + final_msg;
-    });
-
-    data.parser = parser.save();
-
-    if (include_grammar) {
-        data.grammar_lazy = !(has_response_format || (has_tools && inputs.tool_choice == COMMON_CHAT_TOOL_CHOICE_REQUIRED));
-        data.grammar      = build_grammar([&](const common_grammar_builder & builder) {
-            parser.build_grammar(builder, data.grammar_lazy);
-        });
-
-        data.grammar_triggers = {
-            { COMMON_GRAMMAR_TRIGGER_TYPE_PATTERN, "^\\s+to$" },
-            { COMMON_GRAMMAR_TRIGGER_TYPE_PATTERN, "^<\\|channel\\|>\\s*(?:commentary|analysis)\\s+to=functions$" },
-            { COMMON_GRAMMAR_TRIGGER_TYPE_PATTERN, "<\\|start\\|>\\s*assistant(\\s+to)" },
-            { COMMON_GRAMMAR_TRIGGER_TYPE_PATTERN, "<\\|start\\|>\\s*assistant(<\\|channel\\|>\\s*(?:commentary|analysis)\\s+to)" }
-        };
-    }
-
-    return data;
-}
@@ -43,10 +43,9 @@ common_chat_params common_chat_params_init_muse_glimmer(const common_chat_templa

    auto extract_reasoning = inputs.reasoning_format != COMMON_REASONING_FORMAT_NONE;

-    auto has_tools           = inputs.tools.is_array() && !inputs.tools.empty();
-    auto has_response_format = !inputs.json_schema.is_null() && inputs.json_schema.is_object();
-    // Constrained grammar whenever tools are offered or a response format is requested.
-    auto include_grammar     = has_response_format || (has_tools && inputs.tool_choice != COMMON_CHAT_TOOL_CHOICE_NONE);
+    auto has_tools = inputs.tools.is_array() && !inputs.tools.empty();
+    // Constrained grammar whenever tools are offered.
+    auto include_grammar = has_tools && inputs.tool_choice != COMMON_CHAT_TOOL_CHOICE_NONE;

    auto parser = build_chat_peg_parser([&](common_chat_peg_builder & p) {
        auto start = p.rule("start", p.literal("<|start|>assistant"));
@@ -66,15 +65,6 @@ common_chat_params common_chat_params_init_muse_glimmer(const common_chat_templa
        auto final_msg  = p.rule("final", recipient + p.literal("<|message|>") +
                                              p.content(p.until_one_of({ "<|eot|>", "<|eom|>" })));

-        if (has_response_format) {
-            auto response_json   = p.content(p.schema(p.json(), "response-format-schema", inputs.json_schema));
-            auto response_format = p.rule("response-format",
-                recipient + p.literal("<|message|>") +
-                ((p.literal("```json") + p.space() + response_json + p.space() + p.literal("```")) | response_json));
-
-            return p.zero_or_more(start + analysis) + start + response_format;
-        }
-
        if (has_tools && inputs.tool_choice != COMMON_CHAT_TOOL_CHOICE_NONE) {
            auto string_value = p.ac(
                p.tool_arg_string_value(p.until("</atem:parameter>")) + p.tool_arg_close(p.literal("</atem:parameter>")),
@@ -134,13 +124,13 @@ common_chat_params common_chat_params_init_muse_glimmer(const common_chat_templa
    data.parser = parser.save();

    if (include_grammar) {
-        data.grammar_lazy = !(has_response_format || (has_tools && inputs.tool_choice == COMMON_CHAT_TOOL_CHOICE_REQUIRED));
+        data.grammar_lazy = inputs.tool_choice != COMMON_CHAT_TOOL_CHOICE_REQUIRED;
        data.grammar      = build_grammar([&](const common_grammar_builder & builder) {
            parser.build_grammar(builder, data.grammar_lazy);
        });
        data.grammar_triggers = {
            { COMMON_GRAMMAR_TRIGGER_TYPE_PATTERN,
-              "(?:^|<\\|start\\|>assistant)( to=(?!self<\\|message\\|>)(?!user<\\|message\\|>)[^<]*?<\\|message\\|>)" },
+              "<\\|start\\|>assistant( to=(?!self<\\|message\\|>)(?!user<\\|message\\|>)[^<]*?<\\|message\\|>)" },
        };
    }

@@ -63,13 +63,9 @@ common_chat_params common_chat_params_init_kimi_k2(const common_chat_template &

 common_chat_params common_chat_params_init_kimi_k3(const common_chat_template & tmpl, const autoparser::generation_params & inputs);

-common_chat_params common_chat_params_init_ling3(const common_chat_template & tmpl, const autoparser::generation_params & inputs);
-
 // tool_list_tokens preserves the LFM2 system tool-list markers; LFM2.5 renders without them
 common_chat_params common_chat_params_init_lfm2(const common_chat_template & tmpl, const autoparser::generation_params & inputs, bool tool_list_tokens);

-common_chat_params common_chat_params_init_llm_jp_harmony(const common_chat_template & tmpl, const autoparser::generation_params & inputs);
-
 common_chat_params common_chat_params_init_minicpm5(const common_chat_template & tmpl, const autoparser::generation_params & inputs);

 common_chat_params common_chat_params_init_minimax_m3(const common_chat_template & tmpl, const autoparser::generation_params & inputs);
@@ -23,9 +23,8 @@ common_chat_params common_chat_params_init_qwen3_coder(const common_chat_templat
    if (supports_reasoning) {
        data.thinking_start_tag = "<think>";
        // Support both </think> and <tool_call> as reasoning end sequences.
-        // The newline variant comes first so it is included in the forced message
        // <function= is omitted, as it is a workaround for Qwen3-Coder which is not a thinking model
-        data.thinking_end_tags = { "\n</think>", "</think>", "<tool_call>" };
+        data.thinking_end_tags = { "</think>", "<tool_call>" };
        data.preserved_tokens.insert(data.preserved_tokens.end(), { "<think>", "</think>" });
    }

@@ -105,34 +104,9 @@ common_chat_params common_chat_params_init_qwen3_coder(const common_chat_templat

                    auto arg_open = p.tool_arg_open("<parameter=" + p.tool_arg_name(p.literal(param.name)) + ">\n");

-                    auto types = param.schema->value_types();
-
-                    auto arg_value = p.eps();
-                    if (!types.has(common_chat_schema::TYPE_STRING)) {
-                        arg_value = p.tool_arg_json_value(p.schema(p.json(), rule_name + "-schema", doc, *param.schema)) + arg_close;
-                    } else if (types.is_only(common_chat_schema::TYPE_STRING)) {
-                        arg_value = arg_string;
-                    } else {
-                        // The string alternative accepts any text, so the grammar only keeps the raw string
-                        // rule. The parser still tries the JSON alternatives first to type the value.
-                        auto json_value = p.choice();
-                        if (types.has(common_chat_schema::TYPE_OBJECT)) {
-                            json_value |= p.json_object();
-                        }
-                        if (types.has(common_chat_schema::TYPE_ARRAY)) {
-                            json_value |= p.json_array();
-                        }
-                        if (types.has(common_chat_schema::TYPE_NUMBER) || types.has(common_chat_schema::TYPE_INTEGER)) {
-                            json_value |= p.json_number();
-                        }
-                        if (types.has(common_chat_schema::TYPE_BOOLEAN)) {
-                            json_value |= p.json_bool();
-                        }
-                        if (types.has(common_chat_schema::TYPE_NULL)) {
-                            json_value |= p.json_null();
-                        }
-                        arg_value = p.gbnf(p.atomic(p.tool_arg_json_value(json_value) + arg_close) | arg_string, "xml-arg-string");
-                    }
+                    auto arg_value = param.schema->may_be_string() ?
+                        arg_string :
+                        p.tool_arg_json_value(p.schema(p.json(), rule_name + "-schema", doc, *param.schema)) + arg_close;

                    auto arg_rule = p.rule(rule_name, p.tool_arg(arg_open + arg_value));

@@ -11,9 +11,7 @@ set(LLAMA_CHAT_PARSERS_SOURCES
    ${CMAKE_CURRENT_LIST_DIR}/gpt-oss.cpp
    ${CMAKE_CURRENT_LIST_DIR}/kimi-k2.cpp
    ${CMAKE_CURRENT_LIST_DIR}/kimi-k3.cpp
-    ${CMAKE_CURRENT_LIST_DIR}/ling3.cpp
    ${CMAKE_CURRENT_LIST_DIR}/lfm2.cpp
-    ${CMAKE_CURRENT_LIST_DIR}/llm-jp-harmony.cpp
    ${CMAKE_CURRENT_LIST_DIR}/minicpm5.cpp
    ${CMAKE_CURRENT_LIST_DIR}/minimax-m3.cpp
    ${CMAKE_CURRENT_LIST_DIR}/ministral3.cpp
@@ -166,25 +166,6 @@ common_peg_ast_id common_peg_ast_arena::find_by_rule(const common_peg_ast_node &
    return COMMON_PEG_INVALID_AST_ID;
 }

-std::string common_peg_ast_node::sanitized_text() const {
-    if (invalid_utf8.empty()) {
-        return std::string(text);
-    }
-
-    std::string out;
-    out.reserve(text.size() + 2 * invalid_utf8.size());
-
-    size_t seg_start = start;
-    for (const auto & invalid : invalid_utf8) {
-        out.append(text.data() + (seg_start - start), invalid.pos - seg_start);
-        out.append("\xEF\xBF\xBD");
-        seg_start = invalid.pos + invalid.len;
-    }
-    out.append(text.data() + (seg_start - start), end - seg_start);
-
-    return out;
-}
-
 void common_peg_ast_arena::visit(common_peg_ast_id id, const common_peg_ast_visitor & visitor) const {
    if (id == COMMON_PEG_INVALID_AST_ID) {
        return;
@@ -301,7 +282,6 @@ struct parser_executor {

        auto pos = start_pos;
        std::vector<common_peg_ast_id> nodes;
-        std::vector<common_peg_invalid_utf8> invalid_utf8;

        for (size_t i = 0; i < p.children.size(); i++) {
            const auto & child_id = p.children[i];
@@ -326,14 +306,13 @@ struct parser_executor {
            if (!result.nodes.empty()) {
                nodes.insert(nodes.end(), result.nodes.begin(), result.nodes.end());
            }
-            invalid_utf8.insert(invalid_utf8.end(), result.invalid_utf8.begin(), result.invalid_utf8.end());

            if (result.need_more_input()) {
                ctx.parse_depth--;
                if (ctx.is_debug()) {
                    fprintf(stderr, "%sSEQ -> NEED_MORE\n", debug_indent().c_str());
                }
-                return common_peg_parse_result(COMMON_PEG_PARSE_RESULT_NEED_MORE_INPUT, start_pos, result.end, std::move(nodes), std::move(invalid_utf8));
+                return common_peg_parse_result(COMMON_PEG_PARSE_RESULT_NEED_MORE_INPUT, start_pos, result.end, std::move(nodes));
            }

            pos = result.end;
@@ -343,7 +322,7 @@ struct parser_executor {
        if (ctx.is_debug()) {
            fprintf(stderr, "%sSEQ -> SUCCESS at %zu->%zu\n", debug_indent().c_str(), start_pos, pos);
        }
-        return common_peg_parse_result(COMMON_PEG_PARSE_RESULT_SUCCESS, start_pos, pos, std::move(nodes), std::move(invalid_utf8));
+        return common_peg_parse_result(COMMON_PEG_PARSE_RESULT_SUCCESS, start_pos, pos, std::move(nodes));
    }

    common_peg_parse_result operator()(const common_peg_choice_parser & p) {
@@ -391,7 +370,6 @@ struct parser_executor {
        auto pos = start_pos;
        int match_count = 0;
        std::vector<common_peg_ast_id> nodes;
-        std::vector<common_peg_invalid_utf8> invalid_utf8;

        // Try to match up to max_count times (or unlimited if max_count is -1)
        while (p.max_count == -1 || match_count < p.max_count) {
@@ -422,7 +400,6 @@ struct parser_executor {
                if (!result.nodes.empty()) {
                    nodes.insert(nodes.end(), result.nodes.begin(), result.nodes.end());
                }
-                invalid_utf8.insert(invalid_utf8.end(), result.invalid_utf8.begin(), result.invalid_utf8.end());

                pos = result.end;
                match_count++;
@@ -433,14 +410,13 @@ struct parser_executor {
                if (!result.nodes.empty()) {
                    nodes.insert(nodes.end(), result.nodes.begin(), result.nodes.end());
                }
-                invalid_utf8.insert(invalid_utf8.end(), result.invalid_utf8.begin(), result.invalid_utf8.end());

                ctx.parse_depth--;
                if (ctx.is_debug()) {
                    fprintf(stderr, "%sREPEAT -> NEED_MORE (count=%d, nodes=%zu)\n", debug_indent().c_str(),
                            match_count, nodes.size());
                }
-                return common_peg_parse_result(COMMON_PEG_PARSE_RESULT_NEED_MORE_INPUT, start_pos, result.end, std::move(nodes), std::move(invalid_utf8));
+                return common_peg_parse_result(COMMON_PEG_PARSE_RESULT_NEED_MORE_INPUT, start_pos, result.end, std::move(nodes));
            }

            // Child failed - stop trying
@@ -458,7 +434,7 @@ struct parser_executor {
                    fprintf(stderr, "%sREPEAT -> NEED_MORE (not enough matches: %d < %d)\n", debug_indent().c_str(),
                            match_count, p.min_count);
                }
-                return common_peg_parse_result(COMMON_PEG_PARSE_RESULT_NEED_MORE_INPUT, start_pos, pos, std::move(nodes), std::move(invalid_utf8));
+                return common_peg_parse_result(COMMON_PEG_PARSE_RESULT_NEED_MORE_INPUT, start_pos, pos, std::move(nodes));
            }
            if (ctx.is_debug()) {
                fprintf(stderr, "%sREPEAT -> FAIL (not enough matches: %d < %d)\n", debug_indent().c_str(), match_count,
@@ -472,7 +448,7 @@ struct parser_executor {
            fprintf(stderr, "%sREPEAT -> SUCCESS (count=%d, nodes=%zu)\n", debug_indent().c_str(), match_count,
                    nodes.size());
        }
-        return common_peg_parse_result(COMMON_PEG_PARSE_RESULT_SUCCESS, start_pos, pos, std::move(nodes), std::move(invalid_utf8));
+        return common_peg_parse_result(COMMON_PEG_PARSE_RESULT_SUCCESS, start_pos, pos, std::move(nodes));
    }

    common_peg_parse_result operator()(const common_peg_and_parser & p) {
@@ -688,23 +664,23 @@ struct parser_executor {
        // Scan input and check for delimiters
        size_t pos = start_pos;
        size_t last_valid_pos = start_pos;
-        std::vector<common_peg_invalid_utf8> invalid_utf8;

        while (pos < ctx.input.size()) {
            auto utf8_result = common_parse_utf8_codepoint(ctx.input, pos);

-            if (utf8_result.status == utf8_parse_result::INCOMPLETE && ctx.is_lenient()) {
-                // The rest of the sequence may still arrive, return what we have so far
-                return common_peg_parse_result(COMMON_PEG_PARSE_RESULT_NEED_MORE_INPUT, start_pos, last_valid_pos, {}, std::move(invalid_utf8));
+            if (utf8_result.status == utf8_parse_result::INCOMPLETE) {
+                // Incomplete UTF-8 sequence
+                if (!ctx.is_lenient()) {
+                    // Input is complete but UTF-8 is incomplete = malformed
+                    return common_peg_parse_result(COMMON_PEG_PARSE_RESULT_FAIL, start_pos);
+                }
+                // Return what we have so far (before incomplete sequence)
+                return common_peg_parse_result(COMMON_PEG_PARSE_RESULT_NEED_MORE_INPUT, start_pos, last_valid_pos);
            }

-            if (utf8_result.status != utf8_parse_result::SUCCESS) {
-                // Malformed UTF-8, or a sequence truncated by the end of a complete input.
-                // A delimiter cannot start inside bytes that fail to decode, so consume them and move on
-                invalid_utf8.push_back({pos, utf8_result.bytes_consumed});
-                pos += utf8_result.bytes_consumed;
-                last_valid_pos = pos;
-                continue;
+            if (utf8_result.status == utf8_parse_result::INVALID) {
+                // Malformed UTF-8
+                return common_peg_parse_result(COMMON_PEG_PARSE_RESULT_FAIL, start_pos);
            }

            // Check if a delimiter starts at this position
@@ -712,12 +688,12 @@ struct parser_executor {

            if (match == common_trie::COMPLETE_MATCH) {
                // Found a complete delimiter, return everything before it
-                return common_peg_parse_result(COMMON_PEG_PARSE_RESULT_SUCCESS, start_pos, pos, {}, std::move(invalid_utf8));
+                return common_peg_parse_result(COMMON_PEG_PARSE_RESULT_SUCCESS, start_pos, pos);
            }

            if (match == common_trie::PARTIAL_MATCH) {
                // Found a partial match extending to end of input, return everything before it
-                return common_peg_parse_result(COMMON_PEG_PARSE_RESULT_SUCCESS, start_pos, pos, {}, std::move(invalid_utf8));
+                return common_peg_parse_result(COMMON_PEG_PARSE_RESULT_SUCCESS, start_pos, pos);
            }

            pos += utf8_result.bytes_consumed;
@@ -726,9 +702,9 @@ struct parser_executor {

        if (last_valid_pos == ctx.input.size() && ctx.is_lenient()) {
            // Reached the end of a partial stream, there might still be more input that we need to consume.
-            return common_peg_parse_result(COMMON_PEG_PARSE_RESULT_NEED_MORE_INPUT, start_pos, last_valid_pos, {}, std::move(invalid_utf8));
+            return common_peg_parse_result(COMMON_PEG_PARSE_RESULT_NEED_MORE_INPUT, start_pos, last_valid_pos);
        }
-        return common_peg_parse_result(COMMON_PEG_PARSE_RESULT_SUCCESS, start_pos, last_valid_pos, {}, std::move(invalid_utf8));
+        return common_peg_parse_result(COMMON_PEG_PARSE_RESULT_SUCCESS, start_pos, last_valid_pos);
    }

    common_peg_parse_result operator()(const common_peg_schema_parser & p) {
@@ -752,11 +728,10 @@ struct parser_executor {
                result.end,
                text,
                std::move(result.nodes),
-                result.need_more_input(),
-                result.invalid_utf8
+                result.need_more_input()
            );

-            return common_peg_parse_result(result.type, result.start, result.end, { node_id }, std::move(result.invalid_utf8));
+            return common_peg_parse_result(result.type, result.start, result.end, { node_id });
        }

        return result;
@@ -782,11 +757,10 @@ struct parser_executor {
                result.end,
                text,
                std::move(result.nodes),
-                result.need_more_input(),
-                result.invalid_utf8
+                result.need_more_input()
            );

-            return common_peg_parse_result(result.type, result.start, result.end, { node_id }, std::move(result.invalid_utf8));
+            return common_peg_parse_result(result.type, result.start, result.end, { node_id });
        }

        return result;
@@ -72,12 +72,6 @@ enum common_peg_parse_result_type {

 const char * common_peg_parse_result_type_name(common_peg_parse_result_type type);

-// A run of input bytes that does not decode as UTF-8
-struct common_peg_invalid_utf8 {
-    size_t pos;
-    size_t len;
-};
-
 struct common_peg_ast_node {
    common_peg_ast_id id;
    std::string rule;
@@ -88,12 +82,6 @@ struct common_peg_ast_node {
    std::vector<common_peg_ast_id> children;

    bool is_partial = false;
-
-    // Invalid UTF-8 inside the node, in ascending order
-    std::vector<common_peg_invalid_utf8> invalid_utf8;
-
-    // Returns the text with every invalid run replaced by U+FFFD
-    std::string sanitized_text() const;
 };

 struct common_peg_parse_result;
@@ -110,11 +98,10 @@ class common_peg_ast_arena {
        size_t end,
        std::string_view text,
        std::vector<common_peg_ast_id> children,
-        bool is_partial = false,
-        std::vector<common_peg_invalid_utf8> invalid_utf8 = {}
+        bool is_partial = false
    ) {
        common_peg_ast_id id = nodes_.size();
-        nodes_.push_back({id, rule, tag, start, end, text, std::move(children), is_partial, std::move(invalid_utf8)});
+        nodes_.push_back({id, rule, tag, start, end, text, std::move(children), is_partial});
        return id;
    }

@@ -140,9 +127,6 @@ struct common_peg_parse_result {

    std::vector<common_peg_ast_id> nodes;

-    // Invalid UTF-8 consumed by this result, carried up to the enclosing AST nodes
-    std::vector<common_peg_invalid_utf8> invalid_utf8;
-
    common_peg_parse_result() = default;

    common_peg_parse_result(common_peg_parse_result_type type, size_t start)
@@ -151,8 +135,8 @@ struct common_peg_parse_result {
    common_peg_parse_result(common_peg_parse_result_type type, size_t start, size_t end)
        : type(type), start(start), end(end) {}

-    common_peg_parse_result(common_peg_parse_result_type type, size_t start, size_t end, std::vector<common_peg_ast_id> nodes, std::vector<common_peg_invalid_utf8> invalid_utf8 = {})
-        : type(type), start(start), end(end), nodes(std::move(nodes)), invalid_utf8(std::move(invalid_utf8)) {}
+    common_peg_parse_result(common_peg_parse_result_type type, size_t start, size_t end, std::vector<common_peg_ast_id> nodes)
+        : type(type), start(start), end(end), nodes(std::move(nodes)) {}

    bool fail() const { return type == COMMON_PEG_PARSE_RESULT_FAIL; }
    bool need_more_input() const { return type == COMMON_PEG_PARSE_RESULT_NEED_MORE_INPUT; }
@@ -446,7 +430,6 @@ class common_peg_parser_builder {
    common_peg_parser space() { return add(common_peg_space_parser{}); }

    // Matches all characters until a delimiter is found (delimiter not consumed).
-    // Invalid UTF-8 is consumed and recorded on the AST nodes.
    //   S -> (!delim .)*
    common_peg_parser until(const std::string & delimiter) { return add(common_peg_until_parser{{delimiter}}); }

@@ -167,16 +167,16 @@ void common_preset::apply_to_params(common_params & params, const std::set<std::
    }
 }

-static std::map<std::string, std::map<std::string, std::string>> parse_ini_from_file(const std::filesystem::path & path) {
+static std::map<std::string, std::map<std::string, std::string>> parse_ini_from_file(const std::string & path) {
    std::map<std::string, std::map<std::string, std::string>> parsed;

    if (!std::filesystem::exists(path)) {
-        throw std::runtime_error("preset file does not exist: " + fs_path_to_utf8(path));
+        throw std::runtime_error("preset file does not exist: " + path);
    }

    std::ifstream file(path);
    if (!file.good()) {
-        throw std::runtime_error("failed to open server preset file: " + fs_path_to_utf8(path));
+        throw std::runtime_error("failed to open server preset file: " + path);
    }

    std::string contents((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
@@ -225,7 +225,7 @@ static std::map<std::string, std::map<std::string, std::string>> parse_ini_from_
    common_peg_parse_context ctx(contents);
    const auto result = parser.parse(ctx);
    if (!result.success()) {
-        throw std::runtime_error("failed to parse server config file: " + fs_path_to_utf8(path));
+        throw std::runtime_error("failed to parse server config file: " + path);
    }

    std::string current_section = COMMON_PRESET_DEFAULT_NAME;
@@ -282,7 +282,7 @@ common_preset_context::common_preset_context(llama_example ex)
    key_to_opt = get_map_key_opt(ctx_params);
 }

-common_presets common_preset_context::load_from_ini(const std::filesystem::path & path, common_preset & global) const {
+common_presets common_preset_context::load_from_ini(const std::string & path, common_preset & global) const {
    common_presets out;
    auto ini_data = parse_ini_from_file(path);

@@ -323,7 +323,7 @@ common_presets common_preset_context::load_from_ini(const std::filesystem::path
                }
                LOG_DBG("accepted option: %s = %s\n", key.c_str(), preset.options[opt].c_str());
            } else if (ignore_unknown_keys) {
-                LOG_WRN("ignoring option '%s' from %s: not supported by this program\n", key.c_str(), fs_path_to_utf8(path).c_str());
+                LOG_WRN("ignoring option '%s' from %s: not supported by this program\n", key.c_str(), path.c_str());
            } else {
                throw std::runtime_error(string_format(
                    "option '%s' not recognized in preset '%s'",
@@ -67,7 +67,7 @@ struct common_preset_context {
    common_preset_context(llama_example ex);

    // load presets from INI file
-    common_presets load_from_ini(const std::filesystem::path & path, common_preset & global) const;
+    common_presets load_from_ini(const std::string & path, common_preset & global) const;

    // generate presets from cached models
    common_presets load_from_cache() const;
@@ -12,7 +12,6 @@
 #include <climits>
 #include <cmath>
 #include <cstring>
-#include <random>
 #include <unordered_map>
 #include <vector>

@@ -122,9 +121,6 @@ struct common_sampler {

    llama_token_data_array cur_p;

-    // for rejection sampling; independent of the draft, or the target distribution is not preserved
-    std::mt19937 rng;
-
    void reset() {
        prev.clear();

@@ -218,7 +214,7 @@ struct common_sampler * common_sampler_init(
 #ifdef LLAMA_USE_LLGUIDANCE
        grmr = llama_sampler_init_llg(vocab, "lark", grammar_str.c_str());
 #else
-        throw std::runtime_error("failed to parse grammar: llguidance is not enabled");
+        GGML_ABORT("llguidance (cmake -DLLAMA_LLGUIDANCE=ON) is not enabled");
 #endif // LLAMA_USE_LLGUIDANCE
    } else {
        std::vector<std::string> trigger_patterns;
@@ -436,8 +432,6 @@ struct common_sampler * common_sampler_init(
        /* .prev    = */ ring_buffer<llama_token>(std::max(32, params.n_prev)),
        /* .cur     = */ {},
        /* .cur_p   = */ {},
-        // mix it, the chain and the draft are seeded from this one too
-        /* .rng     = */ std::mt19937(llama_sampler_get_seed(chain) ^ 0x9e3779b9u),
    };

    return result;
@@ -521,7 +515,6 @@ struct common_sampler * common_sampler_clone(common_sampler * gsmpl) {
        /* .prev    = */ gsmpl->prev,
        /* .cur     = */ gsmpl->cur,
        /* .cur_p   = */ gsmpl->cur_p,
-        /* .rng     = */ gsmpl->rng,
    };
 }

@@ -542,7 +535,6 @@ void common_sampler_copy(const common_sampler * src, common_sampler * dst) {
    dst->cur        = src->cur;
    dst->cur_p      = src->cur_p;
    dst->cur_p.data = src->cur_p.data ? dst->cur.data() : nullptr; // re-point to dst's buffer
-    dst->rng        = src->rng;
    dst->t_total_us = src->t_total_us;
 }

@@ -689,8 +681,6 @@ std::vector<llama_token> common_sampler_sample_and_accept_n(struct common_sample
    std::vector<llama_token> result;
    result.reserve(idxs.size());

-    const llama_vocab * vocab = llama_model_get_vocab(llama_get_model(ctx));
-
    size_t i = 0;
    for (; i < draft.size(); i++) {
        const llama_token id = common_sampler_sample(gsmpl, ctx, idxs[i], grammar_first);
@@ -699,9 +689,7 @@ std::vector<llama_token> common_sampler_sample_and_accept_n(struct common_sample

        result.push_back(id);

-        // do not accept draft tokens after an EOG - they are not output but would stay in the context
-        // on replay the last token is from the target and can be EOG, so a trailing EOG is still accepted
-        if (draft[i] != id || (llama_vocab_is_eog(vocab, id) && i + 1 < draft.size())) {
+        if (draft[i] != id) {
            break;
        }
    }
@@ -717,124 +705,6 @@ std::vector<llama_token> common_sampler_sample_and_accept_n(struct common_sample
    return result;
 }

-static float prob_of(const llama_token_data * data, size_t n, llama_token id) {
-    for (size_t k = 0; k < n; ++k) {
-        if (data[k].id == id) {
-            return data[k].p;
-        }
-    }
-    return 0.0f;
-}
-
-// Accept a drafted token with probability min(1, p/q), else draw from norm(max(0, p - q)).
-// Preserves the target distribution exactly, and accepts more often than matching does when the
-// draft samples instead of taking its argmax.
-std::vector<llama_token> common_sampler_sample_and_accept_n_rejection(struct common_sampler * gsmpl, struct llama_context * ctx, const std::vector<int> & idxs, const llama_tokens & draft, const std::vector<std::vector<llama_token_data>> & draft_q, bool grammar_first) {
-    GGML_ASSERT(idxs.size()    == draft.size() + 1 && "idxs.size() must be draft.size() + 1");
-    GGML_ASSERT(draft_q.size() == draft.size() && "draft_q must have one entry per draft token");
-
-    std::vector<llama_token> result;
-    result.reserve(idxs.size());
-
-    // draws come from the sampler's own stream, so they stay independent of what was drafted
-    std::uniform_real_distribution<float> uni(0.0f, 1.0f);
-
-    std::vector<llama_token_data> residual;
-
-    std::vector<llama_token_data> cand; // candidate array masked by the grammar, if there is one
-
-    size_t i = 0;
-    for (; i < draft.size(); i++) {
-        // leaves the target distribution in the candidate array
-        const llama_token id_tgt = common_sampler_sample(gsmpl, ctx, idxs[i], grammar_first);
-
-        const auto * cur_p = common_sampler_get_candidates(gsmpl, true);
-        const auto & q     = draft_q[i];
-
-        const bool masked = !grammar_first && grammar_should_apply(gsmpl);
-        if (masked) {
-            cand.assign(cur_p->data, cur_p->data + cur_p->size);
-            llama_token_data_array arr = { cand.data(), cand.size(), -1, false };
-            llama_sampler_apply(gsmpl->grmr, &arr);
-        }
-
-        // a candidate the grammar rejects carries no probability, whatever the target thinks
-        auto p_raw = [&](size_t k) {
-            return masked && cand[k].logit == -INFINITY ? 0.0f : cur_p->data[k].p;
-        };
-
-        // masking drops probability mass, so rescale what is left or the residual is over-weighted
-        float p_sum = 0.0f;
-        if (masked) {
-            for (size_t k = 0; k < cur_p->size; ++k) {
-                p_sum += p_raw(k);
-            }
-        }
-
-        const float p_norm = masked && p_sum > 0.0f ? 1.0f/p_sum : 1.0f;
-
-        auto p_of = [&](size_t k) {
-            return p_raw(k)*p_norm;
-        };
-
-        // q_x is never 0 for a token the draft produced, but guard the divide
-        const float q_x = prob_of(q.data(), q.size(), draft[i]);
-
-        float p_x = 0.0f;
-        for (size_t k = 0; k < cur_p->size; ++k) {
-            if (cur_p->data[k].id == draft[i]) {
-                p_x = p_of(k);
-                break;
-            }
-        }
-
-        if (q_x > 0.0f && (p_x >= q_x || uni(gsmpl->rng) < p_x / q_x)) {
-            common_sampler_accept(gsmpl, draft[i], true);
-            result.push_back(draft[i]);
-            continue;
-        }
-
-        // rejected: tokens outside q's support keep all of p
-        residual.clear();
-        float sum = 0.0f;
-        for (size_t k = 0; k < cur_p->size; ++k) {
-            const float r = p_of(k) - prob_of(q.data(), q.size(), cur_p->data[k].id);
-            if (r > 0.0f) {
-                residual.push_back({ cur_p->data[k].id, 0.0f, r });
-                sum += r;
-            }
-        }
-
-        llama_token id = id_tgt;
-        if (sum > 0.0f) {
-            float u = uni(gsmpl->rng) * sum;
-            id = residual.back().id;
-            for (const auto & e : residual) {
-                u -= e.p;
-                if (u <= 0.0f) {
-                    id = e.id;
-                    break;
-                }
-            }
-        }
-
-        common_sampler_accept(gsmpl, id, true);
-        result.push_back(id);
-
-        break;
-    }
-
-    if (i == draft.size()) {
-        const llama_token id = common_sampler_sample(gsmpl, ctx, idxs[i], grammar_first);
-
-        common_sampler_accept(gsmpl, id, true);
-
-        result.push_back(id);
-    }
-
-    return result;
-}
-
 std::vector<llama_token> common_sampler_sample_and_accept_n(struct common_sampler * gsmpl, struct llama_context * ctx, const llama_tokens & draft, bool grammar_first) {
    std::vector<int> idxs(draft.size() + 1);
    for (size_t i = 0; i < idxs.size(); ++i) {
@@ -85,9 +85,6 @@ llama_token common_sampler_sample(struct common_sampler * gsmpl, struct llama_co
 //
 std::vector<llama_token> common_sampler_sample_and_accept_n(struct common_sampler * gsmpl, struct llama_context * ctx, const std::vector<int> & idxs, const llama_tokens & draft, bool grammar_first = false);

-// as above, but verifies by rejection sampling; draft_q holds the draft's candidates per token
-std::vector<llama_token> common_sampler_sample_and_accept_n_rejection(struct common_sampler * gsmpl, struct llama_context * ctx, const std::vector<int> & idxs, const llama_tokens & draft, const std::vector<std::vector<llama_token_data>> & draft_q, bool grammar_first = false);
-
 // assume idxs == [ 0, 1, 2, ..., draft.size() ]
 std::vector<llama_token> common_sampler_sample_and_accept_n(struct common_sampler * gsmpl, struct llama_context * ctx, const llama_tokens & draft, bool grammar_first = false);

@@ -30,45 +30,6 @@
 #define SPEC_VOCAB_MAX_SIZE_DIFFERENCE  128
 #define SPEC_VOCAB_CHECK_START_TOKEN_ID 5

-// Rebuild seq_id's draft sampler at the target's temperature: rejection weighs q against p, so
-// both have to sample alike. Only temp and seed carry over; the draft keeps its own top_k.
-static void spec_retune(
-        std::vector<common_sampler_ptr> & smpls,
-        std::vector<common_params_sampling> & cfg,
-        const llama_model * model,
-        llama_seq_id seq_id,
-        float temp,
-        uint32_t seed) {
-    if (cfg.size() != smpls.size()) {
-        const size_t n_old = cfg.size();
-        cfg.resize(smpls.size());
-
-        // the initial sampler has no temperature, so no request may match the cache and skip a rebuild
-        for (size_t i = n_old; i < cfg.size(); ++i) {
-            cfg[i].temp = NAN;
-        }
-    }
-
-    auto & cur = cfg[seq_id];
-
-    if (cur.temp == temp && cur.seed == seed) {
-        return;
-    }
-
-    cur.temp = temp;
-    cur.seed = seed;
-
-    common_params_sampling sparams;
-    sparams.no_perf  = false;
-    sparams.top_k    = 10;
-    sparams.temp     = cur.temp;
-    // must be explicit, the default reseeds at random; mixed so it differs from the target's
-    sparams.seed     = cur.seed == LLAMA_DEFAULT_SEED ? cur.seed : cur.seed ^ 0x85ebca6bu;
-    sparams.samplers = { COMMON_SAMPLER_TYPE_TOP_K, COMMON_SAMPLER_TYPE_TEMPERATURE };
-
-    smpls[seq_id].reset(common_sampler_init(model, sparams));
-}
-
 const std::map<std::string, common_speculative_type> common_speculative_type_from_name_map = {
    {"none",          COMMON_SPECULATIVE_TYPE_NONE},
    {"draft-simple",  COMMON_SPECULATIVE_TYPE_DRAFT_SIMPLE},
@@ -204,7 +165,7 @@ struct common_speculative_impl {

    virtual void begin(llama_seq_id seq_id, const llama_tokens & prompt) = 0;

-    virtual bool process(const common_batch & batch) = 0;
+    virtual bool process(const llama_batch & batch) = 0;

    virtual void draft(common_speculative_draft_params_vec & dparams) = 0;

@@ -218,16 +179,10 @@ struct common_speculative_impl {
 struct common_speculative_impl_draft_simple : public common_speculative_impl {
    common_params_speculative_draft params;

-    common_batch batch;
-
-    // zero row at the draft input width, stands in for target embeddings the draft cannot read
-    std::vector<float> zeros;
-    bool zeros_warned = false; // the substitution is reported once
+    llama_batch batch;

    std::vector<common_sampler_ptr> smpls;

-    std::vector<common_params_sampling> smpls_cfg;
-
    common_speculative_impl_draft_simple(const common_params_speculative & params, uint32_t n_seq)
        : common_speculative_impl(COMMON_SPECULATIVE_TYPE_DRAFT_SIMPLE, n_seq, params.draft.n_max)
        , params(params.draft)
@@ -239,8 +194,6 @@ struct common_speculative_impl_draft_simple : public common_speculative_impl {
            throw std::runtime_error("draft-simple requires a draft context");
        }

-        zeros.assign(llama_model_n_embd_inp(llama_get_model(ctx_dft)), 0.0f);
-
        SPC_TRC("%s", "adding speculative implementation 'draft-simple'\n");
        SPC_TRC("- n_max=%d, n_min=%d, p_min=%f\n", this->params.n_max, this->params.n_min, this->params.p_min);
        SPC_TRC("- gpu_layers=%d, cache_k=%s, cache_v=%s, ctx_tgt=%s, ctx_dft=%s, devices=[%s]\n",
@@ -251,7 +204,7 @@ struct common_speculative_impl_draft_simple : public common_speculative_impl {
                ctx_dft ? "yes" : "no",
                common_speculative_get_devices_str(this->params.devices).c_str());

-        batch = common_batch(ctx_dft);
+        batch = llama_batch_init(llama_n_batch(ctx_dft), 0, 1);

        // TODO: optimize or pass from outside?
        // {
@@ -275,7 +228,9 @@ struct common_speculative_impl_draft_simple : public common_speculative_impl {
            common_params_sampling params;
            params.no_perf = false;
            params.top_k = 10;
-            params.samplers.assign(1, COMMON_SAMPLER_TYPE_TOP_K);
+            params.samplers = {
+                COMMON_SAMPLER_TYPE_TOP_K,
+            };

            smpl.reset(common_sampler_init(llama_get_model(ctx_dft), params));
        }
@@ -296,47 +251,21 @@ struct common_speculative_impl_draft_simple : public common_speculative_impl {
        }
    }

-    void begin(llama_seq_id seq_id, const llama_tokens & /*prompt*/) override {
-        // reset here rather than per round, or two identical requests differ
-        common_sampler_reset(smpls[seq_id].get());
+    ~common_speculative_impl_draft_simple() override {
+        llama_batch_free(batch);
    }

-    bool process(const common_batch & batch_in) override {
+    void begin(llama_seq_id /*seq_id*/, const llama_tokens & /*prompt*/) override {
+        // noop
+    }
+
+    bool process(const llama_batch & batch) override {
        auto * ctx_dft = params.ctx_dft;

-        // copy the entries to a batch owned by the draft context, only the last token is output
-        batch.clear();
-        const int32_t n_tokens = batch_in.size();
-        for (int32_t k = 0; k < n_tokens; ++k) {
-            const auto & t = batch_in.tokens[k];
-            const bool output = k == n_tokens - 1;
-            if (t.id != LLAMA_TOKEN_NULL) {
-                const int32_t idx = batch.add(t.id, t.pos[0], t.seq_id, output);
-                if (t.embd.data) {
-                    batch.set_embd(idx, t.embd);
-                }
-            } else {
-                // mtmd input is projected by the target encoder, a draft with a different width cannot read it
-                // it gets zeros instead, keeping its positions contiguous
-                // ref: https://github.com/ggml-org/llama.cpp/pull/29385#discussion_r4124743243
-                const size_t n_embd = t.embd.n_rows * t.embd.n_embd;
-                const bool same_width = n_embd == zeros.size();
-                if (!same_width && !zeros_warned) {
-                    SPC_WRN("target embeddings of size %zu do not fit the draft input width %zu, "
-                            "the draft receives zero rows for them and drafts after multimodal input will be poor\n",
-                            n_embd, zeros.size());
-                    zeros_warned = true;
-                }
-                const llama_embd embd = same_width ? t.embd : llama_embd{ zeros.data(), 1, zeros.size() };
-                batch.add_embd(embd, t.pos.data(), t.seq_id, output);
-            }
-        }
+        llama_batch batch_dft = batch;
+        batch_dft.logits = nullptr;

-        if (batch.size() == 0) {
-            return true;
-        }
-
-        const int ret = llama_process(ctx_dft, LLAMA_PROCESS_TYPE_DECODE, batch.get());
+        const int ret = llama_decode(ctx_dft, batch_dft);

        if (ret != 0) {
            SPC_ERR("failed to decode draft batch, ret = %d\n", ret);
@@ -350,7 +279,7 @@ struct common_speculative_impl_draft_simple : public common_speculative_impl {
    void draft(common_speculative_draft_params_vec & dparams) override {
        auto & ctx_dft = params.ctx_dft;

-        batch.clear();
+        common_batch_clear(batch);

        // keep track of which sequences are still drafting
        int n_drafting = 0;
@@ -365,27 +294,14 @@ struct common_speculative_impl_draft_simple : public common_speculative_impl {

            n_drafting++;
            drafting[seq_id] = true;
-            // greedy drafting leaves no candidates behind, so the verifier falls back to sample-and-match
-            if (!params.probabilistic) {
-                dp.result_q = nullptr;
-            }
+            common_sampler_reset(smpls[seq_id].get());

-            // result_q is only set when the caller wants rejection, so it also gates the retune
-            if (dp.result_q) {
-                spec_retune(smpls, smpls_cfg, llama_get_model(ctx_dft), seq_id, dp.temp, dp.seed);
-            }
-
-            // a reset reseeds the chain, which breaks probabilistic drafting
-            if (!dp.result_q) {
-                common_sampler_reset(smpls[seq_id].get());
-            }
-
-            batch.add(dp.id_last, dp.pos0, seq_id, true);
+            common_batch_add(batch, dp.id_last, dp.pos0, { seq_id }, true);
        }

-        int ret = llama_process(ctx_dft, LLAMA_PROCESS_TYPE_DECODE, batch.get());
+        int ret = llama_decode(ctx_dft, batch);
        if (ret != 0) {
-            SPC_ERR("llama_process returned %d\n", ret);
+            SPC_ERR("llama_decode returned %d\n", ret);
            return;
        }

@@ -394,7 +310,7 @@ struct common_speculative_impl_draft_simple : public common_speculative_impl {
        while (n_drafting > 0) {
            int i_batch = 0;

-            batch.clear();
+            common_batch_clear(batch);

            for (llama_seq_id seq_id = 0; seq_id < (llama_seq_id) n_seq; ++seq_id) {
                if (!drafting[seq_id]) {
@@ -403,7 +319,7 @@ struct common_speculative_impl_draft_simple : public common_speculative_impl {

                auto * smpl = smpls[seq_id].get();

-                const llama_token id_sampled = common_sampler_sample(smpl, ctx_dft, i_batch, true);
+                common_sampler_sample(smpl, ctx_dft, i_batch, true);
                ++i_batch;

                const auto * cur_p = common_sampler_get_candidates(smpl, true);
@@ -415,7 +331,7 @@ struct common_speculative_impl_draft_simple : public common_speculative_impl {
                }

                // add drafted token for each sequence
-                const llama_token id = dparams.at(seq_id).result_q ? id_sampled : cur_p->data[0].id;
+                const llama_token id = cur_p->data[0].id;

                // only collect very high-confidence draft tokens
                if (cur_p->data[0].p < params.p_min) {
@@ -432,10 +348,6 @@ struct common_speculative_impl_draft_simple : public common_speculative_impl {

                result.push_back(id);

-                if (dp.result_q) {
-                    dp.result_q->emplace_back(cur_p->data, cur_p->data + cur_p->size);
-                }
-
                if ((params.n_max <= (int) result.size()) ||
                    (dp.n_max > 0 && dp.n_max <= (int) result.size())) {
                    drafting[seq_id] = false;
@@ -443,17 +355,17 @@ struct common_speculative_impl_draft_simple : public common_speculative_impl {
                    continue;
                }

-                batch.add(id, dp.pos0 + i + 1, seq_id, true);
+                common_batch_add(batch, id, dp.pos0 + i + 1, { seq_id }, true);
            }

-            if (batch.size() == 0) {
+            if (batch.n_tokens == 0) {
                break;
            }

            // evaluate the drafted tokens on the draft model
-            ret = llama_process(ctx_dft, LLAMA_PROCESS_TYPE_DECODE, batch.get());
+            ret = llama_decode(ctx_dft, batch);
            if (ret != 0) {
-                SPC_ERR("llama_process[%d] returned %d\n", i, ret);
+                SPC_ERR("llama_decode[%d] returned %d\n", i, ret);
                break;
            }

@@ -513,8 +425,7 @@ struct common_speculative_impl_draft_simple : public common_speculative_impl {
 //      encoder+decoder on n_accepted+1 rows).
 struct common_speculative_impl_draft_eagle3 : public common_speculative_impl {
    common_params_speculative_draft params;
-    common_batch batch;     // decoder input, (token, g_embd) pairs
-    common_batch batch_enc; // encoder input, built from the extracted target features
+    llama_batch batch;

    std::vector<common_sampler_ptr> smpls;

@@ -568,8 +479,11 @@ struct common_speculative_impl_draft_eagle3 : public common_speculative_impl {
        n_embd_enc = (int32_t) target_layer_ids_n * n_embd_tgt;
        n_layer_tgt = llama_model_n_layer(model_tgt);

-        batch     = common_batch(ctx_dft);
-        batch_enc = common_batch(ctx_dft);
+        const int32_t n_b = (int32_t) llama_n_batch(ctx_dft);
+        batch = llama_batch_init(/*n_tokens=*/ n_b, /*embd=*/ n_embd_dec, /*n_seq_max=*/ 1);
+        // llama_batch_init allocates only one of token/embd; eagle3 decoder needs both.
+        // TODO: fix, how to call without malloc
+        batch.token = (llama_token *) malloc(sizeof(llama_token) * n_b);

        smpls.resize(n_seq);
        for (auto & s : smpls) {
@@ -631,6 +545,12 @@ struct common_speculative_impl_draft_eagle3 : public common_speculative_impl {
            llama_sampler_free(backend_chains[seq_id]);
        }
        backend_chains.clear();
+
+        if (batch.token != nullptr) {
+            free(batch.token);
+            batch.token = nullptr;
+        }
+        llama_batch_free(batch);
    }

    void begin(llama_seq_id seq_id, const llama_tokens & prompt) override {
@@ -649,16 +569,16 @@ struct common_speculative_impl_draft_eagle3 : public common_speculative_impl {
        }
    }

-    bool process(const common_batch & batch_in) override {
-        if (batch_in.size() <= 0) {
+    bool process(const llama_batch & batch_in) override {
+        if (batch_in.n_tokens <= 0) {
            return true;
        }

-        if (!batch_in.has_token() || batch_in.has_embd()) {
+        if (batch_in.token == nullptr || batch_in.embd != nullptr) {
            return true;
        }

-        const int32_t n_tokens = batch_in.size();
+        const int32_t n_tokens = batch_in.n_tokens;

        // i_batch_beg[seq] / i_batch_end[seq]: inclusive batch indices of this seq's
        // first/last token in batch_in. Assumes per-seq tokens are contiguous within
@@ -666,7 +586,8 @@ struct common_speculative_impl_draft_eagle3 : public common_speculative_impl {
        std::vector<int32_t> i_batch_beg(n_seq, -1);
        std::vector<int32_t> i_batch_end(n_seq, -1);
        for (int k = 0; k < n_tokens; ++k) {
-            const llama_seq_id seq_id = batch_in.tokens[k].seq_id;
+            GGML_ASSERT(batch_in.n_seq_id[k] == 1);
+            const llama_seq_id seq_id = batch_in.seq_id[k][0];
            if (seq_id < 0 || seq_id >= (llama_seq_id) n_seq) {
                continue;
            }
@@ -700,23 +621,24 @@ struct common_speculative_impl_draft_eagle3 : public common_speculative_impl {

        g_embd_buf.resize((size_t) n_tokens * n_embd_dec);

-        // llama_process() requires the full encoder batch to fit in n_ubatch.
+        // llama_encode() requires the full encoder batch to fit in n_ubatch.
        // Allow batch > ubatch: eagle3's per-token encoder can be chunked safely.
        const int32_t n_ubatch_dft = (int32_t) llama_n_ubatch(ctx_dft);
        for (int32_t i = 0; i < n_tokens; i += n_ubatch_dft) {
            const int32_t n_chunk = std::min(n_ubatch_dft, n_tokens - i);

-            // the per-token encoder does not use positions, generate placeholder ones from the memory state
-            batch_enc.clear();
-            llama_pos pos = llama_memory_seq_pos_max(llama_get_memory(ctx_dft), 0) + 1;
-            for (int32_t j = 0; j < n_chunk; ++j) {
-                batch_enc.add_embd({ features_buf.data() + (size_t) (i + j) * n_embd_enc, 1, (size_t) n_embd_enc }, &pos, 0, true);
-                pos++;
-            }
-
-            const int32_t rc = llama_process(ctx_dft, LLAMA_PROCESS_TYPE_ENCODE, batch_enc.get());
+            llama_batch enc_batch = {
+                /*.n_tokens =*/ n_chunk,
+                /*.token    =*/ nullptr,
+                /*.embd     =*/ features_buf.data() + (size_t) i * n_embd_enc,
+                /*.pos      =*/ nullptr,
+                /*.n_seq_id =*/ nullptr,
+                /*.seq_id   =*/ nullptr,
+                /*.logits   =*/ nullptr,
+            };
+            const int32_t rc = llama_encode(ctx_dft, enc_batch);
            if (rc != 0) {
-                SPC_ERR("llama_process(ctx_dft) failed rc=%d (n_tokens=%d, offset=%d)\n",
+                SPC_ERR("llama_encode(ctx_dft) failed rc=%d (n_tokens=%d, offset=%d)\n",
                        rc, (int) n_chunk, (int) i);
                return false;
            }
@@ -744,7 +666,7 @@ struct common_speculative_impl_draft_eagle3 : public common_speculative_impl {
        //       deferred boundary, completed by the next process() or draft() call.
        //   (c) refresh deferred state — stash this ubatch's full g_embd into verify_g,
        //       update pending_g_last / pending_pos_last to the last row.
-        batch.clear();
+        common_batch_clear(batch);

        for (llama_seq_id seq_id = 0; seq_id < (llama_seq_id) n_seq; ++seq_id) {
            const int32_t beg = i_batch_beg[seq_id];
@@ -759,34 +681,36 @@ struct common_speculative_impl_draft_eagle3 : public common_speculative_impl {
            //   2) pending_pos_last + 1 == pos[beg]
            //   3) pending_pos_last > dft_pos_max // TODO: is this check needed?
            const llama_pos pending_pos = pending_pos_last[seq_id];
-            if (pending_pos >= 0 && pending_pos + 1 == batch_in.tokens[beg].pos[0]) {
+            if (pending_pos >= 0 && pending_pos + 1 == batch_in.pos[beg]) {
                const llama_pos dft_pos_max = llama_memory_seq_pos_max(llama_get_memory(ctx_dft), seq_id);
                if (pending_pos > dft_pos_max) {
-                    const int32_t idx = batch.add(batch_in.tokens[beg].id, pending_pos, seq_id, /*output=*/ false);
-                    batch.set_embd(idx, { pending_g_last[seq_id].data(), 1, (size_t) n_embd_dec });
+                    common_batch_add(batch, batch_in.token[beg], pending_pos, { seq_id }, /*logits=*/ false);
+                    std::memcpy(batch.embd + (size_t) (batch.n_tokens - 1) * n_embd_dec,
+                                pending_g_last[seq_id].data(), row_bytes);
                }
            }

            for (int32_t k = beg; k < end; ++k) {
-                const int32_t idx = batch.add(batch_in.tokens[k + 1].id, batch_in.tokens[k].pos[0], seq_id, /*output=*/ false);
-                batch.set_embd(idx, { g_embd + (size_t) k * n_embd_dec, 1, (size_t) n_embd_dec });
+                common_batch_add(batch, batch_in.token[k + 1], batch_in.pos[k], { seq_id }, /*logits=*/ false);
+                std::memcpy(batch.embd + (size_t) (batch.n_tokens - 1) * n_embd_dec,
+                            g_embd + (size_t) k * n_embd_dec, row_bytes);
            }

            // refresh deferred state
            const int32_t n_rows = end - beg + 1;
-            verify_pos_first[seq_id] = batch_in.tokens[beg].pos[0];
-            pending_pos_last[seq_id] = batch_in.tokens[end].pos[0];
+            verify_pos_first[seq_id] = batch_in.pos[beg];
+            pending_pos_last[seq_id] = batch_in.pos[end];
            verify_g_rows[seq_id]    = n_rows;
            verify_g[seq_id].resize((size_t) n_rows * n_embd_dec, 0.0f);
            std::memcpy(verify_g[seq_id].data(),       g_embd + (size_t) beg * n_embd_dec, row_bytes * n_rows);
            std::memcpy(pending_g_last[seq_id].data(), g_embd + (size_t) end * n_embd_dec, row_bytes);
        }

-        if (batch.size() > 0) {
-            const int32_t rc = llama_process(ctx_dft, LLAMA_PROCESS_TYPE_DECODE, batch.get());
+        if (batch.n_tokens > 0) {
+            const int32_t rc = llama_decode(ctx_dft, batch);
            if (rc != 0) {
-                SPC_ERR("llama_process(ctx_dft) failed rc=%d (n_tokens=%d, ubatch_pos[0]=%d)\n",
-                        rc, (int) batch.size(), (int) batch_in.tokens[0].pos[0]);
+                SPC_ERR("llama_decode(ctx_dft) failed rc=%d (n_tokens=%d, ubatch_pos[0]=%d)\n",
+                        rc, (int) batch.n_tokens, (int) batch_in.pos[0]);
                return false;
            }
        }
@@ -797,12 +721,14 @@ struct common_speculative_impl_draft_eagle3 : public common_speculative_impl {
    void draft(common_speculative_draft_params_vec & dparams) override {
        auto & ctx_dft = params.ctx_dft;

-        batch.clear();
+        common_batch_clear(batch);

        // keep track of which sequences are still drafting
        int n_drafting = 0;
        std::vector<bool> drafting(n_seq);

+        const size_t row_bytes = (size_t) n_embd_dec * sizeof(float);
+
        // Complete the deferred boundary pair (dp.id_last, pending_g_last) at memory
        // pos pending_pos_last. dp.id_last is target's freshest sample (= corrected
        // token after verify, or first generated token after prefill), matching the
@@ -823,17 +749,19 @@ struct common_speculative_impl_draft_eagle3 : public common_speculative_impl {

            llama_memory_seq_rm(llama_get_memory(ctx_dft), seq_id, pending_pos_last[seq_id], -1);

-            const int32_t idx = batch.add(dp.id_last, pending_pos_last[seq_id], seq_id, true);
-            batch.set_embd(idx, { pending_g_last[seq_id].data(), 1, (size_t) n_embd_dec });
+            common_batch_add(batch, dp.id_last, pending_pos_last[seq_id], { seq_id }, true);
+            std::memcpy(batch.embd + (size_t) (batch.n_tokens - 1) * n_embd_dec,
+                        pending_g_last[seq_id].data(),
+                        row_bytes);
        }

-        if (batch.size() == 0) {
+        if (batch.n_tokens == 0) {
            return;
        }

-        int ret = llama_process(ctx_dft, LLAMA_PROCESS_TYPE_DECODE, batch.get());
+        int ret = llama_decode(ctx_dft, batch);
        if (ret != 0) {
-            SPC_ERR("llama_process returned %d\n", ret);
+            SPC_ERR("llama_decode returned %d\n", ret);
            return;
        }

@@ -842,7 +770,7 @@ struct common_speculative_impl_draft_eagle3 : public common_speculative_impl {
        while (n_drafting > 0) {
            int i_batch = 0;

-            batch.clear();
+            common_batch_clear(batch);

            for (llama_seq_id seq_id = 0; seq_id < (llama_seq_id) n_seq; ++seq_id) {
                if (!drafting[seq_id]) {
@@ -888,17 +816,17 @@ struct common_speculative_impl_draft_eagle3 : public common_speculative_impl {
                    continue;
                }

-                const int32_t idx = batch.add(id, pending_pos_last[seq_id] + (i + 1), seq_id, true);
-                batch.set_embd(idx, { prenorm, 1, (size_t) n_embd_dec });
+                common_batch_add(batch, id, pending_pos_last[seq_id] + (i + 1), { seq_id }, true);
+                std::memcpy(batch.embd + (size_t) (batch.n_tokens - 1) * n_embd_dec, prenorm, row_bytes);
            }

-            if (batch.size() == 0) {
+            if (batch.n_tokens == 0) {
                break;
            }

-            ret = llama_process(ctx_dft, LLAMA_PROCESS_TYPE_DECODE, batch.get());
+            ret = llama_decode(ctx_dft, batch);
            if (ret != 0) {
-                SPC_ERR("llama_process[%d] returned %d\n", i, ret);
+                SPC_ERR("llama_decode[%d] returned %d\n", i, ret);
                break;
            }

@@ -982,10 +910,8 @@ struct common_speculative_impl_draft_eagle3 : public common_speculative_impl {
 struct common_speculative_impl_draft_dflash : public common_speculative_impl {
    common_params_speculative_draft params;

-    common_batch batch;        // noise tokens
-    common_batch batch_inject; // target features for KV cache injection
-
-    std::vector<float> features_buf; // [n_chunk, n_embd_enc] gathered target features
+    llama_batch batch;        // noise tokens
+    llama_batch batch_inject; // target features for KV cache injection

    std::vector<common_sampler_ptr> smpls;

@@ -1081,11 +1007,15 @@ struct common_speculative_impl_draft_dflash : public common_speculative_impl {
        }
        this->n_max = this->params.n_max;

-        batch        = common_batch(ctx_dft);
-        batch_inject = common_batch(ctx_dft);
+        batch        = llama_batch_init(llama_n_batch(ctx_dft), 0,          n_seq);
+        batch_inject = llama_batch_init(llama_n_ubatch(ctx_dft), n_embd_enc, n_seq);

-        // embd batches on an M-RoPE draft carry 4 position rows per token
+        // embd batches on an M-RoPE draft need 4 position rows per token
        is_mrope = llama_model_rope_type(model_dft) == LLAMA_ROPE_TYPE_MROPE;
+        if (is_mrope) {
+            free(batch_inject.pos);
+            batch_inject.pos = (llama_pos *) malloc(sizeof(llama_pos) * 4 * llama_n_batch(ctx_dft));
+        }

        smpls.resize(n_seq);
        for (auto & s : smpls) {
@@ -1134,6 +1064,9 @@ struct common_speculative_impl_draft_dflash : public common_speculative_impl {
            llama_sampler_free(backend_chains[seq_id]);
        }
        backend_chains.clear();
+
+        llama_batch_free(batch);
+        llama_batch_free(batch_inject);
    }

    void begin(llama_seq_id seq_id, const llama_tokens & prompt) override {
@@ -1154,8 +1087,8 @@ struct common_speculative_impl_draft_dflash : public common_speculative_impl {
        }
    }

-    bool process(const common_batch & batch_in) override {
-        if (batch_in.size() <= 0) {
+    bool process(const llama_batch & batch_in) override {
+        if (batch_in.n_tokens <= 0) {
            return true;
        }

@@ -1163,19 +1096,20 @@ struct common_speculative_impl_draft_dflash : public common_speculative_impl {
        // produce the target-layer features used to seed the draft KV cache, so
        // embeddings are injected too, except the pinned ones skipped below.
        // TODO: revisit after https://github.com/ggml-org/llama.cpp/pull/24669 is merged
-        const bool has_tokens     = batch_in.has_token();
-        const bool has_embeddings = batch_in.has_embd();
+        const bool has_tokens     = batch_in.token != nullptr;
+        const bool has_embeddings = batch_in.embd  != nullptr;
        if (has_tokens == has_embeddings) {
            return true;
        }

-        const int32_t n_tokens = batch_in.size();
+        const int32_t n_tokens = batch_in.n_tokens;

        // per-seq inclusive batch range (assumes each seq's tokens are contiguous in the batch)
        std::vector<int32_t> i_batch_beg(n_seq, -1);
        std::vector<int32_t> i_batch_end(n_seq, -1);
        for (int32_t k = 0; k < n_tokens; ++k) {
-            const llama_seq_id seq_id = batch_in.tokens[k].seq_id;
+            GGML_ASSERT(batch_in.n_seq_id[k] == 1);
+            const llama_seq_id seq_id = batch_in.seq_id[k][0];
            if (seq_id < 0 || seq_id >= (llama_seq_id) n_seq) {
                continue;
            }
@@ -1198,7 +1132,7 @@ struct common_speculative_impl_draft_dflash : public common_speculative_impl {

            // an M-RoPE image pins all its rows to one position, so a windowed draft
            // cache cannot free cells for it - skip it, the draft can jump over the gap
-            const bool pos_pinned = batch_in.tokens[i_batch_beg[seq_id]].pos[0] == batch_in.tokens[i_batch_end[seq_id]].pos[0];
+            const bool pos_pinned = batch_in.pos[i_batch_beg[seq_id]] == batch_in.pos[i_batch_end[seq_id]];
            if (has_embeddings && n_rows > 1 && pos_pinned) {
                continue;
            }
@@ -1208,28 +1142,34 @@ struct common_speculative_impl_draft_dflash : public common_speculative_impl {

                // gather target features per extract layer; the fused decode encodes and
                // injects them into the K/V cache at the target positions
-                features_buf.resize((size_t) n_chunk * n_embd_enc);
+                batch_inject.n_tokens = n_chunk;
                for (uint32_t k = 0; k < target_layer_ids_n; ++k) {
                    const float * layer = llama_get_embeddings_layer_inp(ctx_tgt, (uint32_t) target_layer_ids[k]);
                    if (!layer) {
                        GGML_ABORT("DFlash: target layer %d input not extracted.", target_layer_ids[k]);
                    }
                    for (int32_t i = 0; i < n_chunk; ++i) {
-                        float       * dst = features_buf.data() + (size_t) i * n_embd_enc + k * (size_t) n_embd_tgt;
+                        float       * dst = batch_inject.embd + (size_t) i * n_embd_enc + k * (size_t) n_embd_tgt;
                        const float * src = layer + (size_t) (i_batch_beg[seq_id] + offset + i) * n_embd_tgt;
                        std::memcpy(dst, src, (size_t) n_embd_tgt * sizeof(float));
                    }
                }

-                batch_inject.clear();
                for (int32_t i = 0; i < n_chunk; ++i) {
-                    const llama_pos p = batch_in.tokens[i_batch_beg[seq_id] + offset + i].pos[0];
-                    const llama_pos pos_arr[4] = { p, p, p, 0 };
-                    batch_inject.add_embd({ features_buf.data() + (size_t) i * n_embd_enc, 1, (size_t) n_embd_enc }, pos_arr, seq_id, false);
+                    const llama_pos p = batch_in.pos[i_batch_beg[seq_id] + offset + i];
+                    batch_inject.pos[i] = p;
+                    if (is_mrope) {
+                        batch_inject.pos[1 * n_chunk + i] = p;
+                        batch_inject.pos[2 * n_chunk + i] = p;
+                        batch_inject.pos[3 * n_chunk + i] = 0;
+                    }
+                    batch_inject.n_seq_id[i]  = 1;
+                    batch_inject.seq_id[i][0] = seq_id;
+                    batch_inject.logits[i]    = false;
                }
-                const int32_t rc = llama_process(ctx_dft, LLAMA_PROCESS_TYPE_DECODE, batch_inject.get());
+                const int32_t rc = llama_decode(ctx_dft, batch_inject);
                if (rc != 0) {
-                    LOG_ERR("%s: llama_process(ctx_dft) failed rc=%d (n_tokens=%d, offset=%d)\n",
+                    LOG_ERR("%s: llama_decode(ctx_dft) failed rc=%d (n_tokens=%d, offset=%d)\n",
                            __func__, rc, (int) n_chunk, (int) offset);
                    return false;
                }
@@ -1242,7 +1182,7 @@ struct common_speculative_impl_draft_dflash : public common_speculative_impl {
    void draft(common_speculative_draft_params_vec & dparams) override {
        auto & ctx_dft = params.ctx_dft;

-        batch.clear();
+        common_batch_clear(batch);

        // build one batch holding every drafting sequence's noise block into a single decode)
        // record where each block starts and its size
@@ -1262,21 +1202,21 @@ struct common_speculative_impl_draft_dflash : public common_speculative_impl {
            const int32_t n_draft = params.n_max;

            const int32_t n_block_tokens = n_draft + (is_dspark && sample_from_anchor ? 0 : 1);
-            i_block_beg[seq_id] = batch.size();
+            i_block_beg[seq_id] = batch.n_tokens;
            n_block    [seq_id] = n_block_tokens;
            for (int32_t i = 0; i < n_block_tokens; ++i) {
-                batch.add(i == 0 ? dp.id_last : mask_token_id, n + i, seq_id, !is_dflash2);
+                common_batch_add(batch, i == 0 ? dp.id_last : mask_token_id, n + i, { seq_id }, !is_dflash2);
            }
        }

-        if (batch.size() == 0) {
+        if (batch.n_tokens == 0) {
            return;
        }

        // decode all sequence's noise block in a single batch
-        int ret = llama_process(ctx_dft, LLAMA_PROCESS_TYPE_DECODE, batch.get());
+        int ret = llama_decode(ctx_dft, batch);
        if (ret != 0) {
-            LOG_WRN("%s: llama_process returned %d\n", __func__, ret);
+            LOG_WRN("%s: llama_decode returned %d\n", __func__, ret);
            return;
        }

@@ -1390,12 +1330,10 @@ struct common_speculative_impl_draft_dflash : public common_speculative_impl {
 struct common_speculative_impl_draft_mtp : public common_speculative_impl {
    common_params_speculative_draft params; // reuses the draft-model params slot (ctx_tgt/ctx_dft)

-    common_batch batch;
+    llama_batch batch;

    std::vector<common_sampler_ptr> smpls;

-    std::vector<common_params_sampling> smpls_cfg;
-
    // backend sampler chain per seq, attached to ctx_dft
    std::vector<llama_sampler *> backend_chains;

@@ -1448,7 +1386,11 @@ struct common_speculative_impl_draft_mtp : public common_speculative_impl {
                ctx_dft ? "yes" : "no",
                common_speculative_get_devices_str(this->params.devices).c_str());

-        batch = common_batch(ctx_dft);
+        const int32_t n_b = (int32_t) llama_n_batch(ctx_dft);
+        batch = llama_batch_init(/*n_tokens=*/ n_b, /*embd=*/ n_embd, /*n_seq_max=*/ 1);
+        // llama_batch_init allocates only one of token/embd; MTP needs both.
+        // TODO: fix, how to call without malloc
+        batch.token = (llama_token *) malloc(sizeof(llama_token) * n_b);

        smpls.resize(n_seq);
        for (auto & s : smpls) {
@@ -1513,12 +1455,15 @@ struct common_speculative_impl_draft_mtp : public common_speculative_impl {
            llama_sampler_free(backend_chains[seq_id]);
        }
        backend_chains.clear();
+
+        if (batch.token != nullptr) {
+            free(batch.token);
+            batch.token = nullptr;
+        }
+        llama_batch_free(batch);
    }

    void begin(llama_seq_id seq_id, const llama_tokens & prompt) override {
-        // reset here rather than per round, or two identical requests differ
-        common_sampler_reset(smpls[seq_id].get());
-
        const int32_t N = (int32_t) prompt.size();
        if (N <= 0) {
            return;
@@ -1530,23 +1475,23 @@ struct common_speculative_impl_draft_mtp : public common_speculative_impl {
        if (pos_max < N - 1 && !is_mem_shared) {
            SPC_WRN("ctx_dft pos_max=%d < N-1=%d - "
                    "process() hook may not have run on every prefill ubatch "
-                    "(need_embd / output flag on every prompt position?). "
+                    "(need_embd / logits=1 on every prompt position?). "
                    "Drafts may degrade.\n",
                    (int) pos_max, N - 1);
        }
    }

-    bool process(const common_batch & batch_in) override {
-        if (batch_in.size() <= 0) {
+    bool process(const llama_batch & batch_in) override {
+        if (batch_in.n_tokens <= 0) {
            return true;
        }

        // TODO: how to make it work with vision tokens?
-        if (!batch_in.has_token() || batch_in.has_embd()) {
+        if (batch_in.token == nullptr || batch_in.embd != nullptr) {
            return true;
        }

-        const int32_t n_tokens = batch_in.size();
+        const int32_t n_tokens = batch_in.n_tokens;

        // remember the first and last batch index for each sequence
        std::fill(i_batch_beg.begin(), i_batch_beg.end(), -1);
@@ -1554,7 +1499,9 @@ struct common_speculative_impl_draft_mtp : public common_speculative_impl {

        for (int k = 0; k < n_tokens; ++k) {
            for (llama_seq_id seq_id = 0; seq_id < (llama_seq_id) n_seq; ++seq_id) {
-                if (batch_in.tokens[k].seq_id == seq_id) {
+                GGML_ASSERT(batch_in.n_seq_id[k] == 1);
+
+                if (batch_in.seq_id[k][0] == seq_id) {
                    i_batch_end[seq_id] = k;
                    if (i_batch_beg[seq_id] < 0) {
                        i_batch_beg[seq_id] = k;
@@ -1570,26 +1517,33 @@ struct common_speculative_impl_draft_mtp : public common_speculative_impl {

        // if kv is shared with target (e.g Gemma4), then we can skip this catch-up decode
        if (!is_mem_shared) {
-            batch.clear();
+            common_batch_clear(batch);

-            // pair each token with the tgt embedding shifted right by one position, and
-            // the first token of each sequence with the pending embedding from a previous run
+            for (int k = 0; k < n_tokens; ++k) {
+                common_batch_add(batch, batch_in.token[k], batch_in.pos[k], { batch_in.seq_id[k][0] }, 0);
+            }
+
+            // shift the tgt embeddings to the right by one position
            // assumes that the tokens in the batch are sequential for each sequence
            // i.e. we cannot have seq_id like this: [0, 0, 0, 1, 1, 0, 1, 1]
            //                                                       ^--- this is a problem
            // TODO:this is generally true, but would be nice to assert it
-            const float * h_tgt = llama_get_embeddings_nextn(ctx_tgt);
+            {
+                const float * h_tgt = llama_get_embeddings_nextn(ctx_tgt);
+                std::memcpy(batch.embd + (size_t) 1 * n_embd, h_tgt, row_bytes * (n_tokens-1));
+            }

-            for (int k = 0; k < n_tokens; ++k) {
-                const llama_seq_id seq_id = batch_in.tokens[k].seq_id;
+            // fill the pending embeddings from a previous run
+            auto set_h = [&](int idx, const float * h_row) {
+                std::memcpy(batch.embd + (size_t) idx * n_embd, h_row, row_bytes);
+            };

-                const int32_t idx = batch.add(batch_in.tokens[k].id, batch_in.tokens[k].pos[0], seq_id, false);
+            for (llama_seq_id seq_id = 0; seq_id < (llama_seq_id) n_seq; ++seq_id) {
+                if (i_batch_beg[seq_id] < 0) {
+                    continue;
+                }

-                const float * h_row = k == i_batch_beg[seq_id]
-                    ? pending_h[seq_id].data()
-                    : h_tgt + (size_t) (k - 1) * n_embd;
-
-                batch.set_embd(idx, { h_row, 1, (size_t) n_embd });
+                set_h(i_batch_beg[seq_id], pending_h[seq_id].data());
            }

            auto * mem_dft = llama_get_memory(ctx_dft);
@@ -1602,15 +1556,15 @@ struct common_speculative_impl_draft_mtp : public common_speculative_impl {
                        if (i_batch_beg[seq_id] < 0) {
                            continue;
                        }
-                        llama_memory_seq_rm(mem_dft, seq_id, batch_in.tokens[i_batch_beg[seq_id]].pos[0], -1);
+                        llama_memory_seq_rm(mem_dft, seq_id, batch_in.pos[i_batch_beg[seq_id]], -1);
                    }
                    llama_set_nextn_layer_offset(ctx_dft, head);
                }

-                const int32_t rc = llama_process(ctx_dft, LLAMA_PROCESS_TYPE_DECODE, batch.get());
+                const int32_t rc = llama_decode(ctx_dft, batch);
                if (rc != 0) {
-                    SPC_ERR("llama_process(ctx_dft) head=%d failed rc=%d (pos=%d)\n",
-                            head, (int) rc, (int) batch_in.tokens[0].pos[0]);
+                    SPC_ERR("llama_decode(ctx_dft) head=%d failed rc=%d (pos=%d)\n",
+                            head, (int) rc, (int) batch_in.pos[0]);
                    ok = false;
                    break;
                }
@@ -1648,12 +1602,14 @@ struct common_speculative_impl_draft_mtp : public common_speculative_impl {
    void draft(common_speculative_draft_params_vec & dparams) override {
        auto & ctx_dft = params.ctx_dft;

-        batch.clear();
+        common_batch_clear(batch);

        // keep track of which sequences are still drafting
        int n_drafting = 0;
        std::vector<bool> drafting(n_seq);

+        const size_t row_bytes = (size_t) n_embd * sizeof(float);
+
        for (llama_seq_id seq_id = 0; seq_id < (llama_seq_id) n_seq; ++seq_id) {
            auto & dp = dparams[seq_id];

@@ -1663,25 +1619,12 @@ struct common_speculative_impl_draft_mtp : public common_speculative_impl {

            n_drafting++;
            drafting[seq_id] = true;
-            // greedy drafting leaves no candidates behind, so the verifier falls back to sample-and-match
-            if (!params.probabilistic) {
-                dp.result_q = nullptr;
-            }
+            common_sampler_reset(smpls[seq_id].get());

-            // result_q is only set when the caller wants rejection, so it also gates the retune
-            if (dp.result_q) {
-                spec_retune(smpls, smpls_cfg, llama_get_model(ctx_dft), seq_id, dp.temp, dp.seed);
-            }
+            common_batch_add(batch, dp.id_last, dp.pos0, { seq_id }, true);
+            std::memcpy(batch.embd + (size_t) (batch.n_tokens - 1) * n_embd, pending_h[seq_id].data(), row_bytes);

-            // a reset reseeds the chain, which breaks probabilistic drafting
-            if (!dp.result_q) {
-                common_sampler_reset(smpls[seq_id].get());
-            }
-
-            const int32_t idx = batch.add(dp.id_last, dp.pos0, seq_id, true);
-            batch.set_embd(idx, { pending_h[seq_id].data(), 1, (size_t) n_embd });
-
-            i_last[seq_id] = idx;
+            i_last[seq_id] = batch.n_tokens - 1;

            if (chain_heads) {
                chain_h[seq_id].assign(pending_h[seq_id].begin(), pending_h[seq_id].end());
@@ -1707,16 +1650,16 @@ struct common_speculative_impl_draft_mtp : public common_speculative_impl {
                llama_set_nextn_layer_offset(ctx_dft, i);
            }

-            int ret = llama_process(ctx_dft, LLAMA_PROCESS_TYPE_DECODE, batch.get());
+            int ret = llama_decode(ctx_dft, batch);
            if (ret != 0) {
-                SPC_ERR("llama_process[%d] returned %d\n", i, ret);
+                SPC_ERR("llama_decode[%d] returned %d\n", i, ret);
                break;
            }

            // rebuild the batch for the next step: the growing-KV paths re-add only the
            // new token (the KV already holds the prefix), while chained heads re-add the
            // whole prefix at the next head. dropped sequences are simply not re-added.
-            batch.clear();
+            common_batch_clear(batch);

            for (llama_seq_id seq_id = 0; seq_id < (llama_seq_id) n_seq; ++seq_id) {
                if (!drafting[seq_id]) {
@@ -1725,7 +1668,7 @@ struct common_speculative_impl_draft_mtp : public common_speculative_impl {

                auto * smpl = smpls[seq_id].get();

-                const llama_token id_sampled = common_sampler_sample(smpl, ctx_dft, i_last[seq_id], true);
+                common_sampler_sample(smpl, ctx_dft, i_last[seq_id], true);
                const float * h_row = llama_get_embeddings_nextn_ith(ctx_dft, i_last[seq_id]);

                const auto * cur_p = common_sampler_get_candidates(smpl, true);
@@ -1737,7 +1680,7 @@ struct common_speculative_impl_draft_mtp : public common_speculative_impl {
                }

                // add drafted token for each sequence
-                const llama_token id = dparams.at(seq_id).result_q ? id_sampled : cur_p->data[0].id;
+                const llama_token id = cur_p->data[0].id;

                // only collect very high-confidence draft tokens
                if (cur_p->data[0].p < params.p_min) {
@@ -1754,10 +1697,6 @@ struct common_speculative_impl_draft_mtp : public common_speculative_impl {

                result.push_back(id);

-                if (dp.result_q) {
-                    dp.result_q->emplace_back(cur_p->data, cur_p->data + cur_p->size);
-                }
-
                if (params.n_max <= (int) result.size()) {
                    drafting[seq_id] = false;
                    n_drafting--;
@@ -1771,24 +1710,24 @@ struct common_speculative_impl_draft_mtp : public common_speculative_impl {
                    const int n_rows = (int) result.size() + 1; // id_last + tokens drafted so far
                    for (int t = 0; t < n_rows; ++t) {
                        const llama_token tok = (t == 0) ? dp.id_last : result[t - 1];
-                        const int32_t idx = batch.add(tok, dp.pos0 + t, seq_id, t == n_rows - 1);
-                        batch.set_embd(idx, { chain_h[seq_id].data() + (size_t) t * n_embd, 1, (size_t) n_embd });
-                        i_last[seq_id] = idx;
+                        common_batch_add(batch, tok, dp.pos0 + t, { seq_id }, t == n_rows - 1);
+                        std::memcpy(batch.embd + (size_t) (batch.n_tokens - 1) * n_embd,
+                                    chain_h[seq_id].data() + (size_t) t * n_embd, row_bytes);
                    }
                } else if (is_mem_shared) {
                    // note: with shared memory (e.g. Gemma4 assistants) we use the same position for all draft tokens
                    // ref: https://github.com/huggingface/transformers/blob/effde20942e3f82a1b97449f60b3a48c5ff96145/docs/source/en/model_doc/gemma4_assistant.md?plain=1#L36-L37
-                    const int32_t idx = batch.add(id, dp.pos0, seq_id, true);
-                    batch.set_embd(idx, { h_row, 1, (size_t) n_embd });
-                    i_last[seq_id] = idx;
+                    common_batch_add(batch, id, dp.pos0, { seq_id }, true);
+                    std::memcpy(batch.embd + (size_t) (batch.n_tokens - 1) * n_embd, h_row, row_bytes);
                } else {
-                    const int32_t idx = batch.add(id, dp.pos0 + i + 1, seq_id, true);
-                    batch.set_embd(idx, { h_row, 1, (size_t) n_embd });
-                    i_last[seq_id] = idx;
+                    common_batch_add(batch, id, dp.pos0 + i + 1, { seq_id }, true);
+                    std::memcpy(batch.embd + (size_t) (batch.n_tokens - 1) * n_embd, h_row, row_bytes);
                }
+
+                i_last[seq_id] = batch.n_tokens - 1;
            }

-            if (batch.size() == 0) {
+            if (batch.n_tokens == 0) {
                break;
            }

@@ -1850,7 +1789,7 @@ struct common_speculative_impl_ngram_simple : public common_speculative_impl {
        // noop
    }

-    bool process(const common_batch & /*batch*/) override {
+    bool process(const llama_batch & /*batch*/) override {
        // TODO: implement
        return true;
    }
@@ -1898,7 +1837,7 @@ struct common_speculative_impl_ngram_map_k : public common_speculative_impl {
        common_ngram_map_begin(config[seq_id], prompt);
    }

-    bool process(const common_batch & /*batch*/) override {
+    bool process(const llama_batch & /*batch*/) override {
        // TODO: implement
        return true;
    }
@@ -2056,7 +1995,7 @@ struct common_speculative_impl_ngram_mod : public common_speculative_impl {
        sinfo.n_draft_last = result.size();
    }

-    bool process(const common_batch & /*batch*/) override {
+    bool process(const llama_batch & /*batch*/) override {
        // TODO: implement
        return true;
    }
@@ -2218,7 +2157,7 @@ struct common_speculative_impl_ngram_cache : public common_speculative_impl {
        }
    }

-    bool process(const common_batch & /*batch*/) override {
+    bool process(const llama_batch & /*batch*/) override {
        // TODO: implement
        return true;
    }
@@ -2620,7 +2559,7 @@ common_speculative_init_result::common_speculative_init_result(
        model_path = params.speculative.draft.mparams.path;
        LOG_INF("%s: loading draft model '%s'\n", __func__, model_path.c_str());

-        llama_model * model_dft = llama_model_load_from_file(model_path.c_str(), mparams);
+        llama_model * model_dft = llama_model_load_from_file(params.model.path.c_str(), mparams);
        if (model_dft == NULL) {
            LOG_ERR("%s: failed to load draft model, '%s'\n", __func__, model_path.c_str());
            return;
@@ -2851,7 +2790,7 @@ void common_speculative_begin(common_speculative * spec, llama_seq_id seq_id, co
    }
 }

-bool common_speculative_process(common_speculative * spec, const common_batch & batch) {
+bool common_speculative_process(common_speculative * spec, const llama_batch & batch) {
    bool result = true;

    if (spec == nullptr) {
@@ -2914,11 +2853,6 @@ void common_speculative_draft(common_speculative * spec) {
                    if (!result.empty() && (int) result.size() > dp.n_max) {
                        SPC_DBG("truncating draft to %d tokens\n", dp.n_max);
                        result.resize(dp.n_max);
-
-                        // the candidates are one per drafted token and must be cut with them
-                        if (dp.result_q) {
-                            dp.result_q->resize(dp.n_max);
-                        }
                    }
                }

@@ -69,13 +69,6 @@ struct common_speculative_draft_params {

    // the generated draft from the last _draft() call
    llama_tokens * result;
-
-    // candidate distribution per drafted token; set it to make draft-simple and draft-mtp sample
-    std::vector<std::vector<llama_token_data>> * result_q = nullptr;
-
-    // the target's temp and seed, read only when the drafter samples probabilistically
-    float    temp = 1.0f;
-    uint32_t seed = LLAMA_DEFAULT_SEED;
 };

 common_speculative_draft_params & common_speculative_get_draft_params(common_speculative * spec, llama_seq_id seq_id);
@@ -84,7 +77,7 @@ common_speculative_draft_params & common_speculative_get_draft_params(common_spe
 void common_speculative_begin(common_speculative * spec, llama_seq_id seq_id, const llama_tokens & prompt);

 // process the batch and update the internal state of the speculative context
-bool common_speculative_process(common_speculative * spec, const common_batch & batch);
+bool common_speculative_process(common_speculative * spec, const llama_batch & batch);

 // generate drafts for the sequences specified with `common_speculative_get_draft_params`
 void common_speculative_draft(common_speculative * spec);
@@ -26,16 +26,16 @@ utf8_parse_result common_parse_utf8_codepoint(std::string_view input, size_t off

    // Invalid: continuation byte as first byte
    if (!(input[offset] & 0x40)) {
-        return utf8_parse_result(utf8_parse_result::INVALID, 0, 1);
+        return utf8_parse_result(utf8_parse_result::INVALID);
    }

    // 2-byte sequence
    if (!(input[offset] & 0x20)) {
        if (offset + 1 >= input.size()) {
-            return utf8_parse_result(utf8_parse_result::INCOMPLETE, 0, 1);
+            return utf8_parse_result(utf8_parse_result::INCOMPLETE);
        }
        if ((input[offset + 1] & 0xc0) != 0x80) {
-            return utf8_parse_result(utf8_parse_result::INVALID, 0, 1);
+            return utf8_parse_result(utf8_parse_result::INVALID);
        }
        auto result = ((input[offset] & 0x1f) << 6) | (input[offset + 1] & 0x3f);
        return utf8_parse_result(utf8_parse_result::SUCCESS, result, 2);
@@ -43,14 +43,11 @@ utf8_parse_result common_parse_utf8_codepoint(std::string_view input, size_t off

    // 3-byte sequence
    if (!(input[offset] & 0x10)) {
-        // Check one byte at a time so a bad byte is reported before a short input
-        for (size_t i = 1; i < 3; i++) {
-            if (offset + i >= input.size()) {
-                return utf8_parse_result(utf8_parse_result::INCOMPLETE, 0, i);
-            }
-            if ((input[offset + i] & 0xc0) != 0x80) {
-                return utf8_parse_result(utf8_parse_result::INVALID, 0, i);
-            }
+        if (offset + 2 >= input.size()) {
+            return utf8_parse_result(utf8_parse_result::INCOMPLETE);
+        }
+        if ((input[offset + 1] & 0xc0) != 0x80 || (input[offset + 2] & 0xc0) != 0x80) {
+            return utf8_parse_result(utf8_parse_result::INVALID);
        }
        auto result = ((input[offset] & 0x0f) << 12) | ((input[offset + 1] & 0x3f) << 6) | (input[offset + 2] & 0x3f);
        return utf8_parse_result(utf8_parse_result::SUCCESS, result, 3);
@@ -58,20 +55,18 @@ utf8_parse_result common_parse_utf8_codepoint(std::string_view input, size_t off

    // 4-byte sequence
    if (!(input[offset] & 0x08)) {
-        for (size_t i = 1; i < 4; i++) {
-            if (offset + i >= input.size()) {
-                return utf8_parse_result(utf8_parse_result::INCOMPLETE, 0, i);
-            }
-            if ((input[offset + i] & 0xc0) != 0x80) {
-                return utf8_parse_result(utf8_parse_result::INVALID, 0, i);
-            }
+        if (offset + 3 >= input.size()) {
+            return utf8_parse_result(utf8_parse_result::INCOMPLETE);
+        }
+        if ((input[offset + 1] & 0xc0) != 0x80 || (input[offset + 2] & 0xc0) != 0x80 || (input[offset + 3] & 0xc0) != 0x80) {
+            return utf8_parse_result(utf8_parse_result::INVALID);
        }
        auto result = ((input[offset] & 0x07) << 18) | ((input[offset + 1] & 0x3f) << 12) | ((input[offset + 2] & 0x3f) << 6) | (input[offset + 3] & 0x3f);
        return utf8_parse_result(utf8_parse_result::SUCCESS, result, 4);
    }

    // Invalid first byte
-    return utf8_parse_result(utf8_parse_result::INVALID, 0, 1);
+    return utf8_parse_result(utf8_parse_result::INVALID);
 }

 bool common_utf8_is_complete(const std::string & s) {
@@ -9,7 +9,7 @@

 struct utf8_parse_result {
    uint32_t codepoint;      // Decoded codepoint (only valid if status == SUCCESS)
-    size_t bytes_consumed;   // How many bytes this codepoint uses (1-4), or the length of the valid prefix if status != SUCCESS
+    size_t bytes_consumed;   // How many bytes this codepoint uses (1-4)
    enum status { SUCCESS, INCOMPLETE, INVALID } status;

    utf8_parse_result(enum status s, uint32_t cp = 0, size_t bytes = 0)
@@ -28,7 +28,6 @@ TEXT_MODEL_MAP: dict[str, str] = {
    "BailingMoeForCausalLM": "bailingmoe",
    "BailingMoeV2ForCausalLM": "bailingmoe",
    "BailingMoeV3ForCausalLM": "bailingmoe3",
-    "BailingMoeV3VLForConditionalGeneration": "bailingmoe3",
    "BambaForCausalLM": "granite",
    "BertForMaskedLM": "bert",
    "BertForSequenceClassification": "bert",
@@ -42,7 +41,6 @@ TEXT_MODEL_MAP: dict[str, str] = {
    "ChameleonForConditionalGeneration": "chameleon",
    "ChatGLMForConditionalGeneration": "chatglm",
    "ChatGLMModel": "chatglm",
-    "ClefModel": "clef",
    "CodeShellForCausalLM": "codeshell",
    "CogVLMForCausalLM": "cogvlm",
    "Cohere2MoeForCausalLM": "command_r",
@@ -96,7 +94,6 @@ TEXT_MODEL_MAP: dict[str, str] = {
    "Gemma3nForCausalLM": "gemma",
    "Gemma3nForConditionalGeneration": "gemma",
    "Gemma4AssistantForCausalLM": "gemma",
-    "Gemma4DSparkModel": "gemma",
    "Gemma4ForConditionalGeneration": "gemma",
    "Gemma4ForCausalLM": "gemma",
    "Gemma4UnifiedForConditionalGeneration": "gemma",
@@ -107,7 +104,6 @@ TEXT_MODEL_MAP: dict[str, str] = {
    "Glm4MoeLiteForCausalLM": "glm",
    "Glm4vForConditionalGeneration": "glm",
    "Glm4vMoeForConditionalGeneration": "glm",
-    "Glm5NextForConditionalGeneration": "glm",
    "GlmForCausalLM": "chatglm",
    "GlmMoeDsaForCausalLM": "glm",
    "GlmOcrForConditionalGeneration": "glm",
@@ -127,7 +123,6 @@ TEXT_MODEL_MAP: dict[str, str] = {
    "HunYuanDenseV1ForCausalLM": "hunyuan",
    "HunYuanMoEV1ForCausalLM": "hunyuan",
    "HunYuanVLForConditionalGeneration": "hunyuan",
-    "HrmTextForCausalLM": "hrm_text",
    "HYV3ForCausalLM": "hunyuan",
    "HYV4ForCausalLM": "hy_v4",
    "IQuestCoderForCausalLM": "llama",
@@ -151,11 +146,7 @@ TEXT_MODEL_MAP: dict[str, str] = {
    "LLaDAMoEModelLM": "llada",
    "LLaDAModelLM": "llada",
    "LLaMAForCausalLM": "llama",
-    "KevModel": "lev",
-    "LevModel": "lev",
-    "NimbleModel": "lev",
    "Lfm25AudioTokenizer": "lfm2",
-    "Lfm2BidirectionalForMaskedLM": "lfm2",
    "Lfm2BidirectionalModel": "lfm2",
    "Lfm2ForCausalLM": "lfm2",
    "Lfm2Model": "lfm2",
@@ -177,7 +168,6 @@ TEXT_MODEL_MAP: dict[str, str] = {
    "Mamba2ForCausalLM": "mamba",
    "MambaForCausalLM": "mamba",
    "MambaLMHeadModel": "mamba",
-    "MapleForCausalLM": "maple",
    "MellumForCausalLM": "mellum",
    "MiMoV2FlashForCausalLM": "mimo",
    "MiMoV2ForCausalLM": "mimo",
@@ -193,7 +183,6 @@ TEXT_MODEL_MAP: dict[str, str] = {
    "Mistral3ForConditionalGeneration": "mistral3",
    "MistralForCausalLM": "llama",
    "MixtralForCausalLM": "llama",
-    "ModernBertDecisionModel": "bert",
    "ModernBertForMaskedLM": "bert",
    "ModernBertForSequenceClassification": "bert",
    "ModernBertModel": "bert",
@@ -213,7 +202,6 @@ TEXT_MODEL_MAP: dict[str, str] = {
    "MuseGlimmerAssistantModel": "muse_glimmer",
    "MuseGlimmerForConditionalGeneration": "muse_glimmer",
    "OpenELMForCausalLM": "openelm",
-    "OpenJevModel": "qwen",
    "OrionForCausalLM": "orion",
    "PLMForCausalLM": "plm",
    "PLaMo2ForCausalLM": "plamo",
@@ -298,7 +286,6 @@ TEXT_MODEL_MAP: dict[str, str] = {

 MMPROJ_MODEL_MAP: dict[str, str] = {
    "AudioFlamingo3ForConditionalGeneration": "ultravox",
-    "ClefModel": "clef",
    "CogVLMForCausalLM": "cogvlm",
    "DeepseekOCR2ForCausalLM": "deepseek",
    "DeepseekOCRForCausalLM": "deepseek",
@@ -312,9 +299,7 @@ MMPROJ_MODEL_MAP: dict[str, str] = {
    "Gemma4ForConditionalGeneration": "gemma",
    "Gemma4UnifiedForConditionalGeneration": "gemma",
    "Glm4vForConditionalGeneration": "qwen3vl",
-    "BailingMoeV3VLForConditionalGeneration": "bailingmoe3",
    "Glm4vMoeForConditionalGeneration": "qwen3vl",
-    "Glm5NextForConditionalGeneration": "qwen3vl",
    "Glm5vForConditionalGeneration": "kimivl",
    "GlmOcrForConditionalGeneration": "qwen3vl",
    "GlmasrModel": "ultravox",
@@ -352,7 +337,6 @@ MMPROJ_MODEL_MAP: dict[str, str] = {
    "Qwen3TTSForConditionalGeneration": "qwen3tts",
    "Qwen3VLForConditionalGeneration": "qwen3vl",
    "Qwen3VLMoeForConditionalGeneration": "qwen3vl",
-    "OpenJevModel": "qwen3vl",
    "Qwen3_5ForConditionalGeneration": "qwen3vl",
    "Qwen3_5MoeForConditionalGeneration": "qwen3vl",
    "Qwen4ExpForConditionalGeneration": "qwen4exp",
@@ -9,9 +9,7 @@ import torch
 if TYPE_CHECKING:
    from torch import Tensor

-from .base import ModelBase, MmprojModel, TextModel, gguf
-
-from .qwen3vl import Qwen3VLVisionModel
+from .base import ModelBase, TextModel, gguf


@ModelBase.register("BailingMoeV3ForCausalLM")
@@ -76,7 +74,7 @@ class BailingMoeV3Model(TextModel):

        self.gguf_writer.add_expert_feed_forward_length(self.hparams["moe_intermediate_size"])
        self.gguf_writer.add_expert_shared_feed_forward_length(self.hparams["moe_shared_expert_intermediate_size"])
-        self.gguf_writer.add_expert_shared_count(self.hparams.get("num_shared_experts", 1))
+        self.gguf_writer.add_expert_shared_count(self.hparams["num_shared_experts"])
        self.gguf_writer.add_leading_dense_block_count(self.hparams["first_k_dense_replace"])
        self.gguf_writer.add_expert_weights_scale(self.hparams["routed_scaling_factor"])
        self.gguf_writer.add_expert_weights_norm(self.hparams["norm_topk_prob"])
@@ -193,111 +191,3 @@ class BailingMoeV3Model(TextModel):
            experts = [name for layer in self._experts for name in layer]
            if experts:
                raise ValueError(f"Unprocessed experts: {experts}")
-
-
-@ModelBase.register("BailingMoeV3VLForConditionalGeneration")
-@ModelBase.example("inclusionAI/Ling-3.0-flash-VL")
-class BailingMoeV3VLModel(BailingMoeV3Model):
-    model_arch = gguf.MODEL_ARCH.BAILINGMOE3
-
-    def index_tensors(self, remote_hf_model_id: str | None = None):
-        # hoist text_config before the shared BailingMoeV3 logic runs:
-        # ModelBase.__init__ calls this with the raw VL config, where the text
-        # dims still live under text_config
-        if "text_config" in self.hparams:
-            self.hparams = {**self.hparams, **self.hparams["text_config"]}
-        return super().index_tensors(remote_hf_model_id=remote_hf_model_id)
-
-    def set_gguf_parameters(self):
-        super().set_gguf_parameters()
-        mrope_section = self.hparams.get("mrope_section")
-        if mrope_section is None:
-            raise ValueError("BailingMoeV3VL requires mrope_section in the config")
-        if sum(mrope_section[:3]) * 2 != self.hparams["qk_rope_head_dim"]:
-            raise ValueError(
-                f"mrope_section {mrope_section[:3]} counts rope pairs and must sum to"
-                f" qk_rope_head_dim / 2 = {self.hparams['qk_rope_head_dim'] // 2}"
-            )
-        # mrope_section is [t, h, w]; pad to the 4-wide sections array
-        self.gguf_writer.add_rope_dimension_sections(list(mrope_section[:3]) + [0])
-
-    @classmethod
-    def filter_tensors(cls, item: tuple[str, Callable[[], Tensor]]) -> tuple[str, Callable[[], Tensor]] | None:
-        name, gen = item
-
-        # Skip projector tensors; the vision tower is skipped by TextModel.filter_tensors
-        if name.startswith("linear_proj"):
-            return None
-
-        return super().filter_tensors(item)
-
-
-@ModelBase.register("BailingMoeV3VLForConditionalGeneration")
-@ModelBase.example("inclusionAI/Ling-3.0-flash-VL")
-class BailingMoeV3VLVisionModel(Qwen3VLVisionModel):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        assert self.hparams_vision is not None
-
-        if self.hparams_vision.get("disable_merger_proj") is not True:
-            raise ValueError("BailingMoeV3VL requires disable_merger_proj=true")
-
-        # out_hidden_size is the vision encoder output (post spatial merge, pre linear_proj)
-        self.image_emb_dim = self.hparams_vision.get("out_hidden_size")
-        if self.image_emb_dim is None:
-            raise ValueError("BailingMoeV3VL vision config requires out_hidden_size")
-
-    def set_gguf_parameters(self):
-        assert self.hparams_vision is not None
-        MmprojModel.set_gguf_parameters(self)  # skip Qwen3VLVisionModel parameters
-        self.gguf_writer.add_clip_projector_type(gguf.VisionProjectorType.LING3VL)
-        self.gguf_writer.add_vision_use_gelu(True)
-
-        merge_size = self.hparams_vision.get("spatial_merge_size")
-        if merge_size is not None:
-            self.gguf_writer.add_vision_spatial_merge_size(int(merge_size))
-
-        rms_norm_eps = self.global_config.get("text_config", {}).get("rms_norm_eps", 1e-6)
-        self.gguf_writer.add_vision_attention_layernorm_eps(rms_norm_eps)
-
-    @classmethod
-    def filter_tensors(cls, item: tuple[str, Callable[[], Tensor]]) -> tuple[str, Callable[[], Tensor]] | None:
-        name, gen = item
-
-        if name.startswith("lm_head."):
-            return None
-
-        if name.startswith("linear_proj"):
-            # top-level projector MLP: linear_proj.0 -> mm.0, linear_proj.2 -> mm.2
-            parts = name.split(".")
-            if len(parts) != 3:
-                raise ValueError(f"Unexpected linear_proj tensor: {name}")
-            idx, suffix = int(parts[1]), parts[2]
-            name = f"mm.{idx}.{suffix}"
-            # the qwen3vl filter keeps only visual.*; skip it for the renamed projector tensors
-            return MmprojModel.filter_tensors((name, gen))
-
-        if name.startswith("model.visual."):
-            name = name.replace("model.visual.", "visual.", 1)
-
-        if not name.startswith("visual."):
-            return None
-
-        return super().filter_tensors((name, gen))
-
-    def modify_tensors(self, data_torch: Tensor, name: str, bid: int | None) -> Iterable[tuple[str, Tensor]]:
-        assert self.hparams_vision is not None
-
-        if name.startswith("mm.0.") or name.startswith("mm.2."):
-            # top-level projector MLP (linear_proj.0 / linear_proj.2, renamed by filter_tensors)
-            yield (name, data_torch)
-            return
-
-        if name == "visual.merger.norm.weight" or name == "visual.merger.norm.bias":
-            # the merger is norm-only for Ling: per-patch LayerNorm before the spatial merge
-            new_name = f"mm.input_norm.{name.split('.')[-1]}"
-            yield (new_name, data_torch)
-            return
-
-        # Ling has no patch bias; the Conv3D split below matches the stock qwen3vl path
-        yield from Qwen3VLVisionModel.modify_tensors(self, data_torch, name, bid)
@@ -170,9 +170,6 @@ class ModelBase:
        self.dir_model_card = dir_model  # overridden in convert_lora_to_gguf.py
        self._is_nvfp4 = False
        self._is_mxfp4 = False
-        self._nvfp4_global_algo: str | None = None # checkpoint-wide NVFP4 quant_algo
-        self._nvfp4_layer_algo: dict[str, str | None] = {} # per-layer quant_algo, keyed by HF module path
-        self._prec_a4: dict[str, bool] = {} # gguf tensor name -> can use 4-bit (A4) activations
        self._fp8_as_q8 = fp8_as_q8
        self._fp8_dequantized: set[str] = set()

@@ -234,7 +231,7 @@ class ModelBase:

        prefix = "model" if not self.is_mistral_format else "consolidated"
        part_names: list[str] = ModelBase.get_model_part_names(self.dir_model, prefix, ".safetensors")
-        is_safetensors: bool = len(part_names) > 0 or (not self.is_mistral_format and (self.dir_model / "model.safetensors.index.json").is_file())
+        is_safetensors: bool = len(part_names) > 0
        if not is_safetensors:
            part_names = ModelBase.get_model_part_names(self.dir_model, "pytorch_model", ".bin")

@@ -667,18 +664,6 @@ class ModelBase:
                if bias_types:
                    self._fusable_qkv_bias_layers.add(bid)

-    def _tag_prec_a4(self, hf_name: str, gguf_name: str) -> None:
-        # W4A16_NVFP4 should not use 4-bit activations
-        name = hf_name.removesuffix(".weight").removesuffix(".bias")
-        algo = self._nvfp4_global_algo
-        while name:
-            if name in self._nvfp4_layer_algo:
-                algo = self._nvfp4_layer_algo[name]
-                break
-            name = name.rpartition(".")[0]
-        if algo == "W4A16_NVFP4":
-            self._prec_a4[gguf_name] = False
-
    def set_gguf_parameters(self):
        raise NotImplementedError("set_gguf_parameters() must be implemented in subclasses")

@@ -791,36 +776,6 @@ class ModelBase:
        raw = torch.cat((s.unsqueeze(-1), qs.to(torch.uint8)), dim=-1)
        return raw.reshape(rows, n_blocks * 17).cpu().numpy()

-    def _mxfp4_expert_tensor(self, loaders: list[tuple[Callable[[], Tensor], Callable[[], Tensor]]]):
-        """
-        One stacked [n_expert, rows, cols] MXFP4 tensor, built lazily.
-
-        gguf_writer holds every added tensor until the final write, so building
-        this eagerly (like the DeepSeek-V4 path does) keeps every expert in
-        memory at once. lazy means only the tensor being written is resident.
-        """
-        # meta shapes, so this does not read any weights
-        rows, packed_cols = loaders[0][0]().shape
-        n_blocks = (packed_cols * 2) // 32
-        byte_shape = (len(loaders), rows, n_blocks * 17)
-
-        def load(fns: list[tuple[Callable[[], Tensor], Callable[[], Tensor]]]) -> np.ndarray:
-            out = np.empty(byte_shape, dtype=np.uint8)
-            for eid, (packed_fn, scale_fn) in enumerate(fns):
-                out[eid] = self.repack_mxfp4_blocks(
-                    LazyTorchTensor.to_eager(packed_fn()),
-                    LazyTorchTensor.to_eager(scale_fn()),
-                )
-            return out
-
-        # loaders goes through args, not the closure, so that `func` matches
-        # LazyBase's single-argument shape
-        return gguf.LazyNumpyTensor(
-            meta=gguf.LazyNumpyTensor.meta_with_dtype_and_shape(np.uint8, byte_shape),
-            args=(loaders,),
-            func=load,
-        )
-
    @staticmethod
    def _nvfp4_pack(weight: Tensor, scale: Tensor) -> tuple[np.ndarray, list[int]]:
        """Repack NVFP4 ModelOpt tensors into ggml super-block layout.
@@ -852,7 +807,6 @@ class ModelBase:
        raw, shape = self._nvfp4_pack(weight, scale)
        logger.info(f"Repacked {new_name} with shape {shape} and quantization NVFP4")
        self.gguf_writer.add_tensor(new_name, raw, raw_dtype=gguf.GGMLQuantizationType.NVFP4)
-        self._tag_prec_a4(name, new_name)

        self._write_scale_tensor(new_name.replace(".weight", ".scale"), scale2)
        self._write_scale_tensor(new_name.replace(".weight", ".input_scale"), input_scale)
@@ -945,7 +899,6 @@ class ModelBase:
        new_name = self.map_tensor_name(merged_name)
        logger.info(f"Repacked {new_name} with shape [{len(experts)}, {shape[0]}, {shape[1]}] and quantization NVFP4")
        self.gguf_writer.add_tensor(new_name, merged, raw_dtype=gguf.GGMLQuantizationType.NVFP4)
-        self._tag_prec_a4(merged_name, new_name)

        scales.sort(key=lambda x: x[0])
        self._write_scales_tensor(new_name.replace(".weight", ".scale"), [s[1] for s in scales])
@@ -988,9 +941,6 @@ class ModelBase:
            and bool(quant_groups)
            and all(g.get("format") == "nvfp4-pack-quantized" for g in quant_groups.values() if isinstance(g, dict))
        )
-
-        self._nvfp4_global_algo = quant_algo
-
        if quant_algo != "NVFP4":
            if nvfp4_compressed_tensors:
                quant_algo = "NVFP4"
@@ -1000,22 +950,6 @@ class ModelBase:
        self._is_nvfp4 = quant_algo in ("NVFP4", "W4A16_NVFP4")
        self._is_mxfp4 = quant_method == "mxfp4"

-        # Per-tensor NVFP4 precision.
-        self._nvfp4_layer_algo = {}
-        if quant_layers:
-            # store all possible module paths and assert if a quantized layer is not in the model
-            modules: set[str] = set()
-            for name in self.model_tensors:
-                while name := name.rpartition(".")[0]:
-                    modules.add(name)
-
-            for layer_name, entry in quant_layers.items():
-                if not isinstance(entry, dict):
-                    continue
-                if titem := self.filter_tensors((layer_name, lambda: torch.empty(0))):
-                    assert titem[0] in modules, f"quantized_layers entry {layer_name!r} is not in the model tensors"
-                    self._nvfp4_layer_algo[titem[0]] = entry.get("quant_algo")
-
        # NVFP4 weights are repacked and written directly to gguf_writer.
        # This must run before dequant_model so NVFP4 tensors are removed
        # from model_tensors, leaving only non-NVFP4 (e.g. FP8) for dequant.
@@ -1221,12 +1155,6 @@ class ModelBase:
        logger.info("Set model quantization version")
        self.gguf_writer.add_quantization_version(gguf.GGML_QUANT_VERSION)

-        if self._prec_a4:
-            names = sorted(self._prec_a4.keys())
-            values = [self._prec_a4[n] for n in names]
-            logger.info(f"Set prec_a4 metadata for {len(names)} tensor(s)")
-            self.gguf_writer.add_tensor_extra_prec_a4(names, values)
-
    def write_vocab(self):
        raise NotImplementedError("write_vocab() must be implemented in subclasses")

@@ -1268,24 +1196,22 @@ class ModelBase:
        return inner

    @staticmethod
-    def load_hparams(dir_model: Path, is_mistral_format: bool, guess: bool = True):
+    def load_hparams(dir_model: Path, is_mistral_format: bool):
        if is_mistral_format:
            with open(dir_model / "params.json", "r", encoding="utf-8") as f:
                config = json.load(f)
            return config

-        # checkpoints with a non-HF layout are matched by their own loader
-        # models with a HF layout can also register a hparams loader to switch to a custom class
-        config = ModelBase.load_hparams_guess(dir_model) if guess and dir_model.is_dir() else None
-        if config is not None:
-            return config
-
        try:
            # for security reason, we don't allow loading remote code by default
            # if a model need remote code, we will fallback to config.json
            config = AutoConfig.from_pretrained(dir_model, trust_remote_code=False).to_dict()
        except Exception as e:
            logger.warning(f"Failed to load model config from {dir_model}: {e}")
+            if not (dir_model / "config.json").is_file():
+                config = ModelBase.load_hparams_guess(dir_model)
+                if config is not None:
+                    return config
            logger.warning("Trying to load config.json instead")
            with open(dir_model / "config.json", "r", encoding="utf-8") as f:
                config = json.load(f)
@@ -1707,9 +1633,6 @@ class TextModel(ModelBase):
        if chkhsh == "9e454714343b69b99b71795c1d27a68c2a1d15dab111f4d353109f966af29da7":
            # ref: https://huggingface.co/LiquidAI/LFM2.5-8B-A1B
            res = "lfm2"
-        if chkhsh == "846deafc5b0fa786186fa4ae6c7b49903cf2f1d1895bdb80b9120d60be135252":
-            # ref: https://huggingface.co/danish-foundation-models/DFM-Mimir
-            res = "gemma4"
        if chkhsh == "0a766d034107bc736a3f2dc4968fd62e54a3570f1454443e0c5a4cc6bd7941ed":
            # ref: https://huggingface.co/XHToken/Spark-X2.5-1.7B
            res = "spark2_5"
@@ -1935,12 +1858,6 @@ class TextModel(ModelBase):
        if chkhsh == "972da7b59cec44d1f0a490a86c96df53859e486e481563e5dddac155013d87ac":
            # ref: https://huggingface.co/poolside/Laguna-XS.2
            res = "laguna"
-        if chkhsh == "653660222fb704f61cbf2b618a8ae6502b7f8b20c980f9a5de07ed78e13319cd":
-            # ref: https://huggingface.co/ufakai/ufakzeka-1
-            res = "ufakzeka"
-        if chkhsh == "4b05e02dad1c5ae07d266fd3342ddb644c6f6be058d728bc0a33af31a1d6ee66":
-            # ref: https://huggingface.co/jhu-clsp/mmBERT-base
-            res = "mmbert"

        if res is None:
            logger.warning("\n")
@@ -2331,12 +2248,6 @@ class TextModel(ModelBase):
                raise NotImplementedError("Only MEAN, CLS, and LAST pooling types supported")
            self.gguf_writer.add_pooling_type(pooling_type)

-        # pooling before a classification head (e.g. ModernBertForSequenceClassification)
-        if (classifier_pooling := self.hparams.get("classifier_pooling")) is not None:
-            if classifier_pooling not in ("cls", "mean"):
-                raise NotImplementedError(f"Unsupported classifier_pooling: {classifier_pooling}")
-            self.gguf_writer.add_classifier_pooling_type(mode_mapping[classifier_pooling])
-
    def _set_vocab_glmedge(self):
        from transformers import AutoTokenizer
        tokenizer = AutoTokenizer.from_pretrained(self.dir_model)
@@ -2571,11 +2482,6 @@ class TextModel(ModelBase):

        self.gguf_writer.add_add_space_prefix(False)

-        if (add_bos := tokenizer_config.get("add_bos_token")) is not None:
-            self.gguf_writer.add_add_bos_token(add_bos)
-        if (add_eos := tokenizer_config.get("add_eos_token")) is not None:
-            self.gguf_writer.add_add_eos_token(add_eos)
-

 class MmprojModel(ModelBase):
    model_type = ModelType.MMPROJ
@@ -2885,11 +2791,6 @@ else:
    LazyTorchTensor._dtype_str_map["F8_E8M0"] = torch.uint8


-def jinja_str_or_json(name: str) -> str:
-    # jinja expression that renders a variable as-is if it is a string, as JSON otherwise
-    return "{{ " + name + " if " + name + " is string else " + name + " | tojson }}"
-
-
 def get_model_architecture(hparams: dict[str, Any], model_type: ModelType) -> str:
    # TODO @ngxson : this won't work correctly if the model has both audio & vision encoders
    # maybe we should fallback to text model's arch in that case, since not many models have both
@@ -11,7 +11,7 @@ import torch
 if TYPE_CHECKING:
    from torch import Tensor

-from .base import ModelBase, SentencePieceTokenTypes, TextModel, gguf, jinja_str_or_json, logger
+from .base import ModelBase, SentencePieceTokenTypes, TextModel, gguf, logger


@ModelBase.register("BertModel", "BertForMaskedLM", "CamembertModel", "BertForSequenceClassification")
@@ -341,7 +341,7 @@ class NomicBertModel(BertModel):
        else:
            raise ValueError(f"unrecognized parameters: n_positions={npos}, max_trained_positions={mtp}")

-        assert self.hparams["activation_function"] == ("gelu" if self.is_moe else "swiglu")
+        assert self.hparams["activation_function"] == "gelu" if self.is_moe else "swiglu"

        # this doesn't do anything in the HF version
        assert self.hparams["causal"] is False
@@ -606,17 +606,6 @@ class ModernBertModel(BertModel):
        self.gguf_writer.add_add_sep_token(True)
        self._set_vocab_gpt2()

-    def get_vocab_base(self) -> tuple[list[str], list[int], str]:
-        tokens, toktypes, tokpre = super().get_vocab_base()
-        if tokpre == "mmbert":
-            # the added tokens for runs of spaces are never matched by the reference tokenizer
-            space = b"\xe2\x96\x81".decode("utf-8")
-            for i, token in enumerate(tokens):
-                if toktypes[i] == gguf.TokenType.USER_DEFINED and token and not token.strip(" "):
-                    tokens[i] = space * len(token)
-                    toktypes[i] = gguf.TokenType.NORMAL
-        return tokens, toktypes, tokpre
-
    def set_gguf_parameters(self):
        super().set_gguf_parameters()
        self.gguf_writer.add_sliding_window(self.hparams["local_attention"])
@@ -650,98 +639,3 @@ class ModernBertModel(BertModel):
                name = "classifier.out_proj.bias"

        yield from super().modify_tensors(data_torch, name, bid)
-
-
-def _is_decision_checkpoint(dir_model: Path) -> bool:
-    if not (dir_model / "encoder" / "config.json").is_file():
-        return False
-    return (dir_model / "rl_agent_config.json").is_file() or (dir_model / "julia_config.json").is_file()
-
-
-@ModelBase.register_hparams_loader(_is_decision_checkpoint)
-def _load_decision_hparams(dir_model: Path) -> dict[str, Any]:
-    logger.info("gguf: detected ModernBert decision checkpoint")
-    hparams = ModelBase.load_hparams(dir_model / "encoder", False, guess=False)
-    is_julia = (dir_model / "julia_config.json").is_file()
-    with open(dir_model / ("julia_config.json" if is_julia else "rl_agent_config.json"), encoding="utf-8") as f:
-        decision = json.load(f)
-    n_layer = hparams["num_hidden_layers"]
-    n_layer_head = decision["head_layers"]
-    hparams["architectures"] = ["ModernBertDecisionModel"]
-    hparams["decision"] = decision
-    # the head blocks are appended to the encoder blocks, they use a plain 4x MLP
-    hparams["num_hidden_layers"] = n_layer + n_layer_head
-    hparams["intermediate_size"] = [hparams["intermediate_size"]] * n_layer + [4 * hparams["hidden_size"]] * n_layer_head
-    return hparams
-
-
-@ModelBase.register("ModernBertDecisionModel")
-@ModelBase.example("convaiinnovations/laya", "SupersonicLabs/Julia-1")
-class ModernBertDecisionModel(ModernBertModel):
-    model_arch = gguf.MODEL_ARCH.MODERN_BERT
-
-    def set_vocab(self):
-        # vocab loaders read self.dir_model, point it to the tokenizer sub-directory
-        dir_model = self.dir_model
-        self.dir_model = dir_model / "tokenizer"
-        try:
-            super().set_vocab()
-        finally:
-            self.dir_model = dir_model
-        self.gguf_writer.add_token_type_count(3)  # choice, score, noul
-        self.gguf_writer.add_chat_template([{"name": "systemone", "template": self._systemone_template()}])
-
-    def _systemone_template(self) -> str:
-        with open(self.dir_model / "tokenizer" / "tokenizer_config.json", encoding="utf-8") as f:
-            tokenizer_config = json.load(f)
-        tok_cls, tok_sep, tok_mask = (tokenizer_config[k] for k in ("cls_token", "sep_token", "mask_token"))
-        description = jinja_str_or_json("o.description")
-        if self.hparams["decision"].get("architecture") == "JuliaDecisionModel":
-            option = "{% if o.description %}" + description + "{% else %}{{ o.key }}{% endif %}"
-        else:
-            option = (
-                "{% if type == 'choice' %}{{ o.key }}{% if o.description %}: " + description + "{% endif %}"
-                "{% elif type == 'score' %}level {{ o.key }}: " + description
-                + "{% else %}{{ o.key }}: {% if o.description %}" + description
-                + "{% elif o.key == 'true' %}yes, the statement holds"
-                "{% else %}no, the statement does not hold{% endif %}{% endif %}"
-            )
-        return (
-            tok_cls + "{{ type }} question: " + jinja_str_or_json("instructions") + tok_sep
-            + "{% for o in options %}" + tok_mask + " " + option + "{% endfor %}"
-            + tok_sep + jinja_str_or_json("state") + tok_sep
-        )
-
-    def set_gguf_parameters(self):
-        super().set_gguf_parameters()
-        decision = self.hparams["decision"]
-        self.gguf_writer.add_decision_type(gguf.DecisionType.LAYA)
-        self.gguf_writer.add_decision_block_count(decision["head_layers"])
-        self.gguf_writer.add_decision_max_head_tokens(decision.get("head_max_len", 256))
-        for name, value in zip(("choice", "score", "noul"), decision.get("temperature", [])):
-            self.gguf_writer.add_decision_temperature(name, value)
-        # "choice:3-5" -> "choice.3_5", "choice:11+" -> "choice.11"
-        for name, value in decision.get("temperature_by_options", {}).items():
-            self.gguf_writer.add_decision_temperature(name.replace(":", ".").replace("-", "_").rstrip("+"), value)
-
-    @classmethod
-    def filter_tensors(cls, item: tuple[str, Callable[[], Tensor]]) -> tuple[str, Callable[[], Tensor]] | None:
-        name, gen = item
-
-        # act_head is not used for the answer, the fitted temperatures come from the config
-        if name.startswith("act_head.") or name == "temperature":
-            return None
-
-        if name.startswith("encoder."):
-            name = name[8:]
-
-        return super().filter_tensors((name, gen))
-
-    def modify_tensors(self, data_torch: Tensor, name: str, bid: int | None) -> Iterable[tuple[str, Tensor]]:
-        if name.startswith("head.layers.") and bid is not None:
-            # the head blocks come after the encoder blocks
-            suffix = name.split(".", 3)[3].replace("in_proj_", "in_proj.")
-            bid += self.block_count - self.hparams["decision"]["head_layers"]
-            name = f"head.layers.{bid}.{suffix}"
-
-        yield from super().modify_tensors(data_torch, name, bid)
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Alde Rojas	3a3f76f2e8	cont : rename common_schema to common_chat_schema	2026-09-12 13:23:12 -05:00
Alde Rojas	a1e2fc9e8b	cont : restore (min\|max)Length to imply string type	2026-09-12 13:23:12 -05:00
Alde Rojas	2372064fea	cont : make "{}" mean any object for json_object as well	2026-09-12 13:23:12 -05:00
Alde Rojas	cc420dafab	cont : update docs	2026-09-12 13:23:12 -05:00
Alde Rojas	55d9cf0722	cont : remove dead code	2026-09-12 13:23:12 -05:00
Alde Rojas	c8c25a0022	cont : add tests for empty $ref	2026-09-12 13:23:12 -05:00
Alde Rojas	f0fd3a81c0	cont : properly handle empty tool parameters	2026-09-12 13:23:12 -05:00
Alde Rojas	50d886a8a5	cont : fix may_be_string	2026-09-12 13:23:12 -05:00
Alde Rojas	aca246997a	refactor : rename common_schema_builder parse_* methods to build_*	2026-09-12 13:23:12 -05:00
Alde Rojas	7e0f376cf3	tests : take the schema label as const char * to satisfy gcc dangling-reference	2026-09-12 13:23:11 -05:00
Alde Rojas	bdc3a47794	tests : fix gcc dangling-reference warning in test-json-schema	2026-09-12 13:23:11 -05:00
Alde Rojas	301b0eb5f3	refactor : rename common_schema_parse to common_schema_from_json	2026-09-12 13:23:11 -05:00
Alde Rojas	5abafdeff4	cont : clean up	2026-09-12 13:23:11 -05:00
Alde Rojas	c3f104c68a	cont : clean up	2026-09-12 13:23:11 -05:00
Alde Rojas	1dbf3eef57	cont : reduce test cases	2026-09-12 13:23:11 -05:00
Alde Rojas	797b72981f	cont : move enums under common_schema and add type enum	2026-09-12 13:23:11 -05:00
Alde Rojas	e0fc22575d	cont : cleanup	2026-09-12 13:23:11 -05:00
Alde Rojas	78b4c52c06	cont : pass common_schema through the json-schema-to-grammar builder	2026-09-12 13:23:11 -05:00
Alde Rojas	a838fb4d6d	cont : simplify schema resolution	2026-09-12 13:23:11 -05:00
Alde Rojas	a4d976df93	cont : remove common_chat_tool_parameters	2026-09-12 13:23:11 -05:00
Alde Rojas	5204e2104a	cont : cleanup	2026-09-12 13:23:11 -05:00
Alde Rojas	426d070db0	common/schema : implement type/kind resolution	2026-09-12 13:23:11 -05:00
Alde Rojas	9e63e52cfc	common : use common_trie	2026-09-12 13:23:10 -05:00
Alde Rojas	4882c77330	common : refactor json-schema-to-grammar to use common_schema	2026-09-12 13:23:10 -05:00
Alde Rojas	4935133ab8	common : reduce optimizations	2026-09-12 13:23:10 -05:00
Alde Rojas	5088b6d623	common : implement a json schema optimizer	2026-09-12 13:23:10 -05:00
Alde Rojas	8ff43c23e0	common : implement common_schema types	2026-09-12 13:23:10 -05:00