Support sycl backend for Intel GPU

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,26 @@
+---
+name: Bug report
+about: Something built or ran, and did the wrong thing
+labels: bug
+---
+
+**What happened**
+
+**Expected**
+
+**Repro**
+
+```
+# command, including the model and backend
+```
+
+**Environment**
+- vla.cpp commit:
+- Backend: CPU / CUDA / Metal / SYCL
+- OS and compiler:
+- GPU and driver (if relevant):
+- Model and checkpoint:
+
+**Output**
+
+Paste the shortest decisive part of the log, not the whole run.

.github/ISSUE_TEMPLATE/model_request.md

@@ -0,0 +1,20 @@
+---
+name: Architecture request
+about: Ask for a VLA policy that vla.cpp does not run yet
+labels: enhancement
+---
+
+**Policy**
+
+Name, paper or repo link, and the reference implementation.
+
+**Checkpoint**
+
+Where the weights live and under what license.
+
+**Why it is worth adding**
+
+Benchmark numbers, or what it does that the supported archs do not.
+
+CONTRIBUTING.md has the six-site walkthrough if you want to send the port
+yourself.

.github/pull_request_template.md

@@ -0,0 +1,12 @@
+## What
+
+## Why
+
+## Verified
+
+- [ ] Builds clean under `-Wall -Wextra` (first-party code)
+- [ ] `ctest` passes
+- [ ] Numeric output unchanged (`vla_predict_check` diff), or the change is
+      meant to move it and a LIBERO sweep is below
+
+Archs and backends tested:

.github/workflows/build.yml

@@ -17,10 +17,14 @@ jobs:
     runs-on: ubuntu-24.04
     steps:
       - uses: actions/checkout@v4
-      - name: pixel-shuffle channel order
+      # Compiled directly: pure, no llama.cpp or protobuf/zmq needed.
+      - name: pure unit tests
         run: |
-          g++ -std=c++17 -Isrc -Wall -Wextra tests/test_vision_common.cpp -o /tmp/test_vision_common
-          /tmp/test_vision_common
+          for t in test_vision_common test_rope_conventions test_config_guard; do
+            g++ -std=c++17 -Isrc -Wall -Wextra -fsanitize=address,undefined \
+                -fno-omit-frame-pointer "tests/$t.cpp" -o "/tmp/$t"
+            "/tmp/$t"
+          done
 
   py-tooling:
     runs-on: ubuntu-24.04
@@ -31,6 +35,8 @@ jobs:
           python-version: '3.11'
       - name: converter remap
         run: python tests/py/test_converters.py
+      - name: binding struct parity
+        run: python tests/py/test_bindings.py
 
   build-gate:
     runs-on: ubuntu-24.04
@@ -45,8 +51,13 @@ jobs:
       - uses: actions/cache@v4
         with:
           path: build/_deps
-          key: llama-b9866-${{ runner.os }}
+          key: llama-b10326-${{ runner.os }}
       - name: build vla-server + vlm-server + vla-cli (CPU, -Wall -Wextra)
         run: |
-          cmake -B build -DCMAKE_BUILD_TYPE=Release -DGGML_CUDA=OFF
+          cmake -B build -DCMAKE_BUILD_TYPE=Release -DGGML_CUDA=OFF -DVLA_BUILD_TESTS=ON
           cmake --build build -j"$(nproc)" --target vla-server vlm-server vla-cli
+      # Not in cpp-unit: these need ggml headers, so llama.cpp must be fetched.
+      - name: ctest
+        run: |
+          cmake --build build -j"$(nproc)" --target test_dit_common test_qwen3vl_vit
+          ctest --test-dir build --output-on-failure

.github/workflows/release.yml

@@ -0,0 +1,132 @@
+# Tagged binaries and a container image. build.yml already compiles all of this
+# on every push; this is the same work with the artifacts kept.
+name: release
+
+on:
+  push:
+    tags: ['v*']
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: Tag to build (dry run, nothing is published)
+        required: true
+
+permissions:
+  contents: write
+  packages: write
+
+env:
+  BINARIES: vla-server vlm-server vla-cli vla-bench
+
+jobs:
+  linux:
+    runs-on: ubuntu-24.04
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - name: linux-x86_64-cpu
+            cmake: -DGGML_CUDA=OFF
+            cuda: false
+          - name: linux-x86_64-cuda
+            cmake: -DGGML_CUDA=ON -DCMAKE_CUDA_ARCHITECTURES=75;86;89;120
+            cuda: true
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: deps
+        run: |
+          sudo apt-get update -qq
+          sudo apt-get install -y -qq --no-install-recommends \
+            build-essential cmake git ca-certificates pkg-config \
+            libzmq3-dev cppzmq-dev libprotobuf-dev protobuf-compiler
+
+      - name: cuda toolkit
+        if: matrix.cuda
+        run: |
+          wget -q https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2404/x86_64/cuda-keyring_1.1-1_all.deb
+          sudo dpkg -i cuda-keyring_1.1-1_all.deb
+          sudo apt-get update -qq
+          sudo apt-get install -y -qq --no-install-recommends cuda-toolkit-12-6
+          echo "/usr/local/cuda/bin" >> "$GITHUB_PATH"
+
+      - name: build
+        run: |
+          cmake -B build -DCMAKE_BUILD_TYPE=Release ${{ matrix.cmake }}
+          cmake --build build -j"$(nproc)" --target $BINARIES vla
+
+      - name: package
+        run: |
+          out="vla.cpp-${{ github.ref_name }}-${{ matrix.name }}"
+          mkdir -p "$out"
+          for b in $BINARIES; do cp "build/$b" "$out/"; done
+          cp build/libvla.so "$out/"
+          cp include/vla.h LICENSE.md README.md "$out/"
+          tar -czf "$out.tar.gz" "$out"
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: ${{ matrix.name }}
+          path: '*.tar.gz'
+
+  macos:
+    runs-on: macos-14
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: deps
+        run: brew install cmake zeromq cppzmq protobuf
+
+      - name: build
+        run: |
+          cmake -B build -DCMAKE_BUILD_TYPE=Release -DGGML_METAL=ON
+          cmake --build build -j"$(sysctl -n hw.ncpu)" --target $BINARIES vla
+
+      - name: package
+        run: |
+          out="vla.cpp-${{ github.ref_name }}-macos-arm64-metal"
+          mkdir -p "$out"
+          for b in $BINARIES; do cp "build/$b" "$out/"; done
+          cp build/libvla.dylib "$out/"
+          cp include/vla.h LICENSE.md README.md "$out/"
+          # Metal needs the shader library next to the binary.
+          find build -name 'default.metallib' -exec cp {} "$out/" \;
+          tar -czf "$out.tar.gz" "$out"
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: macos-arm64-metal
+          path: '*.tar.gz'
+
+  docker:
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v4
+      - uses: docker/setup-buildx-action@v3
+      - uses: docker/login-action@v3
+        if: startsWith(github.ref, 'refs/tags/')
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      - uses: docker/build-push-action@v6
+        with:
+          context: .
+          push: ${{ startsWith(github.ref, 'refs/tags/') }}
+          tags: |
+            ghcr.io/${{ github.repository }}:${{ github.ref_name }}
+            ghcr.io/${{ github.repository }}:latest
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
+
+  publish:
+    needs: [linux, macos, docker]
+    if: startsWith(github.ref, 'refs/tags/')
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/download-artifact@v4
+        with: { path: dist, merge-multiple: true }
+      - uses: softprops/action-gh-release@v2
+        with:
+          files: dist/*.tar.gz
+          generate_release_notes: true

CMakeLists.txt

@@ -11,6 +11,22 @@ if(NOT CMAKE_BUILD_TYPE)
     set(CMAKE_BUILD_TYPE Release CACHE STRING "" FORCE)
 endif()
 
+# src/backend.h compiles in exactly one accelerator, so two GGML_* flags would
+# give ggml both backends and vla_core only one. Reject before FetchContent.
+set(_vla_accel "")
+foreach(_flag GGML_CUDA GGML_SYCL GGML_METAL)
+    if(${_flag})
+        list(APPEND _vla_accel ${_flag})
+    endif()
+endforeach()
+list(LENGTH _vla_accel _vla_accel_n)
+if(_vla_accel_n GREATER 1)
+    string(REPLACE ";" ", " _vla_accel_str "${_vla_accel}")
+    message(FATAL_ERROR
+        "Enable one accelerator backend at a time; got ${_vla_accel_str}. "
+        "Configure a separate build directory per backend.")
+endif()
+
 set(LLAMA_BUILD_COMMON   ON  CACHE BOOL "" FORCE)
 set(LLAMA_BUILD_TOOLS    ON  CACHE BOOL "" FORCE)
 set(LLAMA_BUILD_SERVER   OFF CACHE BOOL "" FORCE)
@@ -20,7 +36,7 @@ set(LLAMA_BUILD_TESTS    OFF CACHE BOOL "" FORCE)
 include(FetchContent)
 FetchContent_Declare(llama
     GIT_REPOSITORY https://github.com/ggml-org/llama.cpp
-    GIT_TAG        b9866
+    GIT_TAG        b10326
     GIT_SHALLOW    TRUE
 )
 FetchContent_MakeAvailable(llama)
@@ -88,7 +104,23 @@ if(GGML_CUDA)
     target_include_directories(vla_core PUBLIC ${CUDAToolkit_INCLUDE_DIRS})
 endif()
 
-if(GGML_METAL AND NOT GGML_CUDA)
+# Intel GPUs (Arc / Flex / Data Center Max / Xe iGPU) through oneAPI SYCL.
+# ggml's SYCL sources only compile under the oneAPI DPC++ driver, and
+# CMAKE_CXX_COMPILER is global, so our targets are built by icpx too. Fail
+# loudly here rather than let ggml die deep in a kernel compile.
+if(GGML_SYCL AND NOT GGML_CUDA)
+    if(NOT CMAKE_CXX_COMPILER_ID STREQUAL "IntelLLVM")
+        message(FATAL_ERROR
+            "GGML_SYCL=ON needs the oneAPI DPC++ compiler, but CMAKE_CXX_COMPILER is "
+            "'${CMAKE_CXX_COMPILER_ID}'. Source /opt/intel/oneapi/setvars.sh and configure a "
+            "fresh build dir with -DCMAKE_C_COMPILER=icx -DCMAKE_CXX_COMPILER=icpx. "
+            "See docs/backend/sycl.md.")
+    endif()
+    target_compile_definitions(vla_core PUBLIC GGML_USE_SYCL)
+endif()
+
+# Backend precedence matches the ladder in src/backend.h: CUDA, then SYCL, then Metal.
+if(GGML_METAL AND NOT GGML_CUDA AND NOT GGML_SYCL)
     target_compile_definitions(vla_core PUBLIC GGML_USE_METAL)
 endif()
 
@@ -169,6 +201,7 @@ add_executable(vlm-server
 )
 target_include_directories(vlm-server PRIVATE
     ${CMAKE_CURRENT_BINARY_DIR}/proto-gen
+    ${llama_SOURCE_DIR}/vendor/stb
     ${CPPZMQ_INCLUDE_DIR}
 )
 target_link_libraries(vlm-server PRIVATE
@@ -177,6 +210,20 @@ target_link_libraries(vlm-server PRIVATE
     PkgConfig::ZeroMQ
 )
 
+# Stable C ABI. Shared so bindings can dlopen it; visibility hidden so only the
+# vla_* symbols are exported and llama/ggml stay internal.
+add_library(vla SHARED src/vla_c_api.cpp)
+target_include_directories(vla
+    PUBLIC  ${CMAKE_CURRENT_SOURCE_DIR}/include
+    PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src
+)
+target_link_libraries(vla PRIVATE vla_core)
+set_target_properties(vla PROPERTIES
+    CXX_VISIBILITY_PRESET hidden
+    VISIBILITY_INLINES_HIDDEN ON
+    PUBLIC_HEADER ${CMAKE_CURRENT_SOURCE_DIR}/include/vla.h
+)
+
 # One-shot inference CLI: image + tokens -> action, no server or simulator.
 add_executable(vla-cli
     src/serving/vla-cli.cpp
@@ -186,8 +233,14 @@ target_include_directories(vla-cli PRIVATE
 )
 target_link_libraries(vla-cli PRIVATE vla_core)
 
+# Latency for one checkpoint, emits the README table rows.
+add_executable(vla-bench
+    src/serving/vla-bench.cpp
+)
+target_link_libraries(vla-bench PRIVATE vla_core)
+
 # --- First-party build hygiene (never applied to the vendored llama.cpp subtree) --
-set(VLA_FIRST_PARTY_TARGETS vla_core vlm_core vla-server vlm-server vla-cli)
+set(VLA_FIRST_PARTY_TARGETS vla_core vlm_core vla vla-server vlm-server vla-cli vla-bench)
 
 foreach(tgt IN LISTS VLA_FIRST_PARTY_TARGETS)
     # Warn on our own C++ only; nvcc device code keeps its own diagnostics.