Merge branch 'master' into egpu-alert

[MICI] ui: move and restyle the sunnylink pill in settings (#1972 )
models: Model Selector upgrades (#1953 )
2026-08-30 13:13:47 +08:00 · 2026-08-27 11:01:29 -04:00 · 2026-08-27 03:52:57 -04:00 · 2026-08-27 02:03:53 -04:00 · 2026-08-26 02:34:02 -04:00 · 2026-08-25 21:07:44 -04:00
103 changed files with 3646 additions and 1746 deletions
@@ -7,6 +7,19 @@ on:
        description: 'Minimum selector version required for the models (see helpers.py or readme.md)'
        required: true
        type: string
+      target_hardware:
+        description: 'Hardware target to compile for (qcom or usbgpu)'
+        required: true
+        type: choice
+        default: 'qcom'
+        options:
+          - qcom
+          - usbgpu
+      hf_repo:
+        description: 'Hugging Face dataset repository'
+        required: false
+        type: string
+        default: 'sunnypilot/sunnypilot_models_v1'

 jobs:
  setup:
@@ -46,13 +59,14 @@ jobs:
        id: get-json
        run: |
          cd docs/docs
-          latest=$(ls driving_models_v*.json | sed -E 's/.*_v([0-9]+)\.json/\1/' | sort -n | tail -1)
+          PREFIX="driving_models_${{ inputs.target_hardware == 'usbgpu' && 'usbgpu_' || '' }}v"
+          latest=$(ls ${PREFIX}*.json | sed -E "s/${PREFIX}([0-9]+)\.json/\1/" | sort -n | tail -1)
          next=$((latest+1))
-          json_file="driving_models_v${next}.json"
-          cp "driving_models_v${latest}.json" "$json_file"
+          json_file="${PREFIX}${next}.json"
+          cp "${PREFIX}${latest}.json" "$json_file"
          echo "json_file=docs/docs/$json_file" >> $GITHUB_OUTPUT
          echo "json_version=$((next+0))" >> $GITHUB_OUTPUT
-          echo "SRC_JSON_FILE=docs/docs/driving_models_v${latest}.json" >> $GITHUB_ENV
+          echo "SRC_JSON_FILE=docs/docs/${PREFIX}${latest}.json" >> $GITHUB_ENV

      - name: Extract tinygrad models
        id: set-matrix
@@ -61,45 +75,23 @@ jobs:
          jq -c '[.bundles[] | select(.runner=="tinygrad") | {ref, display_name: (.display_name | gsub(" \\([^)]*\\)"; "")), is_20hz}]' "$(basename "${SRC_JSON_FILE}")" > matrix.json
          echo "model_matrix=$(cat matrix.json)" >> $GITHUB_OUTPUT

-      - name: Set up SSH
-        uses: webfactory/ssh-agent@v0.9.0
-        with:
-          ssh-private-key: ${{ secrets.GITLAB_SSH_PRIVATE_KEY }}
-      - run: |
-          mkdir -p ~/.ssh
-          ssh-keyscan -H gitlab.com >> ~/.ssh/known_hosts
-
-      - name: Clone GitLab docs repo and create new recompiled dir
+      - name: Get next recompiled dir number
        id: create-recompiled-dir
        env:
-          GIT_SSH_COMMAND: 'ssh -o UserKnownHostsFile=~/.ssh/known_hosts'
+          HF_REPO: ${{ github.event.inputs.hf_repo }}
        run: |
-          git clone --depth 1 --filter=tree:0 --sparse git@gitlab.com:sunnypilot/public/${{ vars.MODELS_GITLAB }} gitlab_docs
-          cd gitlab_docs
-          git checkout main
-          git sparse-checkout set --no-cone models/
-          cd models
-          latest_dir=$(ls -d recompiled* 2>/dev/null | sed -E 's/recompiled([0-9]+)/\1/' | sort -n | tail -1)
-          if [[ -z "$latest_dir" ]]; then
-            next_dir=1
-          else
-            next_dir=$((latest_dir+1))
-          fi
-          recompiled_dir="${next_dir}"
-          mkdir -p "recompiled${recompiled_dir}"
-          touch "recompiled${recompiled_dir}/.gitkeep"
-          cd ../..
+          pip install huggingface_hub
+          recompiled_dir=$(python3 -c "
+          from huggingface_hub import HfApi
+          import re, sys
+          api = HfApi()
+          files = api.list_repo_files(repo_id=sys.argv[1], repo_type='dataset')
+          dirs = [re.search(r'models/recompiled([0-9]+)', f) for f in files]
+          nums = [int(m.group(1)) for m in dirs if m]
+          print(max(nums) + 1)
+          " "$HF_REPO")
          echo "recompiled_dir=$recompiled_dir" >> $GITHUB_OUTPUT

-      - name: Push empty recompiled dir to GitLab
-        run: |
-          cd gitlab_docs
-          git add models/recompiled${{ steps.create-recompiled-dir.outputs.recompiled_dir }}
-          git config --global user.name "GitHub Action"
-          git config --global user.email "action@github.com"
-          git commit -m "Add recompiled${{ steps.create-recompiled-dir.outputs.recompiled_dir }} for build-all" || echo "No changes to commit"
-          git push origin main
-
      - name: Push new JSON to GitHub docs repo
        run: |
          cd docs
@@ -123,25 +115,30 @@ jobs:
      is_20hz: ${{ matrix.model.is_20hz }}
      recompiled_dir: ${{ needs.setup.outputs.recompiled_dir }}
      json_version: ${{ needs.setup.outputs.json_version }}
+      target_hardware: ${{ github.event.inputs.target_hardware }}
+      hf_repo: ${{ github.event.inputs.hf_repo }}
+      set_min_version: ${{ github.event.inputs.set_min_version }}
+      tinygrad_ref: ${{ needs.setup.outputs.tinygrad_ref }}
    secrets: inherit

  retry_failed_models:
    needs: [setup, get_and_build]
    runs-on: ubuntu-latest
-    if: ${{ needs.setup.result != 'failure' && !cancelled() }}
+    if: ${{ !cancelled() && needs.setup.result == 'success' && (needs.get_and_build.result == 'success' || needs.get_and_build.result == 'failure') }}
    outputs:
      retry_matrix: ${{ steps.set-retry-matrix.outputs.retry_matrix }}
    steps:
      - uses: actions/download-artifact@v4
        with:
-          pattern: model-*
+          pattern: artifact-name-*
          path: output
+        continue-on-error: true

      - id: set-retry-matrix
        run: |
          echo '${{ needs.setup.outputs.model_matrix }}' > matrix.json
-          built=(); while IFS= read -r line; do built+=("$line"); done < <(
-            find output -maxdepth 1 -name 'model-*' -printf "%f\n" | sed -E 's/^model-//' | sed -E 's/-[0-9]+$//' | sed -E 's/ \([^)]*\)//' | awk '{gsub(/^ +| +$/, ""); print}'
+          built=(); while IFS= read -r line; do [ -n "$line" ] && built+=("$line"); done < <(
+            find output -maxdepth 1 -name 'artifact-name-*' -printf "%f\n" 2>/dev/null | sed -E 's/^artifact-name-//' | awk '{gsub(/^ +| +$/, ""); print}'
          )
          jq -c --argjson built "$(printf '%s\n' "${built[@]}" | jq -R . | jq -s .)" \
            'map(select(.display_name as $n | ($built | index($n | gsub("^ +| +$"; "")) | not)))' matrix.json > retry_matrix.json
@@ -149,7 +146,7 @@ jobs:

  retry_get_and_build:
    needs: [setup, get_and_build, retry_failed_models]
-    if: ${{ needs.get_and_build.result == 'failure' || (needs.retry_failed_models.outputs.retry_matrix != '[]' && needs.retry_failed_models.outputs.retry_matrix != '') }}
+    if: ${{ !cancelled() && needs.retry_failed_models.result == 'success' && needs.retry_failed_models.outputs.retry_matrix != '[]' && needs.retry_failed_models.outputs.retry_matrix != '' }}
    strategy:
      matrix:
        model: ${{ fromJson(needs.retry_failed_models.outputs.retry_matrix) }}
@@ -161,146 +158,9 @@ jobs:
      is_20hz: ${{ matrix.model.is_20hz }}
      recompiled_dir: ${{ needs.setup.outputs.recompiled_dir }}
      json_version: ${{ needs.setup.outputs.json_version }}
+      target_hardware: ${{ github.event.inputs.target_hardware }}
      artifact_suffix: -retry
+      hf_repo: ${{ github.event.inputs.hf_repo }}
+      set_min_version: ${{ github.event.inputs.set_min_version }}
+      tinygrad_ref: ${{ needs.setup.outputs.tinygrad_ref }}
    secrets: inherit
-
-  publish_models:
-    name: Publish models sequentially
-    needs: [setup, get_and_build, retry_failed_models, retry_get_and_build]
-    if: ${{ !cancelled() && (needs.get_and_build.result != 'failure' || needs.retry_get_and_build.result == 'success' || (needs.retry_failed_models.outputs.retry_matrix != '[]' && needs.retry_failed_models.outputs.retry_matrix != '')) }}
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      max-parallel: 1
-      matrix:
-        model: ${{ fromJson(needs.setup.outputs.model_matrix) }}
-    env:
-      RECOMPILED_DIR: recompiled${{ needs.setup.outputs.recompiled_dir }}
-      JSON_FILE: ${{ needs.setup.outputs.json_file }}
-      ARTIFACT_NAME_INPUT: ${{ matrix.model.display_name }}
-    steps:
-      - name: Set up SSH
-        uses: webfactory/ssh-agent@v0.9.0
-        with:
-          ssh-private-key: ${{ secrets.GITLAB_SSH_PRIVATE_KEY }}
-
-      - name: Add GitLab.com SSH key to known_hosts
-        run: |
-          mkdir -p ~/.ssh
-          ssh-keyscan -H gitlab.com >> ~/.ssh/known_hosts
-
-      - name: Clone GitLab docs repo
-        env:
-          GIT_SSH_COMMAND: 'ssh -o UserKnownHostsFile=~/.ssh/known_hosts'
-        run: |
-          echo "Cloning GitLab"
-          git clone --depth 1 --filter=tree:0 --sparse git@gitlab.com:sunnypilot/public/${{ vars.MODELS_GITLAB }} gitlab_docs
-          cd gitlab_docs
-          echo "checkout models/${RECOMPILED_DIR}"
-          git sparse-checkout set --no-cone models/${RECOMPILED_DIR}
-          git checkout main
-          cd ..
-
-      - name: Checkout docs repo
-        uses: actions/checkout@v4
-        with:
-          repository: sunnypilot/sunnypilot-models
-          ref: gh-pages
-          path: docs
-          ssh-key: ${{ secrets.CI_SUNNYPILOT_DOCS_PRIVATE_KEY }}
-
-      - name: Validate recompiled dir and JSON version
-        run: |
-          if [ ! -d "gitlab_docs/models/$RECOMPILED_DIR" ]; then
-            echo "Recompiled dir $RECOMPILED_DIR does not exist in GitLab repo"
-            exit 1
-          fi
-          if [ ! -f "$JSON_FILE" ]; then
-            echo "JSON file $JSON_FILE does not exist!"
-            exit 1
-          fi
-
-      - name: Download artifact name file
-        uses: actions/download-artifact@v4
-        with:
-          name: artifact-name-${{ env.ARTIFACT_NAME_INPUT }}
-          path: artifact_name
-
-      - name: Read artifact name
-        id: read-artifact-name
-        run: |
-          ARTIFACT_NAME=$(cat artifact_name/artifact_name.txt)
-          echo "artifact_name=$ARTIFACT_NAME" >> $GITHUB_OUTPUT
-
-      - name: Download model artifact
-        uses: actions/download-artifact@v4
-        with:
-          name: ${{ steps.read-artifact-name.outputs.artifact_name }}
-          path: output
-
-      - name: Remove onnx files bc not needed for recompiled dir since they already exist from single build
-        run: |
-          find output -type f -name '*.onnx' -delete
-          find output -type f -name 'big_*.pkl' -delete
-          find output -type f -name 'dmonitoring_model_tinygrad.pkl' -delete
-
-      - name: Copy model artifacts to gitlab
-        env:
-          ARTIFACT_NAME: ${{ steps.read-artifact-name.outputs.artifact_name }}
-        run: |
-          ARTIFACT_DIR="gitlab_docs/models/${RECOMPILED_DIR}/${ARTIFACT_NAME}"
-          mkdir -p "$ARTIFACT_DIR"
-          for path in output/*; do
-            if [ "$(basename "$path")" = "artifact_name.txt" ]; then
-              continue
-            fi
-            name="$(basename "$path")"
-            if [ -d "$path" ]; then
-              mkdir -p "$ARTIFACT_DIR/$name"
-              cp -r "$path"/* "$ARTIFACT_DIR/$name/"
-              echo "Copied dir $name -> $ARTIFACT_DIR/$name"
-            else
-              cp "$path" "$ARTIFACT_DIR/"
-              echo "Copied file $name -> $ARTIFACT_DIR/"
-            fi
-          done
-
-      - name: Push recompiled dir to GitLab
-        env:
-          GITLAB_SSH_PRIVATE_KEY: ${{ secrets.GITLAB_SSH_PRIVATE_KEY }}
-        run: |
-          cd gitlab_docs
-          git checkout main
-          git pull origin main
-          for d in models/"$RECOMPILED_DIR"/*/; do
-            git sparse-checkout add "$d"
-          done
-          git add models/"$RECOMPILED_DIR"
-          git config --global user.name "GitHub Action"
-          git config --global user.email "action@github.com"
-          git commit -m "Update $RECOMPILED_DIR with model from build-all-tinygrad-models" || echo "No changes to commit"
-          git push origin main
-      - run: |
-          cd docs
-          git pull origin gh-pages
-
-      - name: update json
-        run: |
-          ARGS=""
-          [ -n "${{ inputs.set_min_version }}" ] && ARGS="$ARGS --set-min-version \"${{ inputs.set_min_version }}\""
-          ARGS="$ARGS --sort-by-date"
-          ARGS="$ARGS --tinygrad-ref \"${{ needs.setup.outputs.tinygrad_ref }}\""
-          eval python3 docs/json_parser.py \
-            --json-path "$JSON_FILE" \
-            --recompiled-dir "gitlab_docs/models/$RECOMPILED_DIR" \
-            $ARGS
-
-      - name: Push updated json to GitHub
-        run: |
-          cd docs
-          git config --global user.name "GitHub Action"
-          git config --global user.email "action@github.com"
-          git checkout gh-pages
-          git add docs/"$(basename $JSON_FILE)"
-          git commit -m "Update $(basename $JSON_FILE) after recompiling model" || echo "No changes to commit"
-          git push origin gh-pages
@@ -0,0 +1,501 @@
+name: Build default models
+
+on:
+  workflow_dispatch:
+    inputs:
+      target:
+        description: 'Model target to build'
+        required: true
+        type: choice
+        options:
+          - small
+          - big
+          - dm
+  workflow_call:
+    inputs:
+      target:
+        description: 'Model target to build (small, big, or dm)'
+        required: true
+        type: string
+
+concurrency:
+  group: build-default-models-${{ inputs.target }}
+  cancel-in-progress: false
+
+env:
+  HF_REPO: sunnypilot/sunnypilot_models_v1
+
+jobs:
+  resolve:
+    runs-on: ubuntu-24.04
+    outputs:
+      model_name: ${{ steps.resolve.outputs.model_name }}
+      onnx_ref: ${{ steps.resolve.outputs.onnx_ref }}
+      onnx_path: ${{ steps.resolve.outputs.onnx_path }}
+      hf_defaults_path: ${{ steps.resolve.outputs.hf_defaults_path }}
+      tinygrad_ref: ${{ steps.resolve.outputs.tinygrad_ref }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - id: resolve
+        run: |
+          export PYTHONPATH=${{ github.workspace }}
+
+          if [ "${{ inputs.target }}" = "big" ]; then
+            NAME=$(python3 -c "from openpilot.sunnypilot.models.model_name import DEFAULT_BIG_MODEL; print(DEFAULT_BIG_MODEL)")
+            ONNX_PATH="openpilot/selfdrive/modeld/models/big_driving_supercombo.onnx"
+            HF_DEFAULTS_PATH="models/defaults/big"
+          elif [ "${{ inputs.target }}" = "dm" ]; then
+            ONNX_PATH="openpilot/selfdrive/modeld/models/dmonitoring_model.onnx"
+            HF_DEFAULTS_PATH="models/defaults/dm"
+            NAME="dmonitoring_model ($(git log -1 --format=%cd --date=format:'%B %d, %Y' -- "$ONNX_PATH"))"
+          else
+            NAME=$(python3 -c "from openpilot.sunnypilot.models.model_name import DEFAULT_MODEL; print(DEFAULT_MODEL)")
+            ONNX_PATH="openpilot/selfdrive/modeld/models/driving_supercombo.onnx"
+            HF_DEFAULTS_PATH="models/defaults/small"
+          fi
+
+          ONNX_REF=$(git log -1 --format='%H' -- "$ONNX_PATH")
+          TINYGRAD_REF=$(python3 openpilot/sunnypilot/models/tinygrad_ref.py)
+          if [ -z "$TINYGRAD_REF" ]; then
+            echo "::error::Failed to resolve tinygrad ref"
+            exit 1
+          fi
+
+          echo "model_name=${NAME}" >> $GITHUB_OUTPUT
+          echo "onnx_ref=${ONNX_REF}" >> $GITHUB_OUTPUT
+          echo "onnx_path=${ONNX_PATH}" >> $GITHUB_OUTPUT
+          echo "hf_defaults_path=${HF_DEFAULTS_PATH}" >> $GITHUB_OUTPUT
+          echo "tinygrad_ref=${TINYGRAD_REF}" >> $GITHUB_OUTPUT
+
+  build_small_model:
+    needs: resolve
+    if: ${{ inputs.target == 'small' }}
+    runs-on: [self-hosted, tici]
+    env:
+      SMALL_ONNX: openpilot/selfdrive/modeld/models/driving_supercombo.onnx
+      SMALL_PKL: openpilot/selfdrive/modeld/models/driving_tinygrad.pkl
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Pull ONNX via LFS
+        run: git lfs pull -I "${{ env.SMALL_ONNX }}"
+
+      - name: Set environment variables
+        run: |
+          source /etc/profile
+          export UV_PROJECT_ENVIRONMENT=${HOME}/venv
+          export UV_PYTHON_PREFERENCE=managed
+          export UV_PYTHON_INSTALL_DIR=${HOME}/uv/python
+          export VIRTUAL_ENV=$UV_PROJECT_ENVIRONMENT
+          uv sync --frozen
+          printenv >> $GITHUB_ENV
+
+      - name: Disable powersave
+        run: |
+          source ${UV_PROJECT_ENVIRONMENT}/bin/activate
+          PYTHONPATH=$PYTHONPATH:${{ github.workspace }}/ ${{ github.workspace }}/scripts/manage-powersave.py --disable
+
+      - name: Compile small model with stock compiler
+        run: |
+          source ${UV_PROJECT_ENVIRONMENT}/bin/activate
+          export PYTHONPATH="${PYTHONPATH}:${{ github.workspace }}/tinygrad_repo:${{ github.workspace }}"
+
+          MODEL_SIZE=$(python3 -c "from openpilot.common.transformations.model import MEDMODEL_INPUT_SIZE as s; print(f'{s[0]}x{s[1]}')")
+          CAMERA_RES=$(python3 -c "from openpilot.common.transformations.camera import _ar_ox_fisheye as a, _os_fisheye as o; print(f'{a.width}x{a.height} {o.width}x{o.height}')")
+          FRAME_SKIP=$(python3 -c "from openpilot.selfdrive.modeld.constants import ModelConstants as MC; print(MC.MODEL_RUN_FREQ // MC.MODEL_CONTEXT_FREQ)")
+
+          TG_FLAGS="DEV=QCOM IMAGE=1 FLOAT16=1 NOLOCALS=1 JIT_BATCH_SIZE=0 OPENPILOT_HACKS=1"
+
+          env ${TG_FLAGS} python3 \
+            ${{ github.workspace }}/openpilot/selfdrive/modeld/compile_modeld.py \
+            --onnx ${{ github.workspace }}/${{ env.SMALL_ONNX }} \
+            --model-size $MODEL_SIZE \
+            --camera-resolutions $CAMERA_RES \
+            --frame-skip $FRAME_SKIP \
+            --output ${{ github.workspace }}/${{ env.SMALL_PKL }}
+
+      - name: Chunk small pkl
+        run: |
+          source ${UV_PROJECT_ENVIRONMENT}/bin/activate
+          export PYTHONPATH=${{ github.workspace }}
+          python3 -c "
+          from openpilot.common.file_chunker import chunk_file, get_chunk_targets
+          import os
+          pkl = '${{ github.workspace }}/${{ env.SMALL_PKL }}'
+          size = os.path.getsize(pkl)
+          targets = get_chunk_targets(pkl, size)
+          chunk_file(pkl, targets)
+          print(f'Chunked into {len(targets)} files')
+          "
+
+      - name: Prepare output
+        env:
+          MODEL_NAME: ${{ needs.resolve.outputs.model_name }}
+        run: |
+          source ${UV_PROJECT_ENVIRONMENT}/bin/activate
+          export PYTHONPATH=${{ github.workspace }}
+          MODELS_DIR="${{ github.workspace }}/openpilot/selfdrive/modeld/models"
+          OUTPUT_DIR="${{ github.workspace }}/small_output"
+          PKL_BASE="driving_tinygrad.pkl"
+          mkdir -p "$OUTPUT_DIR"
+
+          cp "$MODELS_DIR/${PKL_BASE}".chunk* "$OUTPUT_DIR/"
+          cp "$MODELS_DIR/${PKL_BASE}.chunkmanifest" "$OUTPUT_DIR/"
+
+          python3 "${{ github.workspace }}/release/ci/model_generator.py" \
+            --model-dir "$MODELS_DIR" \
+            --output-dir "$OUTPUT_DIR" \
+            --custom-name "$MODEL_NAME" \
+            --upstream-branch "${{ needs.resolve.outputs.onnx_ref }}"
+
+          echo "model-${MODEL_NAME}-${{ github.run_number }}" > "$OUTPUT_DIR/artifact_name.txt"
+
+      - name: Upload small model artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: model-${{ needs.resolve.outputs.model_name }}-${{ github.run_number }}
+          path: ${{ github.workspace }}/small_output/
+
+      - name: Upload artifact name file
+        uses: actions/upload-artifact@v4
+        with:
+          name: artifact-name-${{ needs.resolve.outputs.model_name }}
+          path: ${{ github.workspace }}/small_output/artifact_name.txt
+
+      - name: Re-enable powersave
+        if: always()
+        run: |
+          source ${UV_PROJECT_ENVIRONMENT}/bin/activate
+          PYTHONPATH=$PYTHONPATH:${{ github.workspace }}/ ${{ github.workspace }}/scripts/manage-powersave.py --enable
+
+  build_big_model:
+    needs: resolve
+    if: ${{ inputs.target == 'big' }}
+    runs-on: [self-hosted, usbgpu]
+    env:
+      BIG_ONNX: openpilot/selfdrive/modeld/models/big_driving_supercombo.onnx
+      BIG_PKL: openpilot/selfdrive/modeld/models/big_driving_tinygrad.pkl
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Pull big ONNX via LFS
+        run: git lfs pull -I "${{ env.BIG_ONNX }}"
+
+      - name: Set environment variables
+        run: |
+          source /etc/profile
+          export UV_PROJECT_ENVIRONMENT=${HOME}/venv
+          export UV_PYTHON_PREFERENCE=managed
+          export UV_PYTHON_INSTALL_DIR=${HOME}/uv/python
+          export VIRTUAL_ENV=$UV_PROJECT_ENVIRONMENT
+          uv sync --frozen
+          printenv >> $GITHUB_ENV
+
+      - name: Disable powersave
+        run: |
+          source ${UV_PROJECT_ENVIRONMENT}/bin/activate
+          PYTHONPATH=$PYTHONPATH:${{ github.workspace }}/ ${{ github.workspace }}/scripts/manage-powersave.py --disable
+
+      - name: Wait for chestnut PCIe link
+        run: |
+          source ${UV_PROJECT_ENVIRONMENT}/bin/activate
+          export PYTHONPATH="${PYTHONPATH}:${{ github.workspace }}/tinygrad_repo:${{ github.workspace }}"
+          python3 -c "
+          import time
+          from openpilot.system.hardware.chestnut.flash import link_up
+          for i in range(10):
+              if link_up():
+                  print(f'PCIe link up after {i+1} attempt(s)')
+                  break
+              time.sleep(1)
+          else:
+              raise RuntimeError('Chestnut PCIe link not ready after 10 attempts')
+          "
+
+      - name: Compile big model with stock compiler
+        run: |
+          source ${UV_PROJECT_ENVIRONMENT}/bin/activate
+          export PYTHONPATH="${PYTHONPATH}:${{ github.workspace }}/tinygrad_repo:${{ github.workspace }}"
+
+          MODEL_SIZE=$(python3 -c "from openpilot.common.transformations.model import MEDMODEL_INPUT_SIZE as s; print(f'{s[0]}x{s[1]}')")
+          CAMERA_RES=$(python3 -c "from openpilot.common.transformations.camera import _ar_ox_fisheye as a, _os_fisheye as o; print(f'{a.width}x{a.height} {o.width}x{o.height}')")
+          FRAME_SKIP=$(python3 -c "from openpilot.selfdrive.modeld.constants import ModelConstants as MC; print(MC.MODEL_RUN_FREQ // MC.MODEL_CONTEXT_FREQ)")
+
+          TG_FLAGS="DEBUG=2 DEV=USB+AMD:LLVM WARP_DEV=QCOM FLOAT16=1 JIT_BATCH_SIZE=0 GMMU=0 TC_OPT=2"
+
+          env ${TG_FLAGS} python3 \
+            ${{ github.workspace }}/openpilot/selfdrive/modeld/compile_modeld.py \
+            --onnx ${{ github.workspace }}/${{ env.BIG_ONNX }} \
+            --model-size $MODEL_SIZE \
+            --camera-resolutions $CAMERA_RES \
+            --frame-skip $FRAME_SKIP \
+            --output ${{ github.workspace }}/${{ env.BIG_PKL }}
+
+      - name: Chunk big pkl
+        run: |
+          source ${UV_PROJECT_ENVIRONMENT}/bin/activate
+          export PYTHONPATH=${{ github.workspace }}
+          python3 -c "
+          from openpilot.common.file_chunker import chunk_file, get_chunk_targets
+          import os
+          pkl = '${{ github.workspace }}/${{ env.BIG_PKL }}'
+          size = os.path.getsize(pkl)
+          targets = get_chunk_targets(pkl, size)
+          chunk_file(pkl, targets)
+          print(f'Chunked into {len(targets)} files')
+          "
+
+      - name: Prepare output
+        env:
+          MODEL_NAME: ${{ needs.resolve.outputs.model_name }}
+        run: |
+          source ${UV_PROJECT_ENVIRONMENT}/bin/activate
+          export PYTHONPATH=${{ github.workspace }}
+          MODELS_DIR="${{ github.workspace }}/openpilot/selfdrive/modeld/models"
+          OUTPUT_DIR="${{ github.workspace }}/big_output"
+          PKL_BASE="big_driving_tinygrad.pkl"
+          mkdir -p "$OUTPUT_DIR"
+
+          cp "$MODELS_DIR/${PKL_BASE}".chunk* "$OUTPUT_DIR/"
+          cp "$MODELS_DIR/${PKL_BASE}.chunkmanifest" "$OUTPUT_DIR/"
+
+          python3 "${{ github.workspace }}/release/ci/model_generator.py" \
+            --model-dir "$MODELS_DIR" \
+            --output-dir "$OUTPUT_DIR" \
+            --custom-name "$MODEL_NAME" \
+            --upstream-branch "${{ needs.resolve.outputs.onnx_ref }}"
+
+          echo "model-${MODEL_NAME}-${{ github.run_number }}" > "$OUTPUT_DIR/artifact_name.txt"
+
+      - name: Upload big model artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: model-${{ needs.resolve.outputs.model_name }}-${{ github.run_number }}
+          path: ${{ github.workspace }}/big_output/
+
+      - name: Upload artifact name file
+        uses: actions/upload-artifact@v4
+        with:
+          name: artifact-name-${{ needs.resolve.outputs.model_name }}
+          path: ${{ github.workspace }}/big_output/artifact_name.txt
+
+      - name: Re-enable powersave
+        if: always()
+        run: |
+          source ${UV_PROJECT_ENVIRONMENT}/bin/activate
+          PYTHONPATH=$PYTHONPATH:${{ github.workspace }}/ ${{ github.workspace }}/scripts/manage-powersave.py --enable
+
+  upload_defaults:
+    needs: [ resolve, build_small_model, build_big_model, build_dm_model ]
+    if: |
+      ${{
+        !cancelled() &&
+        (inputs.target == 'big' && needs.build_big_model.result == 'success' ||
+         inputs.target == 'small' && needs.build_small_model.result == 'success' ||
+         inputs.target == 'dm' && needs.build_dm_model.result == 'success')
+      }}
+    runs-on: ubuntu-24.04
+    permissions:
+      id-token: write
+      contents: write
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Pull ONNX via LFS
+        run: git lfs pull -I "${{ needs.resolve.outputs.onnx_path }}"
+
+      - name: Install huggingface_hub
+        run: pip install --upgrade "huggingface_hub>=0.22.0"
+
+      - name: Download artifact name
+        if: ${{ inputs.target == 'small' || inputs.target == 'big' }}
+        uses: actions/download-artifact@v4
+        with:
+          name: artifact-name-${{ needs.resolve.outputs.model_name }}
+          path: artifact_name
+
+      - name: Read artifact name
+        if: ${{ inputs.target == 'small' || inputs.target == 'big' }}
+        id: artifact
+        run: |
+          ARTIFACT_NAME=$(cat artifact_name/artifact_name.txt)
+          echo "artifact_name=$ARTIFACT_NAME" >> $GITHUB_OUTPUT
+
+      - name: Download model artifact
+        if: ${{ inputs.target == 'small' || inputs.target == 'big' }}
+        uses: actions/download-artifact@v4
+        with:
+          name: ${{ steps.artifact.outputs.artifact_name }}
+          path: output
+
+      - name: Upload model to HF
+        if: ${{ inputs.target == 'small' || inputs.target == 'big' }}
+        env:
+          HF_OIDC_RESOURCE: datasets/${{ env.HF_REPO }}
+          ARTIFACT_NAME: ${{ steps.artifact.outputs.artifact_name }}
+        run: |
+          rm -f output/artifact_name.txt
+          export PYTHONPATH=$(pwd)
+          python3 release/ci/upload_default_model.py \
+            --hf-repo "${{ env.HF_REPO }}" \
+            --hf-defaults-path "${{ needs.resolve.outputs.hf_defaults_path }}" \
+            --artifact-name "$ARTIFACT_NAME" \
+            --model-dir output \
+            --onnx-path "${{ needs.resolve.outputs.onnx_path }}" \
+            --onnx-ref "${{ needs.resolve.outputs.onnx_ref }}" \
+            --model-name "${{ needs.resolve.outputs.model_name }}" \
+            --tinygrad-ref "${{ needs.resolve.outputs.tinygrad_ref }}" \
+            --run-number "${{ github.run_number }}"
+
+      - name: Download DM artifact
+        if: ${{ inputs.target == 'dm' }}
+        uses: actions/download-artifact@v4
+        with:
+          name: dm-model-${{ github.run_number }}
+          path: dm_output
+
+      - name: Generate DM metadata and upload to HF
+        if: ${{ inputs.target == 'dm' }}
+        env:
+          HF_OIDC_RESOURCE: datasets/${{ env.HF_REPO }}
+        run: |
+          export PYTHONPATH=$(pwd)
+          python3 -c "
+          import json, hashlib
+          from pathlib import Path
+          from datetime import datetime, UTC
+
+          dm_dir = Path('dm_output')
+          manifest = list(dm_dir.glob('*.chunkmanifest'))
+          assert manifest, 'No chunkmanifest found'
+          pkl_name = manifest[0].name.removesuffix('.chunkmanifest')
+          num_chunks = int(manifest[0].read_text().strip())
+
+          chunks = []
+          for i in range(num_chunks):
+              chunk = dm_dir / f'{pkl_name}.chunk{i+1:02d}of{num_chunks:02d}'
+              chunks.append({
+                  'file_name': chunk.name,
+                  'sha256': hashlib.sha256(chunk.read_bytes()).hexdigest()
+              })
+
+          digest = hashlib.sha256()
+          for c in chunks:
+              with open(dm_dir / c['file_name'], 'rb') as f:
+                  while block := f.read(1024*1024):
+                      digest.update(block)
+
+          metadata = {
+              'bundles': [{
+                  'short_name': 'DMMODEL',
+                  'display_name': '${{ needs.resolve.outputs.model_name }}',
+                  'ref': '${{ needs.resolve.outputs.onnx_ref }}',
+                  'runner': 'tinygrad',
+                  'build_time': datetime.now(UTC).strftime('%Y-%m-%dT%H:%M:%SZ'),
+                  'models': [{
+                      'type': 'chunked',
+                      'artifact': {
+                          'file_name': pkl_name,
+                          'download_uri': {'url': '', 'sha256': digest.hexdigest()},
+                          'chunks': chunks
+                      }
+                  }]
+              }]
+          }
+          with open(dm_dir / 'metadata.json', 'w') as f:
+              json.dump(metadata, f, indent=2)
+          print('Generated DM metadata.json')
+          "
+
+          python3 release/ci/upload_default_model.py \
+            --hf-repo "${{ env.HF_REPO }}" \
+            --hf-defaults-path "${{ needs.resolve.outputs.hf_defaults_path }}" \
+            --artifact-name "dm-model-${{ github.run_number }}" \
+            --model-dir dm_output \
+            --onnx-path "${{ needs.resolve.outputs.onnx_path }}" \
+            --onnx-ref "${{ needs.resolve.outputs.onnx_ref }}" \
+            --model-name "${{ needs.resolve.outputs.model_name }}" \
+            --tinygrad-ref "${{ needs.resolve.outputs.tinygrad_ref }}" \
+            --run-number "${{ github.run_number }}"
+
+  build_dm_model:
+    needs: resolve
+    if: ${{ inputs.target == 'dm' }}
+    runs-on: [self-hosted, tici]
+    env:
+      DM_ONNX: openpilot/selfdrive/modeld/models/dmonitoring_model.onnx
+      DM_PKL: openpilot/selfdrive/modeld/models/dmonitoring_model_tinygrad.pkl
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Pull DM ONNX via LFS
+        run: git lfs pull -I "${{ env.DM_ONNX }}"
+
+      - name: Set environment variables
+        run: |
+          source /etc/profile
+          export UV_PROJECT_ENVIRONMENT=${HOME}/venv
+          export UV_PYTHON_PREFERENCE=managed
+          export UV_PYTHON_INSTALL_DIR=${HOME}/uv/python
+          export VIRTUAL_ENV=$UV_PROJECT_ENVIRONMENT
+          uv sync --frozen
+          printenv >> $GITHUB_ENV
+
+      - name: Disable powersave
+        run: |
+          source ${UV_PROJECT_ENVIRONMENT}/bin/activate
+          PYTHONPATH=$PYTHONPATH:${{ github.workspace }}/ ${{ github.workspace }}/scripts/manage-powersave.py --disable
+
+      - name: Compile DM model
+        run: |
+          source ${UV_PROJECT_ENVIRONMENT}/bin/activate
+          export PYTHONPATH="${PYTHONPATH}:${{ github.workspace }}/tinygrad_repo:${{ github.workspace }}"
+
+          TG_FLAGS="DEV=QCOM IMAGE=1 FLOAT16=1 NOLOCALS=1 JIT_BATCH_SIZE=0 OPENPILOT_HACKS=1"
+
+          taskset -c 7 env ${TG_FLAGS} python3 \
+            ${{ github.workspace }}/tinygrad_repo/examples/openpilot/compile3.py \
+            ${{ github.workspace }}/${{ env.DM_ONNX }} \
+            ${{ github.workspace }}/${{ env.DM_PKL }}
+
+      - name: Chunk DM pkl
+        run: |
+          source ${UV_PROJECT_ENVIRONMENT}/bin/activate
+          export PYTHONPATH=${{ github.workspace }}
+          python3 -c "
+          from openpilot.common.file_chunker import chunk_file, get_chunk_targets
+          import os
+          pkl = '${{ github.workspace }}/${{ env.DM_PKL }}'
+          size = os.path.getsize(pkl)
+          targets = get_chunk_targets(pkl, size)
+          chunk_file(pkl, targets)
+          print(f'Chunked {pkl} into {len(targets)} chunks')
+          "
+
+      - name: Prepare DM output
+        run: |
+          mkdir -p dm_output
+          cp ${{ github.workspace }}/${{ env.DM_PKL }}.chunk* dm_output/
+          cp ${{ github.workspace }}/${{ env.DM_PKL }}.chunkmanifest dm_output/
+
+      - name: Upload DM artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: dm-model-${{ github.run_number }}
+          path: dm_output/
+
+      - name: Re-enable powersave
+        if: always()
+        run: |
+          source ${UV_PROJECT_ENVIRONMENT}/bin/activate
+          PYTHONPATH=$PYTHONPATH:${{ github.workspace }}/ ${{ github.workspace }}/scripts/manage-powersave.py --enable
+
@@ -29,11 +29,24 @@ on:
        required: false
        type: boolean
        default: true
-      bypass_push:
-        description: 'Bypass pushing to GitLab for build-all'
+      target_hardware:
+        description: 'Hardware target to compile for (qcom or usbgpu)'
        required: false
-        default: true
-        type: boolean
+        type: string
+        default: 'qcom'
+      hf_repo:
+        description: 'Hugging Face dataset repository (e.g. sunnypilot/sunnypilot_models_v1)'
+        required: false
+        type: string
+        default: 'sunnypilot/sunnypilot_models_v1'
+      set_min_version:
+        description: 'Minimum selector version'
+        required: false
+        type: string
+      tinygrad_ref:
+        description: 'Tinygrad reference'
+        required: false
+        type: string
  workflow_dispatch:
    inputs:
      upstream_branch:
@@ -65,8 +78,8 @@ on:
          - None
          - Master Models
          - Release Models
-          - 2025 World Models
          - 2026 World Models
+          - 2026 Deep RL Models
          - Custom Merge Models
          - Other
      custom_model_folder:
@@ -81,9 +94,22 @@ on:
        description: 'Minimum selector version'
        required: false
        type: string
+      target_hardware:
+        description: 'Hardware target to compile for'
+        required: false
+        type: choice
+        default: 'qcom'
+        options:
+          - qcom
+          - usbgpu
+      hf_repo:
+        description: 'Hugging Face dataset repository'
+        required: false
+        type: string
+        default: 'sunnypilot/sunnypilot_models_v1'
 env:
  RECOMPILED_DIR: recompiled${{ inputs.recompiled_dir }}
-  JSON_FILE: docs/docs/driving_models_v${{ inputs.json_version }}.json
+  JSON_FILE: docs/docs/driving_models_${{ inputs.target_hardware == 'usbgpu' && 'usbgpu_v' || 'v' }}${{ inputs.json_version }}.json

 jobs:
  build_model:
@@ -93,38 +119,20 @@ jobs:
      custom_name: ${{ inputs.custom_name || inputs.upstream_branch }}
      is_20hz: ${{ inputs.is_20hz }}
      artifact_suffix: ${{ inputs.artifact_suffix }}
+      target_hardware: ${{ inputs.target_hardware }}
    secrets: inherit

  publish_model:
-    if: ${{ !inputs.bypass_push && !cancelled() }}
+    if: ${{ !cancelled() && needs.build_model.result == 'success' }}
    concurrency:
-      group: gitlab-push-${{ inputs.recompiled_dir }}
+      group: hf-push-${{ inputs.recompiled_dir }}
      cancel-in-progress: false
    needs: build_model
    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+      contents: write
    steps:
-      - name: Set up SSH
-        uses: webfactory/ssh-agent@v0.9.0
-        with:
-          ssh-private-key: ${{ secrets.GITLAB_SSH_PRIVATE_KEY }}
-
-      - name: Add GitLab.com SSH key to known_hosts
-        run: |
-          mkdir -p ~/.ssh
-          ssh-keyscan -H gitlab.com >> ~/.ssh/known_hosts
-
-      - name: Clone GitLab docs repo
-        env:
-          GIT_SSH_COMMAND: 'ssh -o UserKnownHostsFile=~/.ssh/known_hosts'
-        run: |
-          echo "Cloning GitLab"
-          git clone --depth 1 --filter=tree:0 --sparse git@gitlab.com:sunnypilot/public/${{ vars.MODELS_GITLAB }} gitlab_docs
-          cd gitlab_docs
-          echo "checkout models/${RECOMPILED_DIR}"
-          git sparse-checkout set --no-cone models/${RECOMPILED_DIR}
-          git checkout main
-          cd ..
-
      - name: Checkout docs repo
        uses: actions/checkout@v4
        with:
@@ -133,16 +141,28 @@ jobs:
          path: docs
          ssh-key: ${{ secrets.CI_SUNNYPILOT_DOCS_PRIVATE_KEY }}

-      - name: Validate recompiled dir and JSON version
+      - name: Install huggingface_hub
+        run: pip install --upgrade "huggingface_hub>=0.22.0"
+
+      - name: Validate hf_repo and JSON version
+        env:
+          HF_OIDC_RESOURCE: datasets/${{ inputs.hf_repo }}
        run: |
-          if [ ! -d "gitlab_docs/models/$RECOMPILED_DIR" ]; then
-            echo "Recompiled dir $RECOMPILED_DIR does not exist in GitLab repo"
-            exit 1
-          fi
          if [ ! -f "$JSON_FILE" ]; then
            echo "JSON file $JSON_FILE does not exist!"
            exit 1
          fi
+          python3 -c "
+          import sys
+          from huggingface_hub import HfApi
+          try:
+              api = HfApi()
+              api.repo_info(repo_id=sys.argv[1], repo_type='dataset')
+              print(f'Success: Repo {sys.argv[1]} exists.')
+          except Exception as e:
+              print('HF validation failed:', e)
+              sys.exit(1)
+          " "${{ inputs.hf_repo }}"

      - name: Download artifact name file
        uses: actions/download-artifact@v4
@@ -162,49 +182,26 @@ jobs:
          name: ${{ steps.read-artifact-name.outputs.artifact_name }}
          path: output

-      - name: Remove unwanted files
-        run: |
-          find output -type f -name 'dmonitoring_model_tinygrad.pkl' -delete
-          find output -type f -name 'dmonitoring_model.onnx' -delete
-
-      - name: Copy model artifact(s) to GitLab recompiled dir
+      - name: Create models folder
        env:
          ARTIFACT_NAME: ${{ steps.read-artifact-name.outputs.artifact_name }}
        run: |
-          ARTIFACT_DIR="gitlab_docs/models/${RECOMPILED_DIR}/${ARTIFACT_NAME}"
-          mkdir -p "$ARTIFACT_DIR"
-          for path in output/*; do
-            if [ "$(basename "$path")" = "artifact_name.txt" ]; then
-              continue
-            fi
-            name="$(basename "$path")"
-            if [ -d "$path" ]; then
-              mkdir -p "$ARTIFACT_DIR/$name"
-              cp -r "$path"/* "$ARTIFACT_DIR/$name/"
-              echo "Copied dir $name -> $ARTIFACT_DIR/$name"
-            else
-              cp "$path" "$ARTIFACT_DIR/"
-              echo "Copied file $name -> $ARTIFACT_DIR/"
-            fi
-          done
+          mkdir -p "local_models/${RECOMPILED_DIR}/${ARTIFACT_NAME}"
+          cp -r output/* "local_models/${RECOMPILED_DIR}/${ARTIFACT_NAME}/"
+          rm -f "local_models/${RECOMPILED_DIR}/${ARTIFACT_NAME}/artifact_name.txt"

-      - name: Push recompiled dir to GitLab
+      - name: Upload to Hugging Face
        env:
-          GITLAB_SSH_PRIVATE_KEY: ${{ secrets.GITLAB_SSH_PRIVATE_KEY }}
+          HF_OIDC_RESOURCE: datasets/${{ inputs.hf_repo }}
+          ARTIFACT_NAME: ${{ steps.read-artifact-name.outputs.artifact_name }}
        run: |
-          cd gitlab_docs
-          git checkout main
-          git pull origin main
-          for d in models/"$RECOMPILED_DIR"/*/; do
-            git sparse-checkout add "$d"
-          done
-          git add models/"$RECOMPILED_DIR"
-          git config --global user.name "GitHub Action"
-          git config --global user.email "action@github.com"
-          git commit -m "Create/Update $RECOMPILED_DIR with new/updated model from build-single-tinygrad-model" || echo "No changes to commit"
-          git push origin main
+          hf upload ${{ inputs.hf_repo }} \
+            output/ \
+            "models/${RECOMPILED_DIR}/${ARTIFACT_NAME}/" \
+            --repo-type=dataset

-      - run: |
+      - name: Pull gh-pages
+        run: |
          cd docs
          git pull origin gh-pages

@@ -220,9 +217,11 @@ jobs:
          fi
          [ -n "${{ inputs.generation }}" ] && ARGS="$ARGS --generation \"${{ inputs.generation }}\""
          [ -n "${{ inputs.version }}" ] && ARGS="$ARGS --version \"${{ inputs.version }}\""
+          [ -n "${{ inputs.set_min_version }}" ] && ARGS="$ARGS --set-min-version \"${{ inputs.set_min_version }}\""
+          [ -n "${{ inputs.tinygrad_ref }}" ] && ARGS="$ARGS --tinygrad-ref \"${{ inputs.tinygrad_ref }}\""
          eval python3 docs/json_parser.py \
            --json-path "$JSON_FILE" \
-            --recompiled-dir "gitlab_docs/models/$RECOMPILED_DIR" \
+            --recompiled-dir "local_models/$RECOMPILED_DIR" \
            --sort-by-date \
            $ARGS

@@ -0,0 +1,66 @@
+name: Download HF model chunks
+description: Resolve and download model chunks from HuggingFace in parallel
+
+inputs:
+  hf_repo:
+    description: HuggingFace dataset repo
+    required: true
+  models:
+    description: 'JSON array of {hf_path, onnx_hash, canonical} objects'
+    required: true
+  dest_dir:
+    description: Destination directory for downloaded chunks
+    required: true
+
+runs:
+  using: composite
+  steps:
+    - name: Download model chunks
+      shell: bash
+      env:
+        HF_REPO: ${{ inputs.hf_repo }}
+        MODELS_JSON: ${{ inputs.models }}
+        DEST_DIR: ${{ inputs.dest_dir }}
+      run: |
+        set -eo pipefail
+        DOWNLOAD_LIST=$(mktemp)
+
+        resolve_chunks() {
+          local HF_PATH="$1" ONNX_HASH="$2" CANONICAL="$3" DEST_DIR="$4"
+          local JSON_URL="https://huggingface.co/datasets/${HF_REPO}/resolve/main/${HF_PATH}/default_models.json"
+          local DEFAULTS BUNDLE ARTIFACT BASE_URL NUM_CHUNKS
+          DEFAULTS=$(curl -fsSL "$JSON_URL")
+          BUNDLE=$(echo "$DEFAULTS" | jq --arg hash "$ONNX_HASH" '.bundles[] | select(.onnx_sha256 == $hash)')
+          ARTIFACT=$(echo "$BUNDLE" | jq -r '.models[0].artifact')
+          BASE_URL=$(echo "$ARTIFACT" | jq -r '.download_uri.url' | sed 's|/[^/]*$||')
+          NUM_CHUNKS=$(echo "$ARTIFACT" | jq -r '.chunks | length')
+
+          mkdir -p "$DEST_DIR"
+          while IFS= read -r CHUNK_NAME; do
+            CHUNK_IDX=$(echo "$CHUNK_NAME" | grep -oP 'chunk\K[0-9]+of[0-9]+' || true)
+            if [ -z "$CHUNK_IDX" ]; then
+              echo "::error::Failed to parse chunk index from: $CHUNK_NAME"
+              return 1
+            fi
+            ENCODED_URL=$(python3 -c "import urllib.parse; print(urllib.parse.quote('${BASE_URL}/${CHUNK_NAME}', safe=':/'))")
+            printf '%s\t%s\n' "$ENCODED_URL" "${DEST_DIR}/${CANONICAL}.chunk${CHUNK_IDX}" >> "$DOWNLOAD_LIST"
+          done < <(echo "$ARTIFACT" | jq -r '.chunks[].file_name')
+          echo "$NUM_CHUNKS" > "${DEST_DIR}/${CANONICAL}.chunkmanifest"
+        }
+
+        echo "$MODELS_JSON" | jq -c '.[]' | while IFS= read -r model; do
+          HF_PATH=$(echo "$model" | jq -r '.hf_path')
+          ONNX_HASH=$(echo "$model" | jq -r '.onnx_hash')
+          CANONICAL=$(echo "$model" | jq -r '.canonical')
+          resolve_chunks "$HF_PATH" "$ONNX_HASH" "$CANONICAL" "$DEST_DIR"
+        done
+
+        TOTAL=$(wc -l < "$DOWNLOAD_LIST")
+        echo "Downloading $TOTAL chunks with 8 parallel connections..."
+        xargs -P8 -d'\n' -I{} bash -c '
+          URL="${1%%	*}"
+          DEST="${1#*	}"
+          echo "Downloading $(basename "$DEST")"
+          curl -fsSL --retry 3 --retry-delay 5 -o "$DEST" "$URL"
+        ' _ {} < "$DOWNLOAD_LIST"
+        rm -f "$DOWNLOAD_LIST"
@@ -80,6 +80,7 @@ jobs:
        with:
          repository: commaai/openpilot
          ref: ${{ inputs.upstream_branch }}
+          fetch-depth: 1
          submodules: recursive
          path: openpilot

@@ -89,26 +90,38 @@ jobs:
        with:
          repository: sunnypilot/sunnypilot
          ref: ${{ inputs.upstream_branch }}
+          fetch-depth: 1
          submodules: recursive
          path: openpilot
      - name: Get commit date
        id: commit-date
        run: |
-          cd ${{ github.workspace }}/openpilot
+          cd ${{ github.workspace }}/openpilot/openpilot
          commit_date=$(git log -1 --format=%cd --date=format:'%B %d, %Y')
          echo "model_date=${commit_date}" >> $GITHUB_OUTPUT
          cat $GITHUB_OUTPUT
      - run: |
-          cd ${{ github.workspace }}/openpilot
-          git lfs pull
+          cd ${{ github.workspace }}/openpilot/openpilot
+          if [ "${{ inputs.target_hardware }}" != "usbgpu" ]; then
+            git lfs pull -X "**/selfdrive/modeld/models/big_*.onnx,**/selfdrive/modeld/models/dmonitoring_*.onnx"
+            rm -f selfdrive/modeld/models/big_*.onnx selfdrive/modeld/models/dmonitoring_*.onnx
+          else
+            git lfs pull -I "**/selfdrive/modeld/models/big_*.onnx" -X ""
+            find selfdrive/modeld/models -name "*.onnx" ! -name "big_*.onnx" -delete
+          fi
+          if grep -lIF "version https://git-lfs.github.com/spec/v1" selfdrive/modeld/models/*.onnx; then
+            echo "::error::the ONNX files above are still LFS pointers, not real models"
+            exit 1
+          fi
      - name: 'Upload Artifact'
        uses: actions/upload-artifact@v4
        with:
          name: models-${{ env.REF }}${{ inputs.artifact_suffix  }}
          path: ${{ github.workspace }}/openpilot/openpilot/selfdrive/modeld/models/*.onnx
+          if-no-files-found: error

  build_model:
-    runs-on: [self-hosted, tici]
+    runs-on: [self-hosted, usbgpu]
    needs: get_model
    env:
      MODEL_NAME: ${{ inputs.custom_name || inputs.upstream_branch }} (${{ needs.get_model.outputs.model_date }})
@@ -116,24 +129,9 @@ jobs:
    steps:
      - uses: actions/checkout@v4
        with:
+          fetch-depth: 1
          submodules: recursive

-      - run: git lfs pull
-      - name: Cache SCons
-        uses: actions/cache@v4
-        with:
-          path: ${{env.SCONS_CACHE_DIR}}
-          key: scons-${{ runner.os }}-${{ runner.arch }}-${{ github.head_ref || github.ref_name }}-model-${{ github.sha }}
-          # Note: GitHub Actions enforces cache isolation between different build sources (PR builds, workflow dispatches, etc.)
-          #   for security. Only caches from the default branch are shared across all builds. This is by design and cannot be overridden.
-          restore-keys: |
-            scons-${{ runner.os }}-${{ runner.arch }}-${{ github.head_ref || github.ref_name }}-model
-            scons-${{ runner.os }}-${{ runner.arch }}-${{ github.head_ref || github.ref_name }}
-            scons-${{ runner.os }}-${{ runner.arch }}-${{ env.MASTER_NEW_BRANCH }}-model
-            scons-${{ runner.os }}-${{ runner.arch }}-${{ env.MASTER_BRANCH }}-model
-            scons-${{ runner.os }}-${{ runner.arch }}-${{ env.MASTER_NEW_BRANCH }}
-            scons-${{ runner.os }}-${{ runner.arch }}-${{ env.MASTER_BRANCH }}
-            scons-${{ runner.os }}-${{ runner.arch }}

      - name: Set environment variables
        id: set-env
@@ -144,7 +142,7 @@ jobs:
          export UV_PYTHON_PREFERENCE=managed
          export UV_PYTHON_INSTALL_DIR=${HOME}/uv/python
          export VIRTUAL_ENV=$UV_PROJECT_ENVIRONMENT
-          uv sync
+          uv sync --frozen
          printenv >> $GITHUB_ENV
          if [[ "${{ runner.debug }}" == "1" ]]; then
            cat $GITHUB_OUTPUT
@@ -166,15 +164,13 @@ jobs:
          fi
          source ${UV_PROJECT_ENVIRONMENT}/bin/activate
          PYTHONPATH=$PYTHONPATH:${{ github.workspace }}/ ${{ github.workspace }}/scripts/manage-powersave.py --disable
-          rm -rf ${{ env.MODELS_DIR }}/*.onnx
+          rm -rf ${{ env.MODELS_DIR }}/*.onnx*

      - name: Download model artifacts
        uses: actions/download-artifact@v4
        with:
          name: models-${{ env.REF }}${{ inputs.artifact_suffix }}
          path: ${{ env.MODELS_DIR }}
-      - run: |
-          rm -f ${{ env.MODELS_DIR }}/{dmonitoring_model,big_driving_policy,big_driving_vision,big_driving_supercombo}.onnx

      - name: Build Model
        run: |
@@ -188,34 +184,48 @@ jobs:
          MODEL_SIZE=$(python3 -c "from openpilot.common.transformations.model import MEDMODEL_INPUT_SIZE as s; print(f'{s[0]}x{s[1]}')")
          CAMERA_RES=$(python3 -c "from openpilot.common.transformations.camera import _ar_ox_fisheye as a, _os_fisheye as o; print(f'{a.width}x{a.height} {o.width}x{o.height}')")

+          TG_FLAGS_QCOM="DEV=QCOM IMAGE=1 FLOAT16=1 NOLOCALS=1 JIT_BATCH_SIZE=0 OPENPILOT_HACKS=1"
          if [ "${{ inputs.target_hardware }}" == "usbgpu" ]; then
            echo "USBGPU build"
            export USBGPU=1
-            TG_FLAGS="DEV=AMD USBGPU=1 IMAGE=1 FLOAT16=1 NOLOCALS=1 JIT_BATCH_SIZE=0 OPENPILOT_HACKS=1"
+            TG_FLAGS="DEBUG=1 DEV=USB+AMD:LLVM WARP_DEV=QCOM FLOAT16=1 JIT_BATCH_SIZE=0 GMMU=0 TC_OPT=2"
            OUTPUT_PKL="${{ env.MODELS_DIR }}/big_driving_tinygrad.pkl"
          else
            echo "QCOM build"
-            TG_FLAGS="DEV=QCOM IMAGE=1 FLOAT16=1 NOLOCALS=1 JIT_BATCH_SIZE=0 OPENPILOT_HACKS=1"
+            TG_FLAGS="$TG_FLAGS_QCOM"
            OUTPUT_PKL="${{ env.MODELS_DIR }}/driving_tinygrad.pkl"
          fi

          # Generate metadata for all ONNX files
          find "${{ env.MODELS_DIR }}" -maxdepth 1 -name '*.onnx' | while IFS= read -r onnx_file; do
            echo "Generating metadata: $onnx_file"
-            env ${TG_FLAGS} python3 "${{ env.MODELS_DIR }}/../get_model_metadata.py" "$onnx_file" || true
+            env ${TG_FLAGS_QCOM} python3 "${{ env.MODELS_DIR }}/../get_model_metadata.py" "$onnx_file" || true
          done

          # Detect model type and build compile args
-          VISION_ONNX="${{ env.MODELS_DIR }}/driving_vision.onnx"
-          POLICY_ONNX="${{ env.MODELS_DIR }}/driving_policy.onnx"
-          OFF_POLICY_ONNX="${{ env.MODELS_DIR }}/driving_off_policy.onnx"
-          ON_POLICY_ONNX="${{ env.MODELS_DIR }}/driving_on_policy.onnx"
+          VISION_ONNX=""
+          for f in "${{ env.MODELS_DIR }}/driving_vision.onnx" "${{ env.MODELS_DIR }}/big_driving_vision.onnx"; do
+            [ -f "$f" ] && VISION_ONNX="$f" && break
+          done
+
+          POLICY_ONNX=""
+          for f in "${{ env.MODELS_DIR }}/driving_policy.onnx" "${{ env.MODELS_DIR }}/big_driving_policy.onnx"; do
+            [ -f "$f" ] && POLICY_ONNX="$f" && break
+          done
+
+          OFF_POLICY_ONNX=""
+          for f in "${{ env.MODELS_DIR }}/driving_off_policy.onnx" "${{ env.MODELS_DIR }}/big_driving_off_policy.onnx"; do
+            [ -f "$f" ] && OFF_POLICY_ONNX="$f" && break
+          done
+
+          ON_POLICY_ONNX=""
+          for f in "${{ env.MODELS_DIR }}/driving_on_policy.onnx" "${{ env.MODELS_DIR }}/big_driving_on_policy.onnx"; do
+            [ -f "$f" ] && ON_POLICY_ONNX="$f" && break
+          done
+
          SUPERCOMBO_ONNX=""
-          for f in "${{ env.MODELS_DIR }}/supercombo.onnx" "${{ env.MODELS_DIR }}/driving_supercombo.onnx"; do
-            if [ -f "$f" ]; then
-              SUPERCOMBO_ONNX="$f"
-              break
-            fi
+          for f in "${{ env.MODELS_DIR }}/supercombo.onnx" "${{ env.MODELS_DIR }}/driving_supercombo.onnx" "${{ env.MODELS_DIR }}/big_supercombo.onnx" "${{ env.MODELS_DIR }}/big_driving_supercombo.onnx"; do
+            [ -f "$f" ] && SUPERCOMBO_ONNX="$f" && break
          done

          MODEL_TYPE="" ONNX_ARGS="" OUTPUT_NAME=""
@@ -254,10 +264,8 @@ jobs:
          # Copy the model files
          rsync -avm \
            --include='*.dlc' \
-            --include='*.pkl' \
            --include='*.chunk*' \
            --include='*.chunkmanifest' \
-            --include='*.onnx' \
            --exclude='*' \
            --delete-excluded \
            --chown=comma:comma \
@@ -4,12 +4,8 @@ env:
  BUILD_DIR: "/data/openpilot"
  OUTPUT_DIR: ${{ github.workspace }}/output
  CI_DIR: ${{ github.workspace }}/release/ci
-  SCONS_CACHE_DIR: ${{ github.workspace }}/release/ci/scons_cache
  PUBLIC_REPO_URL: "https://github.com/sunnypilot/sunnypilot"

-  # Branch configurations
-  STAGING_SOURCE_BRANCH: 'master'
-
  # Runtime configuration
  SOURCE_BRANCH: "${{ github.head_ref || github.ref_name }}"

@@ -40,8 +36,11 @@ jobs:
      publish_concurrency_group: ${{ steps.strategy.outputs.publish_concurrency_group }}
      is_stable_branch: ${{ steps.strategy.outputs.is_stable_branch }}
      build: ${{ steps.strategy.outputs.build }}
+      include_big_model: ${{ steps.strategy.outputs.include_big_model }}
    steps:
      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
      - name: Extract deploy strategy
        id: strategy
        run: |
@@ -82,6 +81,9 @@ jobs:
            stable_version=$(cat openpilot/sunnypilot/common/version.h | grep SUNNYPILOT_VERSION | sed -e 's/[^0-9|.]//g');
            echo "version=$([ "$is_stable_branch" = "true" ] && echo "$stable_version" || echo "$BUILD")" >> $GITHUB_OUTPUT
            echo "extra_version_identifier=${environment}" >> $GITHUB_OUTPUT
+
+            include_big_model="$(echo "$CONFIG" | jq -r '.include_big_model // false')";
+            echo "include_big_model=$include_big_model" >> $GITHUB_OUTPUT
          fi
          echo "build=$BUILD" >> $GITHUB_OUTPUT
          cat $GITHUB_OUTPUT
@@ -96,6 +98,8 @@ jobs:
      }}
    steps:
      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
      - name: Wait for Tests
        uses: ./.github/workflows/wait-for-action # Path to where you place the action
        with:
@@ -109,11 +113,6 @@ jobs:
      group: build-${{ github.head_ref || github.ref_name }}
      cancel-in-progress: false
    runs-on: [self-hosted, tici]
-    outputs:
-      new_branch: ${{ needs.prepare_strategy.outputs.new_branch }}
-      version: ${{ needs.prepare_strategy.outputs.version }}
-      extra_version_identifier: ${{ needs.prepare_strategy.outputs.extra_version_identifier }}
-      commit_sha: ${{ github.sha }}
    if: ${{
      (always() && !cancelled() && !failure()) &&
      needs.prepare_strategy.result == 'success' &&
@@ -124,31 +123,14 @@ jobs:
    steps:
      - uses: actions/checkout@v4
        with:
+          fetch-depth: 1
          submodules: recursive
          ref: ${{ env.SOURCE_BRANCH }}
          repository: ${{ github.event.pull_request.head.repo.fork && github.event.pull_request.head.repo.full_name || github.repository }}
      - run: git lfs pull

-      - name: Cache SCons
-        uses: actions/cache@v4
-        with:
-          path: ${{env.SCONS_CACHE_DIR}}
-          key: scons-${{ runner.os }}-${{ runner.arch }}-${{ env.SOURCE_BRANCH }}-${{ github.sha }}
-          # Note: GitHub Actions enforces cache isolation between different build sources (PR builds, workflow dispatches, etc.)
-          #   for security. Only caches from the default branch are shared across all builds. This is by design and cannot be overridden.
-          restore-keys: |
-            scons-${{ runner.os }}-${{ runner.arch }}-${{ env.SOURCE_BRANCH }}
-            scons-${{ runner.os }}-${{ runner.arch }}-${{ env.STAGING_SOURCE_BRANCH }}
-            scons-${{ runner.os }}-${{ runner.arch }}
-
      - name: Set environment variables
-        id: set-env
        run: |
-          echo "new_branch=${{ needs.prepare_strategy.outputs.new_branch }}" >> $GITHUB_OUTPUT
-          echo "version=${{ needs.prepare_strategy.outputs.version }}" >> $GITHUB_OUTPUT
-          echo "extra_version_identifier=${{ needs.prepare_strategy.outputs.extra_version_identifier }}" >> $GITHUB_OUTPUT
-          echo "commit_sha=${{ github.sha }}" >> $GITHUB_OUTPUT
-
          # Set up common environment
          source /etc/profile;
          export UV_PROJECT_ENVIRONMENT=${HOME}/venv
@@ -157,9 +139,6 @@ jobs:
          export VIRTUAL_ENV=$UV_PROJECT_ENVIRONMENT
          uv sync
          printenv >> $GITHUB_ENV
-          if [[ "${{ runner.debug }}" == "1" ]]; then
-            cat $GITHUB_OUTPUT
-          fi

      - name: Setup build environment
        run: |
@@ -168,7 +147,7 @@ jobs:
          echo "Starting build stage..."
          echo "BUILD_DIR: ${BUILD_DIR}"
          echo "CI_DIR: ${CI_DIR}"
-          echo "VERSION: ${{ steps.set-env.outputs.version }}"
+          echo "VERSION: ${{ needs.prepare_strategy.outputs.version }}"
          echo "UV_PROJECT_ENVIRONMENT: ${UV_PROJECT_ENVIRONMENT}"
          echo "VIRTUAL_ENV: ${VIRTUAL_ENV}"
          echo "-------"
@@ -180,61 +159,44 @@ jobs:

      - name: Build Main Project
        run: |
-          export PYTHONPATH="$BUILD_DIR"
-          ./tools/release/release_files.py | sort | uniq | rsync -rRl${RUNNER_DEBUG:+v} --files-from=- . $BUILD_DIR/
+          export PYTHONPATH="$BUILD_DIR:$BUILD_DIR/msgq_repo:$BUILD_DIR/opendbc_repo:$BUILD_DIR/rednose_repo:$BUILD_DIR/teleoprtc_repo:$BUILD_DIR/tinygrad_repo"
+          ./tools/release/release_files.py | xargs -0 cp -pR --parents -t "$BUILD_DIR" --
+          # outside the checkout, which is wiped each run. /data/scons_cache is the device's, not ours.
+          SCONS_CACHE="$RUNNER_WORKSPACE/scons_cache"
+          mkdir -p "$SCONS_CACHE"
          cd $BUILD_DIR
-          ln -sfn msgq_repo/msgq msgq
-          ln -sfn opendbc_repo/opendbc opendbc
-          ln -sfn rednose_repo/rednose rednose
-          ln -sfn teleoprtc_repo/teleoprtc teleoprtc
-          ln -sfn tinygrad_repo/tinygrad tinygrad
-          sed -i '/from .board.jungle import PandaJungle, PandaJungleDFU/s/^/#/' panda/__init__.py
-          echo "Building sunnypilot's modeld_v2..."
-          scons -j$(nproc) cache_dir=${{env.SCONS_CACHE_DIR}} --minimal openpilot/sunnypilot/modeld_v2
-          echo "Building sunnypilot's locationd..."
-          scons -j2 cache_dir=${{env.SCONS_CACHE_DIR}} --minimal openpilot/sunnypilot/selfdrive/locationd
-          echo "Building openpilot's locationd..."
-          scons -j1 cache_dir=${{env.SCONS_CACHE_DIR}} --minimal openpilot/selfdrive/locationd
+          echo "Building locationd..."
+          # -j1: parallel rednose generators OOM the device
+          scons -j1 cache_dir="$SCONS_CACHE" --minimal \
+            openpilot/selfdrive/locationd openpilot/sunnypilot/selfdrive/locationd
          echo "Building rest of sunnypilot"
-          scons -j$(nproc) cache_dir=${{env.SCONS_CACHE_DIR}} --minimal
+          SKIP_TINYGRAD_COMPILE=1 /usr/bin/time -v scons -j$(nproc) cache_dir="$SCONS_CACHE" --minimal
          touch ${BUILD_DIR}/prebuilt
          if [[ "${{ runner.debug }}" == "1" ]]; then
            ls -la ${BUILD_DIR}
          fi

-      - name: Prepare Output
+      - name: Strip release tree
        run: |
-          sudo rm -rf ${OUTPUT_DIR}
-          mkdir -p ${OUTPUT_DIR}
-          rsync -am${RUNNER_DEBUG:+v} \
-            --exclude='.sconsign.dblite' \
-            --exclude='*.a' \
-            --exclude='*.o' \
-            --exclude='*.os' \
-            --exclude='*.pyc' \
-            --exclude='moc_*' \
-            --exclude='__pycache__' \
-            --exclude='Jenkinsfile' \
-            --exclude='**/release/' \
-            --exclude='**/.github/' \
-            --exclude='**/openpilot/selfdrive/ui/replay/' \
-            --exclude='**/__pycache__/' \
-            --exclude='${{env.SCONS_CACHE_DIR}}' \
-            --exclude='**/.git/' \
-            --exclude='**/SConstruct' \
-            --exclude='**/SConscript' \
-            --exclude='**/.venv/' \
-            --exclude='openpilot/selfdrive/modeld/models/*.onnx*' \
-            --exclude='openpilot/sunnypilot/modeld*/models/*.onnx*' \
-            --exclude='openpilot/third_party/*x86*' \
-            --exclude='openpilot/third_party/*Darwin*' \
-            --delete-excluded \
-            --chown=comma:comma \
-            ${BUILD_DIR}/ ${OUTPUT_DIR}/
+          cd $BUILD_DIR
+          find . -name '*.a' -delete
+          find . -name '*.o' -delete
+          find . -name '*.os' -delete
+          find . -name '*.pyc' -delete
+          find . -name 'moc_*' -delete
+          find . -name '__pycache__' -type d -exec rm -rf {} +
+          find . -name 'SConstruct' -delete
+          find . -name 'SConscript' -delete
+          rm -rf .sconsign.dblite Jenkinsfile tools/release/ release/
+          rm -f openpilot/selfdrive/modeld/models/*.onnx*
+          rm -f openpilot/sunnypilot/modeld*/models/*.onnx*
+          find openpilot/third_party/ -name '*x86*' -exec rm -r {} +
+          find openpilot/third_party/ -name '*Darwin*' -exec rm -r {} +
+          cd -

      - name: 'Tar.gz files'
        run: |
-          tar czf prebuilt.tar.gz -C ${{ env.OUTPUT_DIR }} .
+          tar czf prebuilt.tar.gz -C ${{ env.BUILD_DIR }} .
          ls -la prebuilt.tar.gz

      - name: 'Upload Artifact'
@@ -242,6 +204,7 @@ jobs:
        with:
          name: prebuilt
          path: prebuilt.tar.gz
+          compression-level: 0

      - name: Re-enable powersave
        if: always()
@@ -249,22 +212,212 @@ jobs:
          source ${UV_PROJECT_ENVIRONMENT}/bin/activate
          PYTHONPATH=$PYTHONPATH:${{ github.workspace }}/ ${{ github.workspace }}/scripts/manage-powersave.py --enable

+  prepare_chestnut:
+    needs: [ prepare_strategy ]
+    runs-on: ubuntu-24.04
+    if: ${{ needs.prepare_strategy.outputs.include_big_model == 'true' }}
+    outputs:
+      onnx_sha256: ${{ steps.resolve.outputs.onnx_sha256 }}
+    env:
+      GH_REPO: ${{ github.repository }}
+      HF_REPO: sunnypilot/sunnypilot_models_v1
+      HF_DEFAULTS_PATH: models/defaults/big
+    steps:
+      - name: Resolve ONNX hash and tinygrad ref via API
+        id: resolve
+        run: |
+          REF="${{ github.head_ref || github.ref_name }}"
+
+          ONNX_HASH=$(gh api "repos/${GH_REPO}/contents/openpilot/selfdrive/modeld/models/big_driving_supercombo.onnx?ref=${REF}" --jq '.content' | base64 -d | grep '^oid sha256:' | cut -d: -f2)
+          echo "ONNX hash: $ONNX_HASH"
+          echo "onnx_sha256=$ONNX_HASH" >> $GITHUB_OUTPUT
+
+          TINYGRAD_REF=$(gh api "repos/${GH_REPO}/contents/tinygrad_repo?ref=${REF}" --jq '.sha')
+          echo "tinygrad ref: $TINYGRAD_REF"
+
+          JSON_URL="https://huggingface.co/datasets/${HF_REPO}/resolve/main/${HF_DEFAULTS_PATH}/default_models.json"
+
+          check_defaults() {
+            DEFAULTS=$(curl -fsSL "$JSON_URL" 2>/dev/null) || return 1
+            TINYGRAD_MATCH=$(echo "$DEFAULTS" | jq -r --arg ref "$TINYGRAD_REF" '.tinygrad_ref == $ref' 2>/dev/null)
+            [ "$TINYGRAD_MATCH" = "true" ] || return 1
+            BUNDLE=$(echo "$DEFAULTS" | jq --arg hash "$ONNX_HASH" '.bundles[] | select(.onnx_sha256 == $hash)' 2>/dev/null)
+            [ -n "$BUNDLE" ] && [ "$BUNDLE" != "null" ]
+          }
+
+          if check_defaults; then
+            echo "HF defaults match repo ONNX hash and tinygrad ref"
+            exit 0
+          fi
+
+          echo "No matching model on HF — dispatching build"
+          gh workflow run build-default-models.yaml --ref "$REF" -f target=big
+
+          echo "Polling HF for big model availability..."
+          for i in $(seq 1 90); do
+            sleep 30
+            if check_defaults; then
+              echo "Big model available on HF after $((i * 30))s"
+              exit 0
+            fi
+            echo "Poll $i/90: not yet available"
+          done
+
+          echo "::error::Big model not available on HF after 45 minutes"
+          exit 1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Cancel run on failure
+        if: failure()
+        run: gh run cancel ${{ github.run_id }}
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+  prepare_small_model:
+    needs: [ prepare_strategy ]
+    runs-on: ubuntu-24.04
+    outputs:
+      driving_onnx_sha256: ${{ steps.resolve.outputs.driving_onnx_sha256 }}
+    env:
+      GH_REPO: ${{ github.repository }}
+      HF_REPO: sunnypilot/sunnypilot_models_v1
+      HF_DEFAULTS_PATH: models/defaults/small
+    steps:
+      - name: Resolve ONNX hash and tinygrad ref via API
+        id: resolve
+        run: |
+          REF="${{ github.head_ref || github.ref_name }}"
+
+          DRIVING_HASH=$(gh api "repos/${GH_REPO}/contents/openpilot/selfdrive/modeld/models/driving_supercombo.onnx?ref=${REF}" --jq '.content' | base64 -d | grep '^oid sha256:' | cut -d: -f2)
+          echo "Driving ONNX hash: $DRIVING_HASH"
+          echo "driving_onnx_sha256=$DRIVING_HASH" >> $GITHUB_OUTPUT
+
+          TINYGRAD_REF=$(gh api "repos/${GH_REPO}/contents/tinygrad_repo?ref=${REF}" --jq '.sha')
+          echo "tinygrad ref: $TINYGRAD_REF"
+
+          JSON_URL="https://huggingface.co/datasets/${HF_REPO}/resolve/main/${HF_DEFAULTS_PATH}/default_models.json"
+
+          check_defaults() {
+            DEFAULTS=$(curl -fsSL "$JSON_URL" 2>/dev/null) || return 1
+            TINYGRAD_MATCH=$(echo "$DEFAULTS" | jq -r --arg ref "$TINYGRAD_REF" '.tinygrad_ref == $ref' 2>/dev/null)
+            [ "$TINYGRAD_MATCH" = "true" ] || return 1
+            DRIVING=$(echo "$DEFAULTS" | jq --arg hash "$DRIVING_HASH" '.bundles[] | select(.onnx_sha256 == $hash)' 2>/dev/null)
+            [ -n "$DRIVING" ] && [ "$DRIVING" != "null" ] || return 1
+          }
+
+          if check_defaults; then
+            echo "HF defaults match repo ONNX hash and tinygrad ref"
+            exit 0
+          fi
+
+          echo "No matching model on HF — dispatching build"
+          gh workflow run build-default-models.yaml --ref "$REF" -f target=small
+
+          echo "Polling HF for model availability..."
+          for i in $(seq 1 60); do
+            sleep 30
+            if check_defaults; then
+              echo "Model available on HF after $((i * 30))s"
+              exit 0
+            fi
+            echo "Poll $i/60: not yet available"
+          done
+
+          echo "::error::Small driving model not available on HF after 30 minutes"
+          exit 1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Cancel run on failure
+        if: failure()
+        run: gh run cancel ${{ github.run_id }}
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+  prepare_dm_model:
+    needs: [ prepare_strategy ]
+    runs-on: ubuntu-24.04
+    outputs:
+      dm_onnx_sha256: ${{ steps.resolve.outputs.dm_onnx_sha256 }}
+    env:
+      GH_REPO: ${{ github.repository }}
+      HF_REPO: sunnypilot/sunnypilot_models_v1
+      HF_DEFAULTS_PATH: models/defaults/dm
+    steps:
+      - name: Resolve ONNX hash and tinygrad ref via API
+        id: resolve
+        run: |
+          REF="${{ github.head_ref || github.ref_name }}"
+
+          DM_HASH=$(gh api "repos/${GH_REPO}/contents/openpilot/selfdrive/modeld/models/dmonitoring_model.onnx?ref=${REF}" --jq '.content' | base64 -d | grep '^oid sha256:' | cut -d: -f2)
+          echo "DM ONNX hash: $DM_HASH"
+          echo "dm_onnx_sha256=$DM_HASH" >> $GITHUB_OUTPUT
+
+          TINYGRAD_REF=$(gh api "repos/${GH_REPO}/contents/tinygrad_repo?ref=${REF}" --jq '.sha')
+          echo "tinygrad ref: $TINYGRAD_REF"
+
+          JSON_URL="https://huggingface.co/datasets/${HF_REPO}/resolve/main/${HF_DEFAULTS_PATH}/default_models.json"
+
+          check_defaults() {
+            DEFAULTS=$(curl -fsSL "$JSON_URL" 2>/dev/null) || return 1
+            TINYGRAD_MATCH=$(echo "$DEFAULTS" | jq -r --arg ref "$TINYGRAD_REF" '.tinygrad_ref == $ref' 2>/dev/null)
+            [ "$TINYGRAD_MATCH" = "true" ] || return 1
+            DM=$(echo "$DEFAULTS" | jq --arg hash "$DM_HASH" '.bundles[] | select(.onnx_sha256 == $hash)' 2>/dev/null)
+            [ -n "$DM" ] && [ "$DM" != "null" ] || return 1
+          }
+
+          if check_defaults; then
+            echo "HF defaults match DM ONNX hash and tinygrad ref"
+            exit 0
+          fi
+
+          echo "No matching DM model on HF — dispatching build"
+          gh workflow run build-default-models.yaml --ref "$REF" -f target=dm
+
+          echo "Polling HF for DM model availability..."
+          for i in $(seq 1 60); do
+            sleep 30
+            if check_defaults; then
+              echo "DM model available on HF after $((i * 30))s"
+              exit 0
+            fi
+            echo "Poll $i/60: not yet available"
+          done
+
+          echo "::error::DM model not available on HF after 30 minutes"
+          exit 1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Cancel run on failure
+        if: failure()
+        run: gh run cancel ${{ github.run_id }}
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

  publish:
    concurrency:
-      # We do a bit of a hack here to avoid canceling the publishing job if a new commit comes in while we're publishing by adding the sha to the group name.
-      # This means that if multiple commits come in while we're publishing, they will be queued up and publish one after the other.
-      # Otherwise, if a job is waiting to be published due to environment wait time, it would be canceled by a new commit and restart the wait time.
      group: ${{ needs.prepare_strategy.outputs.publish_concurrency_group }}
      cancel-in-progress: ${{ needs.prepare_strategy.outputs.cancel_publish_in_progress == 'true' }}
-    if: ${{ (always() && !cancelled() && !failure()) && needs.build.result == 'success' && needs.prepare_strategy.result == 'success' && (!contains(github.event_name, 'pull_request') || (github.event.action == 'labeled' && github.event.label.name == 'prebuilt')) }}
-    needs: [ build, prepare_strategy ]
+    if: ${{
+      always() && !cancelled() &&
+      needs.build.result == 'success' &&
+      needs.prepare_strategy.result == 'success' &&
+      needs.prepare_small_model.result == 'success' &&
+      needs.prepare_dm_model.result == 'success' &&
+      (!contains(github.event_name, 'pull_request') || (github.event.action == 'labeled' && github.event.label.name == 'prebuilt')) &&
+      (needs.prepare_strategy.outputs.include_big_model != 'true' || needs.prepare_chestnut.result == 'success')
+      }}
+    needs: [ build, prepare_strategy, prepare_chestnut, prepare_small_model, prepare_dm_model ]
    runs-on: ubuntu-24.04
    environment: ${{ needs.prepare_strategy.outputs.environment }}
    steps:
      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 1

-      - name: Download build artifacts
+      - name: Download prebuilt artifact
        uses: actions/download-artifact@v4
        with:
          name: prebuilt
@@ -274,6 +427,17 @@ jobs:
          mkdir -p ${{ env.OUTPUT_DIR }}
          tar xzf prebuilt.tar.gz -C ${{ env.OUTPUT_DIR }}

+      - name: Download model chunks from HF
+        uses: ./.github/workflows/download-hf-model-chunks
+        with:
+          hf_repo: sunnypilot/sunnypilot_models_v1
+          dest_dir: ${{ env.OUTPUT_DIR }}/openpilot/selfdrive/modeld/models
+          models: |
+            [
+              {"hf_path": "models/defaults/small", "onnx_hash": "${{ needs.prepare_small_model.outputs.driving_onnx_sha256 }}", "canonical": "driving_tinygrad.pkl"},
+              {"hf_path": "models/defaults/dm", "onnx_hash": "${{ needs.prepare_dm_model.outputs.dm_onnx_sha256 }}", "canonical": "dmonitoring_model_tinygrad.pkl"}
+            ]
+
      - name: Configure Git
        run: |
          git config --global user.email "github-actions[bot]@users.noreply.github.com"
@@ -283,36 +447,95 @@ jobs:
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        run: |
-          echo '${{ toJSON(needs.build.outputs) }}'
+          echo '${{ toJSON(needs.prepare_strategy.outputs) }}'
          ls -la ${{ env.OUTPUT_DIR }}

          ${{ env.CI_DIR }}/publish.sh \
            "${{ github.workspace }}" \
            "${{ env.OUTPUT_DIR }}" \
-            "${{ needs.build.outputs.new_branch }}" \
-            "${{ needs.build.outputs.version }}" \
+            "${{ needs.prepare_strategy.outputs.new_branch }}" \
+            "${{ needs.prepare_strategy.outputs.version }}" \
            "https://x-access-token:${{github.token}}@github.com/sunnypilot/sunnypilot.git" \
-            "${{ needs.build.outputs.extra_version_identifier }}"
-
-          echo ""
-          echo "----   ℹ️ To update the list of branches that auto deploy prebuilts  -----"
-          echo ""
-          echo "1. Go to: ${{ github.server_url }}/${{ github.repository }}/settings/variables/actions/AUTO_DEPLOY_PREBUILT_BRANCHES"
-          echo "2. Current value: ${{ vars.AUTO_DEPLOY_PREBUILT_BRANCHES }}"
-          echo "3. Update as needed (JSON array with no spaces)"
+            "${{ needs.prepare_strategy.outputs.extra_version_identifier }}"

      - name: Tag ${{ needs.prepare_strategy.outputs.environment }}
        if: ${{ needs.prepare_strategy.outputs.is_stable_branch == 'true' && (github.event_name != 'push' || !startsWith(github.ref, 'refs/tags/')) }}
        run: |
            TAG="${{ needs.prepare_strategy.outputs.environment }}/${{ needs.prepare_strategy.outputs.version }}/${{ needs.prepare_strategy.outputs.build }}"
-            git tag -f -a ${TAG} -m "${{ needs.prepare_strategy.outputs.environment }} @ ${{ needs.prepare_strategy.outputs.version }} of build ${{ needs.build.outputs.build }}."
+            git tag -f -a ${TAG} -m "${{ needs.prepare_strategy.outputs.environment }} @ ${{ needs.prepare_strategy.outputs.version }} of build ${{ needs.prepare_strategy.outputs.build }}."
            git push -f origin ${TAG}

+  publish_chestnut:
+    concurrency:
+      group: ${{ needs.prepare_strategy.outputs.publish_concurrency_group }}-chestnut
+      cancel-in-progress: ${{ needs.prepare_strategy.outputs.cancel_publish_in_progress == 'true' }}
+    if: ${{
+      always() && !cancelled() &&
+      needs.build.result == 'success' &&
+      needs.prepare_strategy.result == 'success' &&
+      needs.prepare_small_model.result == 'success' &&
+      needs.prepare_dm_model.result == 'success' &&
+      needs.prepare_chestnut.result == 'success' &&
+      (!contains(github.event_name, 'pull_request') || (github.event.action == 'labeled' && github.event.label.name == 'prebuilt'))
+      }}
+    needs: [ build, prepare_strategy, prepare_chestnut, prepare_small_model, prepare_dm_model ]
+    runs-on: ubuntu-24.04
+    environment: ${{ needs.prepare_strategy.outputs.environment }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+
+      - name: Download prebuilt artifact
+        uses: actions/download-artifact@v4
+        with:
+          name: prebuilt
+
+      - name: Untar prebuilt
+        run: |
+          mkdir -p ${{ env.OUTPUT_DIR }}
+          tar xzf prebuilt.tar.gz -C ${{ env.OUTPUT_DIR }}
+
+      - name: Download model chunks from HF
+        uses: ./.github/workflows/download-hf-model-chunks
+        with:
+          hf_repo: sunnypilot/sunnypilot_models_v1
+          dest_dir: ${{ env.OUTPUT_DIR }}/openpilot/selfdrive/modeld/models
+          models: |
+            [
+              {"hf_path": "models/defaults/small", "onnx_hash": "${{ needs.prepare_small_model.outputs.driving_onnx_sha256 }}", "canonical": "driving_tinygrad.pkl"},
+              {"hf_path": "models/defaults/dm", "onnx_hash": "${{ needs.prepare_dm_model.outputs.dm_onnx_sha256 }}", "canonical": "dmonitoring_model_tinygrad.pkl"},
+              {"hf_path": "models/defaults/big", "onnx_hash": "${{ needs.prepare_chestnut.outputs.onnx_sha256 }}", "canonical": "big_driving_tinygrad.pkl"}
+            ]
+
+      - name: Configure Git
+        run: |
+          git config --global user.email "github-actions[bot]@users.noreply.github.com"
+          git config --global user.name "github-actions[bot]"
+
+      - name: Publish chestnut branch
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          CHESTNUT_BRANCH="${{ needs.prepare_strategy.outputs.new_branch }}-chestnut"
+
+          ${{ env.CI_DIR }}/publish.sh \
+            "${{ github.workspace }}" \
+            "${{ env.OUTPUT_DIR }}" \
+            "$CHESTNUT_BRANCH" \
+            "${{ needs.prepare_strategy.outputs.version }}" \
+            "https://x-access-token:${{github.token}}@github.com/sunnypilot/sunnypilot.git" \
+            "${{ needs.prepare_strategy.outputs.extra_version_identifier }}"
+
  notify:
    needs:
    - prepare_strategy
    - build
    - publish
+    - publish_chestnut
+    - prepare_chestnut
+    - prepare_small_model
+    - prepare_dm_model
    runs-on: ubuntu-24.04
    if: ${{ (always() && !cancelled() && !failure())
      && needs.publish.result == 'success'
@@ -320,11 +543,12 @@ jobs:
      && (fromJSON(vars.DEV_FEEDBACK_NOTIFICATION_BRANCHES_V2)[github.head_ref || github.ref_name] != null) }}
    steps:
      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 1

      - name: Prepare notification message
        id: message
        run: |
-          TEMPLATE='${{ vars.DISCOURSE_GENERAL_UPDATE_NOTICE }}'
          export VERSION="${{ needs.prepare_strategy.outputs.version }}"
          export branch_name="${{ env.SOURCE_BRANCH }}"
          export new_branch="${{ needs.prepare_strategy.outputs.new_branch }}"
@@ -333,6 +557,7 @@ jobs:
          export commit_short_sha="${commit_short_sha:0:7}"
          export extra_version_identifier="${{ needs.prepare_strategy.outputs.extra_version_identifier || github.run_number }}"
          export PUBLIC_REPO_URL="${{ env.PUBLIC_REPO_URL }}"
+          export chestnut_branch="${{ needs.prepare_chestnut.result == 'success' && format('{0}-chestnut', needs.prepare_strategy.outputs.new_branch) || '' }}"

          MESSAGE=$(cat << 'EOF' | envsubst
          ${{ vars.DISCOURSE_GENERAL_UPDATE_NOTICE }}
@@ -373,7 +598,7 @@ jobs:
              owner: context.repo.owner,
              repo: context.repo.repo,
              issue_number: prNumber,
-              name: process.env.LABELf
+              name: process.env.LABEL
            });

            console.log(`Removed '${process.env.LABEL}' label from PR #${prNumber}`);
@@ -25,7 +25,8 @@ env:

 jobs:
  preview:
-    if: github.repository == 'sunnypilot/sunnypilot'
+    if: false # tmp disable due to GH API rate limiting flakiness
+    #if: github.repository == 'sunnypilot/sunnypilot'
    name: preview
    runs-on: ubuntu-latest
    timeout-minutes: 20
@@ -22,6 +22,7 @@ shopt -s huponexit # kill all child processes when the shell exits

 export CI=1
 export PYTHONWARNINGS=error
+export COMMA_CACHE=/data/tmp/comma_download_cache
 #export LOGPRINT=debug # this has gotten too spammy...
 export TEST_DIR=${env.TEST_DIR}
 export SOURCE_DIR=${env.SOURCE_DIR}
@@ -4,7 +4,7 @@

 A supported vehicle is one that just works when you install a comma device. All supported cars provide a better experience than any stock system. Supported vehicles reference the US market unless otherwise specified.

-# 342 Supported Cars
+# 345 Supported Cars

 |Make|Model|Supported Package|ACC|No ACC accel below|No ALC below|Steering Torque|Resume from stop|<a href="##"><img width=2000></a>Hardware Needed<br>&nbsp;|Video|Setup Video|
 |---|---|---|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
@@ -34,6 +34,7 @@ A supported vehicle is one that just works when you install a comma device. All
 |Chrysler|Pacifica Hybrid 2019-25|Adaptive Cruise Control (ACC)|Stock|0 mph|39 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 FCA connector<br>- 1 OBD-C cable (2 ft)<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Chrysler Pacifica Hybrid 2019-25">Buy Here</a></sub></details>|||
 |comma|body|All|openpilot|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|None|<a href="https://youtu.be/VT-i3yRsX2s?t=2736" target="_blank"><img height="18px" src="assets/icon-youtube.svg" /></a>||
 |CUPRA[<sup>12</sup>](#footnotes)|Ateca 2018-23|Adaptive Cruise Control (ACC) & Lane Assist|openpilot available[<sup>1,16</sup>](#footnotes)|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 VW J533 connector<br>- 1 comma four<br>- 1 harness box<br>- 1 long OBD-C cable (9.5 ft)<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=CUPRA Ateca 2018-23">Buy Here</a></sub></details>|||
+|CUPRA[<sup>12</sup>](#footnotes)|Born 2021-23|Adaptive Cruise Control (ACC) & Lane Assist|openpilot[<sup>16</sup>](#footnotes)|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 VW J533 connector<br>- 1 comma four<br>- 1 harness box<br>- 1 long OBD-C cable (9.5 ft)<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=CUPRA Born 2021-23">Buy Here</a></sub></details>|||
 |Dodge|Durango 2020-21|Adaptive Cruise Control (ACC)|Stock|0 mph|39 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 FCA connector<br>- 1 OBD-C cable (2 ft)<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Dodge Durango 2020-21">Buy Here</a></sub></details>|||
 |Ford|Bronco Sport 2021-24|Co-Pilot360 Assist+|openpilot|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 Ford Q3 connector<br>- 1 OBD-C cable (2 ft)<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Ford Bronco Sport 2021-24">Buy Here</a></sub></details>|||
 |Ford|Escape 2020-22|Co-Pilot360 Assist+|openpilot|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 Ford Q3 connector<br>- 1 OBD-C cable (2 ft)<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Ford Escape 2020-22">Buy Here</a></sub></details>|||
@@ -82,7 +83,7 @@ A supported vehicle is one that just works when you install a comma device. All
 |Honda|City (Brazil only) 2023-25|All|openpilot available[<sup>1,5</sup>](#footnotes)|0 mph|14 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 Honda Bosch B connector<br>- 1 OBD-C cable (2 ft)<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Honda City (Brazil only) 2023-25">Buy Here</a></sub></details>|||
 |Honda|Civic 2016-18|Honda Sensing|openpilot|0 mph|12 mph|[![star](assets/icon-star-empty.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 Honda Nidec connector<br>- 1 OBD-C cable (2 ft)<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Honda Civic 2016-18">Buy Here</a></sub></details>|<a href="https://youtu.be/-IkImTe1NYE" target="_blank"><img height="18px" src="assets/icon-youtube.svg" /></a>||
 |Honda|Civic 2019-21|All|openpilot available[<sup>1,5</sup>](#footnotes)|0 mph|2 mph[<sup>4</sup>](#footnotes)|[![star](assets/icon-star-empty.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 Honda Bosch A connector<br>- 1 OBD-C cable (2 ft)<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Honda Civic 2019-21">Buy Here</a></sub></details>|<a href="https://www.youtube.com/watch?v=4Iz1Mz5LGF8" target="_blank"><img height="18px" src="assets/icon-youtube.svg" /></a>||
-|Honda|Civic 2022-24|All|openpilot available[<sup>1,5</sup>](#footnotes)|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 Honda Bosch B connector<br>- 1 OBD-C cable (2 ft)<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Honda Civic 2022-24">Buy Here</a></sub></details>|<a href="https://youtu.be/ytiOT5lcp6Q" target="_blank"><img height="18px" src="assets/icon-youtube.svg" /></a>||
+|Honda|Civic 2022-26|All|openpilot available[<sup>1,5</sup>](#footnotes)|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 Honda Bosch B connector<br>- 1 OBD-C cable (2 ft)<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Honda Civic 2022-26">Buy Here</a></sub></details>|<a href="https://youtu.be/ytiOT5lcp6Q" target="_blank"><img height="18px" src="assets/icon-youtube.svg" /></a>||
 |Honda|Civic Hatchback 2017-18|Honda Sensing|openpilot available[<sup>1,5</sup>](#footnotes)|0 mph|12 mph|[![star](assets/icon-star-empty.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 Honda Bosch A connector<br>- 1 OBD-C cable (2 ft)<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Honda Civic Hatchback 2017-18">Buy Here</a></sub></details>|||
 |Honda|Civic Hatchback 2019-21|All|openpilot available[<sup>1,5</sup>](#footnotes)|0 mph|12 mph|[![star](assets/icon-star-empty.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 Honda Bosch A connector<br>- 1 OBD-C cable (2 ft)<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Honda Civic Hatchback 2019-21">Buy Here</a></sub></details>|||
 |Honda|Civic Hatchback 2022-24|All|openpilot available[<sup>1,5</sup>](#footnotes)|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 Honda Bosch B connector<br>- 1 OBD-C cable (2 ft)<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Honda Civic Hatchback 2022-24">Buy Here</a></sub></details>|<a href="https://youtu.be/ytiOT5lcp6Q" target="_blank"><img height="18px" src="assets/icon-youtube.svg" /></a>||
@@ -158,7 +159,7 @@ A supported vehicle is one that just works when you install a comma device. All
 |Hyundai|Tucson Plug-in Hybrid 2024|All|openpilot available[<sup>1</sup>](#footnotes)|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 Hyundai N connector<br>- 1 OBD-C cable (2 ft)<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Hyundai Tucson Plug-in Hybrid 2024">Buy Here</a></sub></details>|||
 |Hyundai|Veloster 2019-20|Smart Cruise Control (SCC)|Stock|5 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-empty.svg)](##)|<details><summary>Parts</summary><sub>- 1 Hyundai E connector<br>- 1 OBD-C cable (2 ft)<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Hyundai Veloster 2019-20">Buy Here</a></sub></details>|||
 |Jeep|Grand Cherokee 2016-18|Adaptive Cruise Control (ACC)|Stock|0 mph|9 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 FCA connector<br>- 1 OBD-C cable (2 ft)<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Jeep Grand Cherokee 2016-18">Buy Here</a></sub></details>|<a href="https://www.youtube.com/watch?v=eLR9o2JkuRk" target="_blank"><img height="18px" src="assets/icon-youtube.svg" /></a>||
-|Jeep|Grand Cherokee 2019-21|Adaptive Cruise Control (ACC)|Stock|0 mph|39 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 FCA connector<br>- 1 OBD-C cable (2 ft)<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Jeep Grand Cherokee 2019-21">Buy Here</a></sub></details>|<a href="https://www.youtube.com/watch?v=jBe4lWnRSu4" target="_blank"><img height="18px" src="assets/icon-youtube.svg" /></a>||
+|Jeep|Grand Cherokee 2019-21|Adaptive Cruise Control (ACC)|Stock|0 mph|39 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 FCA connector<br>- 1 OBD-C cable (2 ft)<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Jeep Grand Cherokee 2019-21">Buy Here</a></sub></details>|||
 |Kia|Carnival 2022-24|Smart Cruise Control (SCC)|openpilot available[<sup>1</sup>](#footnotes)|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 Hyundai A connector<br>- 1 OBD-C cable (2 ft)<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Kia Carnival 2022-24">Buy Here</a></sub></details>|||
 |Kia|Carnival (China only) 2023|Smart Cruise Control (SCC)|openpilot available[<sup>1</sup>](#footnotes)|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 Hyundai K connector<br>- 1 OBD-C cable (2 ft)<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Kia Carnival (China only) 2023">Buy Here</a></sub></details>|||
 |Kia|Ceed 2019-21|Smart Cruise Control (SCC)|Stock|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 Hyundai E connector<br>- 1 OBD-C cable (2 ft)<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Kia Ceed 2019-21">Buy Here</a></sub></details>|||
@@ -242,20 +243,20 @@ A supported vehicle is one that just works when you install a comma device. All
 |Rivian|R1T 2025|All|openpilot|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 Rivian B connector<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 long OBD-C cable (9.5 ft)<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Rivian R1T 2025">Buy Here</a></sub></details>|||
 |SEAT[<sup>12</sup>](#footnotes)|Ateca 2016-23|Adaptive Cruise Control (ACC) & Lane Assist|openpilot available[<sup>1,16</sup>](#footnotes)|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 VW J533 connector<br>- 1 comma four<br>- 1 harness box<br>- 1 long OBD-C cable (9.5 ft)<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=SEAT Ateca 2016-23">Buy Here</a></sub></details>|||
 |SEAT[<sup>12</sup>](#footnotes)|Leon 2014-20|Adaptive Cruise Control (ACC) & Lane Assist|openpilot available[<sup>1,16</sup>](#footnotes)|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 VW J533 connector<br>- 1 comma four<br>- 1 harness box<br>- 1 long OBD-C cable (9.5 ft)<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=SEAT Leon 2014-20">Buy Here</a></sub></details>|||
-|Subaru|Ascent 2019-21|All[<sup>7</sup>](#footnotes)|openpilot available[<sup>1,8</sup>](#footnotes)|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 Subaru A connector<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Subaru Ascent 2019-21">Buy Here</a></sub></details><details><summary>Tools</summary><sub>- 1 Pry Tool<br>- 1 Socket Wrench 8mm or 5/16" (deep)</sub></details>|||
-|Subaru|Crosstrek 2018-19|EyeSight Driver Assistance[<sup>7</sup>](#footnotes)|openpilot available[<sup>1,8</sup>](#footnotes)|0 mph|0 mph|[![star](assets/icon-star-empty.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 Subaru A connector<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Subaru Crosstrek 2018-19">Buy Here</a></sub></details><details><summary>Tools</summary><sub>- 1 Pry Tool<br>- 1 Socket Wrench 8mm or 5/16" (deep)</sub></details>|<a href="https://youtu.be/Agww7oE1k-s?t=26" target="_blank"><img height="18px" src="assets/icon-youtube.svg" /></a>||
-|Subaru|Crosstrek 2020-23|EyeSight Driver Assistance[<sup>7</sup>](#footnotes)|openpilot available[<sup>1,8</sup>](#footnotes)|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 Subaru A connector<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Subaru Crosstrek 2020-23">Buy Here</a></sub></details><details><summary>Tools</summary><sub>- 1 Pry Tool<br>- 1 Socket Wrench 8mm or 5/16" (deep)</sub></details>|||
+|Subaru|Ascent 2019-21|All[<sup>7</sup>](#footnotes)|Stock|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 Subaru A connector<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Subaru Ascent 2019-21">Buy Here</a></sub></details><details><summary>Tools</summary><sub>- 1 Pry Tool<br>- 1 Socket Wrench 8mm or 5/16" (deep)</sub></details>|||
+|Subaru|Crosstrek 2018-19|EyeSight Driver Assistance[<sup>7</sup>](#footnotes)|Stock|0 mph|0 mph|[![star](assets/icon-star-empty.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 Subaru A connector<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Subaru Crosstrek 2018-19">Buy Here</a></sub></details><details><summary>Tools</summary><sub>- 1 Pry Tool<br>- 1 Socket Wrench 8mm or 5/16" (deep)</sub></details>|<a href="https://youtu.be/Agww7oE1k-s?t=26" target="_blank"><img height="18px" src="assets/icon-youtube.svg" /></a>||
+|Subaru|Crosstrek 2020-23|EyeSight Driver Assistance[<sup>7</sup>](#footnotes)|Stock|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 Subaru A connector<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Subaru Crosstrek 2020-23">Buy Here</a></sub></details><details><summary>Tools</summary><sub>- 1 Pry Tool<br>- 1 Socket Wrench 8mm or 5/16" (deep)</sub></details>|||
 |Subaru|Forester 2017-18|EyeSight Driver Assistance[<sup>7</sup>](#footnotes)|Stock|0 mph|0 mph|[![star](assets/icon-star-empty.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 Subaru A connector<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Subaru Forester 2017-18">Buy Here</a></sub></details><details><summary>Tools</summary><sub>- 1 Pry Tool<br>- 1 Socket Wrench 8mm or 5/16" (deep)</sub></details>|||
-|Subaru|Forester 2019-21|All[<sup>7</sup>](#footnotes)|openpilot available[<sup>1,8</sup>](#footnotes)|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 Subaru A connector<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Subaru Forester 2019-21">Buy Here</a></sub></details><details><summary>Tools</summary><sub>- 1 Pry Tool<br>- 1 Socket Wrench 8mm or 5/16" (deep)</sub></details>|||
-|Subaru|Impreza 2017-19|EyeSight Driver Assistance[<sup>7</sup>](#footnotes)|openpilot available[<sup>1,8</sup>](#footnotes)|0 mph|0 mph|[![star](assets/icon-star-empty.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 Subaru A connector<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Subaru Impreza 2017-19">Buy Here</a></sub></details><details><summary>Tools</summary><sub>- 1 Pry Tool<br>- 1 Socket Wrench 8mm or 5/16" (deep)</sub></details>|||
-|Subaru|Impreza 2020-22|EyeSight Driver Assistance[<sup>7</sup>](#footnotes)|openpilot available[<sup>1,8</sup>](#footnotes)|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 Subaru A connector<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Subaru Impreza 2020-22">Buy Here</a></sub></details><details><summary>Tools</summary><sub>- 1 Pry Tool<br>- 1 Socket Wrench 8mm or 5/16" (deep)</sub></details>|||
+|Subaru|Forester 2019-21|All[<sup>7</sup>](#footnotes)|Stock|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 Subaru A connector<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Subaru Forester 2019-21">Buy Here</a></sub></details><details><summary>Tools</summary><sub>- 1 Pry Tool<br>- 1 Socket Wrench 8mm or 5/16" (deep)</sub></details>|||
+|Subaru|Impreza 2017-19|EyeSight Driver Assistance[<sup>7</sup>](#footnotes)|Stock|0 mph|0 mph|[![star](assets/icon-star-empty.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 Subaru A connector<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Subaru Impreza 2017-19">Buy Here</a></sub></details><details><summary>Tools</summary><sub>- 1 Pry Tool<br>- 1 Socket Wrench 8mm or 5/16" (deep)</sub></details>|||
+|Subaru|Impreza 2020-22|EyeSight Driver Assistance[<sup>7</sup>](#footnotes)|Stock|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 Subaru A connector<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Subaru Impreza 2020-22">Buy Here</a></sub></details><details><summary>Tools</summary><sub>- 1 Pry Tool<br>- 1 Socket Wrench 8mm or 5/16" (deep)</sub></details>|||
 |Subaru|Legacy 2015-18|EyeSight Driver Assistance[<sup>7</sup>](#footnotes)|Stock|0 mph|0 mph|[![star](assets/icon-star-empty.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 Subaru A connector<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Subaru Legacy 2015-18">Buy Here</a></sub></details><details><summary>Tools</summary><sub>- 1 Pry Tool<br>- 1 Socket Wrench 8mm or 5/16" (deep)</sub></details>|||
 |Subaru|Legacy 2020-22|All[<sup>7</sup>](#footnotes)|Stock|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-empty.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 Subaru B connector<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Subaru Legacy 2020-22">Buy Here</a></sub></details><details><summary>Tools</summary><sub>- 1 Pry Tool<br>- 1 Socket Wrench 8mm or 5/16" (deep)</sub></details>|||
 |Subaru|Outback 2015-17|EyeSight Driver Assistance[<sup>7</sup>](#footnotes)|Stock|0 mph|0 mph|[![star](assets/icon-star-empty.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 Subaru A connector<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Subaru Outback 2015-17">Buy Here</a></sub></details><details><summary>Tools</summary><sub>- 1 Pry Tool<br>- 1 Socket Wrench 8mm or 5/16" (deep)</sub></details>|||
 |Subaru|Outback 2018-19|EyeSight Driver Assistance[<sup>7</sup>](#footnotes)|Stock|0 mph|0 mph|[![star](assets/icon-star-empty.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 Subaru A connector<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Subaru Outback 2018-19">Buy Here</a></sub></details><details><summary>Tools</summary><sub>- 1 Pry Tool<br>- 1 Socket Wrench 8mm or 5/16" (deep)</sub></details>|||
 |Subaru|Outback 2020-22|All[<sup>7</sup>](#footnotes)|Stock|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-empty.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 Subaru B connector<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Subaru Outback 2020-22">Buy Here</a></sub></details><details><summary>Tools</summary><sub>- 1 Pry Tool<br>- 1 Socket Wrench 8mm or 5/16" (deep)</sub></details>|||
-|Subaru|XV 2018-19|EyeSight Driver Assistance[<sup>7</sup>](#footnotes)|openpilot available[<sup>1,8</sup>](#footnotes)|0 mph|0 mph|[![star](assets/icon-star-empty.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 Subaru A connector<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Subaru XV 2018-19">Buy Here</a></sub></details><details><summary>Tools</summary><sub>- 1 Pry Tool<br>- 1 Socket Wrench 8mm or 5/16" (deep)</sub></details>|<a href="https://youtu.be/Agww7oE1k-s?t=26" target="_blank"><img height="18px" src="assets/icon-youtube.svg" /></a>||
-|Subaru|XV 2020-21|EyeSight Driver Assistance[<sup>7</sup>](#footnotes)|openpilot available[<sup>1,8</sup>](#footnotes)|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 Subaru A connector<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Subaru XV 2020-21">Buy Here</a></sub></details><details><summary>Tools</summary><sub>- 1 Pry Tool<br>- 1 Socket Wrench 8mm or 5/16" (deep)</sub></details>|||
+|Subaru|XV 2018-19|EyeSight Driver Assistance[<sup>7</sup>](#footnotes)|Stock|0 mph|0 mph|[![star](assets/icon-star-empty.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 Subaru A connector<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Subaru XV 2018-19">Buy Here</a></sub></details><details><summary>Tools</summary><sub>- 1 Pry Tool<br>- 1 Socket Wrench 8mm or 5/16" (deep)</sub></details>|<a href="https://youtu.be/Agww7oE1k-s?t=26" target="_blank"><img height="18px" src="assets/icon-youtube.svg" /></a>||
+|Subaru|XV 2020-21|EyeSight Driver Assistance[<sup>7</sup>](#footnotes)|Stock|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 Subaru A connector<br>- 1 comma four<br>- 1 comma power v3<br>- 1 harness box<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Subaru XV 2020-21">Buy Here</a></sub></details><details><summary>Tools</summary><sub>- 1 Pry Tool<br>- 1 Socket Wrench 8mm or 5/16" (deep)</sub></details>|||
 |Škoda|Fabia 2022-23[<sup>15</sup>](#footnotes)|Adaptive Cruise Control (ACC) & Lane Assist|openpilot available[<sup>1,16</sup>](#footnotes)|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 VW J533 connector<br>- 1 comma four<br>- 1 harness box<br>- 1 long OBD-C cable (9.5 ft)<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Škoda Fabia 2022-23">Buy Here</a></sub></details>[<sup>17</sup>](#footnotes)|||
 |Škoda|Kamiq 2021-23[<sup>13,15</sup>](#footnotes)|Adaptive Cruise Control (ACC) & Lane Assist|openpilot available[<sup>1,16</sup>](#footnotes)|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 VW J533 connector<br>- 1 comma four<br>- 1 harness box<br>- 1 long OBD-C cable (9.5 ft)<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Škoda Kamiq 2021-23">Buy Here</a></sub></details>[<sup>17</sup>](#footnotes)|||
 |Škoda[<sup>12</sup>](#footnotes)|Karoq 2019-23[<sup>15</sup>](#footnotes)|Adaptive Cruise Control (ACC) & Lane Assist|openpilot available[<sup>1,16</sup>](#footnotes)|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 VW J533 connector<br>- 1 comma four<br>- 1 harness box<br>- 1 long OBD-C cable (9.5 ft)<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Škoda Karoq 2019-23">Buy Here</a></sub></details>|||
@@ -334,6 +335,8 @@ A supported vehicle is one that just works when you install a comma device. All
 |Volkswagen[<sup>12</sup>](#footnotes)|Golf R 2015-19|Adaptive Cruise Control (ACC) & Lane Assist|openpilot available[<sup>1,16</sup>](#footnotes)|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 VW J533 connector<br>- 1 comma four<br>- 1 harness box<br>- 1 long OBD-C cable (9.5 ft)<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Volkswagen Golf R 2015-19">Buy Here</a></sub></details>|||
 |Volkswagen[<sup>12</sup>](#footnotes)|Golf SportsVan 2015-20|Adaptive Cruise Control (ACC) & Lane Assist|openpilot available[<sup>1,16</sup>](#footnotes)|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 VW J533 connector<br>- 1 comma four<br>- 1 harness box<br>- 1 long OBD-C cable (9.5 ft)<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Volkswagen Golf SportsVan 2015-20">Buy Here</a></sub></details>|||
 |Volkswagen[<sup>12</sup>](#footnotes)|Grand California 2019-24|Adaptive Cruise Control (ACC) & Lane Assist|openpilot available[<sup>1,16</sup>](#footnotes)|0 mph|31 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 VW J533 connector<br>- 1 comma four<br>- 1 harness box<br>- 1 long OBD-C cable (9.5 ft)<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Volkswagen Grand California 2019-24">Buy Here</a></sub></details>|<a href="https://youtu.be/4100gLeabmo" target="_blank"><img height="18px" src="assets/icon-youtube.svg" /></a>||
+|Volkswagen[<sup>12</sup>](#footnotes)|ID.4 2021-23|Adaptive Cruise Control (ACC) & Lane Assist|openpilot[<sup>16</sup>](#footnotes)|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 VW J533 connector<br>- 1 comma four<br>- 1 harness box<br>- 1 long OBD-C cable (9.5 ft)<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Volkswagen ID.4 2021-23">Buy Here</a></sub></details>|||
+|Volkswagen[<sup>12</sup>](#footnotes)|ID.4 2024-25|Adaptive Cruise Control (ACC) & Lane Assist|openpilot[<sup>16</sup>](#footnotes)|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 VW J533 connector<br>- 1 comma four<br>- 1 harness box<br>- 1 long OBD-C cable (9.5 ft)<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Volkswagen ID.4 2024-25">Buy Here</a></sub></details>|||
 |Volkswagen[<sup>12</sup>](#footnotes)|Jetta 2019-23|Adaptive Cruise Control (ACC) & Lane Assist|openpilot available[<sup>1,16</sup>](#footnotes)|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 VW J533 connector<br>- 1 comma four<br>- 1 harness box<br>- 1 long OBD-C cable (9.5 ft)<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Volkswagen Jetta 2019-23">Buy Here</a></sub></details>|||
 |Volkswagen[<sup>12</sup>](#footnotes)|Jetta GLI 2021-23|Adaptive Cruise Control (ACC) & Lane Assist|openpilot available[<sup>1,16</sup>](#footnotes)|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 VW J533 connector<br>- 1 comma four<br>- 1 harness box<br>- 1 long OBD-C cable (9.5 ft)<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Volkswagen Jetta GLI 2021-23">Buy Here</a></sub></details>|||
 |Volkswagen|Passat 2015-22[<sup>14</sup>](#footnotes)|Adaptive Cruise Control (ACC) & Lane Assist|openpilot available[<sup>1,16</sup>](#footnotes)|0 mph|0 mph|[![star](assets/icon-star-full.svg)](##)|[![star](assets/icon-star-full.svg)](##)|<details><summary>Parts</summary><sub>- 1 OBD-C cable (2 ft)<br>- 1 VW J533 connector<br>- 1 comma four<br>- 1 harness box<br>- 1 long OBD-C cable (9.5 ft)<br>- 1 mount<br><a href="https://comma.ai/shop/comma-3x?harness=Volkswagen Passat 2015-22">Buy Here</a></sub></details>|||
@@ -24,7 +24,9 @@ function agnos_init {
    if $AGNOS_PY --verify $MANIFEST; then
      sudo reboot
    fi
-    $DIR/openpilot/common/hardware/comma/updater $AGNOS_PY $MANIFEST
+    while true; do
+      $DIR/openpilot/common/hardware/comma/updater $AGNOS_PY $MANIFEST
+    done
  fi
 }

@@ -131,6 +131,7 @@ struct ModelManagerSP @0xaedffd8f31e7b55d {
    downloaded @2;
    cached @3;
    failed @4;
+    verifying @5;
  }

  struct DownloadProgress {
@@ -352,6 +353,7 @@ struct OnroadEventSP @0xda96579883444c35 {
    speedLimitPending @22;
    e2eChime @23;
    laneChangeRoadEdge @24;
+    bigModelReady @25;
  }
 }

@@ -15,7 +15,7 @@ public:

  static std::string get_serial() { return "cccccc"; }

-  static std::map<std::string, std::string> get_init_logs() {
+  static std::map<std::string, std::string> get_init_logs(bool route_log = false) {
    return {};
  }

@@ -59,7 +59,7 @@ public:
    std::ofstream("/sys/class/leds/led:switch_2/brightness") << value << "\n";
  }

-  static std::map<std::string, std::string> get_init_logs() {
+  static std::map<std::string, std::string> get_init_logs(bool route_log = false) {
    std::map<std::string, std::string> ret = {
      {"/BUILD", util::read_file("/BUILD")},
      {"lsblk", util::check_output("lsblk -o NAME,SIZE,STATE,VENDOR,MODEL,REV,SERIAL")},
@@ -73,12 +73,14 @@ public:
    temp.erase(temp.find_last_not_of(std::string("\0\r\n", 3))+1);
    ret["boot temp"] = temp;

-    // TODO: log something from system and boot
-    for (std::string part : {"xbl", "abl", "aop", "devcfg", "xbl_config"}) {
-      for (std::string slot : {"a", "b"}) {
-        std::string partition = part + "_" + slot;
-        std::string hash = util::check_output("sha256sum /dev/disk/by-partlabel/" + partition);
-        ret[partition] = hash.substr(0, hash.find_first_of(" "));
+    // TODO: these are too slow to do on route log inits. need to do it async?
+    if (!route_log) {
+      for (std::string part : {"xbl", "abl", "aop", "devcfg", "xbl_config"}) {
+        for (std::string slot : {"a", "b"}) {
+          std::string partition = part + "_" + slot;
+          std::string hash = util::check_output("sha256sum /dev/disk/by-partlabel/" + partition);
+          ret[partition] = hash.substr(0, hash.find_first_of(" "));
+        }
      }
    }

@@ -59,7 +59,7 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
    {"IsDriverViewEnabled", {CLEAR_ON_MANAGER_START, BOOL}},
    {"IsEngaged", {PERSISTENT, BOOL}},
    {"IsLdwEnabled", {PERSISTENT | BACKUP, BOOL}},
-    {"IsLiveStreaming", {CLEAR_ON_MANAGER_START, BOOL}},
+    {"IsLiveStreaming", {CLEAR_ON_MANAGER_START | CLEAR_ON_IGNITION_ON, BOOL}},
    {"IsMetric", {PERSISTENT | BACKUP, BOOL}},
    {"IsOffroad", {CLEAR_ON_MANAGER_START, BOOL}},
    {"IsRhdDetected", {PERSISTENT, BOOL}},
@@ -91,10 +91,10 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
    {"ObdMultiplexingChanged", {CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION, BOOL}},
    {"ObdMultiplexingEnabled", {CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION, BOOL}},
    {"Offroad_CarUnrecognized", {CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION, JSON}},
+    {"Offroad_ChestnutBranch", {CLEAR_ON_MANAGER_START, JSON}},
    {"Offroad_ConnectivityNeeded", {CLEAR_ON_MANAGER_START, JSON}},
    {"Offroad_ConnectivityNeededPrompt", {CLEAR_ON_MANAGER_START, JSON}},
    {"Offroad_ExcessiveActuation", {PERSISTENT, JSON}},
-    {"Offroad_NeosUpdate", {CLEAR_ON_MANAGER_START, JSON}},
    {"Offroad_NoFirmware", {CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION, JSON}},
    {"Offroad_Recalibration", {CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION, JSON}},
    {"Offroad_TemperatureTooHigh", {CLEAR_ON_MANAGER_START, JSON}},
@@ -186,7 +186,6 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
    {"ShowTurnSignals", {PERSISTENT | BACKUP, BOOL, "0"}},
    {"StandstillTimer", {PERSISTENT | BACKUP, BOOL, "0"}},
    {"TrueVEgoUI", {PERSISTENT | BACKUP, BOOL, "0"}},
-    {"CustomButtonAction", {PERSISTENT | BACKUP, INT, "0"}},

    // MADS params
    {"Mads", {PERSISTENT | BACKUP, BOOL, "1"}},
@@ -196,11 +195,15 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {

    // Model Manager params
    {"ModelManager_ActiveBundle", {PERSISTENT, JSON}},
+    {"ModelManager_ActiveBundleUSBGPU", {PERSISTENT, JSON}},
+    {"ModelManager_ActiveJson", {CLEAR_ON_MANAGER_START, JSON}},
    {"ModelManager_ClearCache", {CLEAR_ON_MANAGER_START, BOOL}},
-    {"ModelManager_DownloadIndex", {CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION, INT}},
+    {"ModelManager_DownloadRef", {CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION, STRING}},
    {"ModelManager_Favs", {PERSISTENT | BACKUP, STRING}},
    {"ModelManager_LastSyncTime", {CLEAR_ON_MANAGER_START | CLEAR_ON_OFFROAD_TRANSITION, INT, "0"}},
+    {"ModelManager_LastSyncTime_USBGPU", {CLEAR_ON_MANAGER_START | CLEAR_ON_OFFROAD_TRANSITION, INT, "0"}},
    {"ModelManager_ModelsCache", {PERSISTENT | BACKUP, JSON}},
+    {"ModelManager_ModelsCache_USBGPU", {PERSISTENT | BACKUP, JSON}},

    // Neural Network Lateral Control
    {"NeuralNetworkLateralControl", {PERSISTENT | BACKUP, BOOL, "0"}},
@@ -16,6 +16,15 @@ MASTER_SP_BRANCHES = ['master']
 RELEASE_BRANCHES = ['release-tizi-staging', 'release-mici-staging', 'release-tizi', 'release-mici', 'nightly']
 TESTED_BRANCHES = RELEASE_BRANCHES + ['devel-staging', 'nightly-dev'] + RELEASE_SP_BRANCHES + TESTED_SP_BRANCHES

+CHESTNUT_BRANCHES = {
+  "staging": "staging-chestnut",
+  "dev": "dev-chestnut",
+  "release-mici": "release-chestnut",
+  "release-tizi": "release-chestnut",
+  "release-mici-staging": "release-chestnut-staging",
+  "release-tizi-staging": "release-chestnut-staging",
+}
+
 SP_BRANCH_MIGRATIONS = {
  ("tici", "staging-c3-new"): "staging-tici",
  ("tici", "dev-c3-new"): "staging-tici",
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:c4c38772e6080aa4b8bf5212d3619e949775468c64f3edb88a1a426d767c38d2
-size 1579
+oid sha256:190e196eba6feffec125ac66cf7e77620b759e346fa69b80e3a3884a5694cb15
+size 3225
@@ -44,8 +44,7 @@ class LongControl:
    self.CP = CP
    self.CP_SP = CP_SP
    self.long_control_state = LongCtrlState.off
-    self.pid = PIDController((CP.longitudinalTuning.kpBP, CP.longitudinalTuning.kpV),
-                             (CP.longitudinalTuning.kiBP, CP.longitudinalTuning.kiV),
+    self.pid = PIDController(0.0, (CP.longitudinalTuning.kiBP, CP.longitudinalTuning.kiV),
                             rate=1 / DT_CTRL)
    self.last_output_accel = 0.0

@@ -35,6 +35,7 @@ build_files = [f'{gen}/acados_solver_long.c'] + casadi_model + casadi_cost_y + c

 # extra generated files used to trigger a rebuild
 generated_files = [
+  'acados_ocp_long.json',
  f'{gen}/Makefile',

  f'{gen}/main_long.c',
@@ -49,9 +49,8 @@ def get_cruise_accel(e2e, v_cruise, v_ego, a_cruise_prev, angle_steers, CP, dt,
      max_accel = min(max_accel, coast_limit)

  target_accel = np.clip(v_cruise - v_ego, A_CRUISE_MIN, max_accel)
-  if not e2e:
-    j_cruise = np.interp(v_ego, A_CRUISE_MAX_BP, J_CRUISE_VALS)
-    target_accel = float(np.clip(target_accel, a_cruise_prev - j_cruise * dt, a_cruise_prev + j_cruise * dt))
+  j_cruise = np.interp(v_ego, A_CRUISE_MAX_BP, J_CRUISE_VALS)
+  target_accel = float(np.clip(target_accel, a_cruise_prev - j_cruise * dt, a_cruise_prev + j_cruise * dt))

  return target_accel

@@ -65,10 +64,9 @@ class LongitudinalPlanner(LongitudinalPlannerSP):
    self.dt = dt
    self.allow_throttle = True

-    self.a_desired = init_a
    self.v_desired_filter = FirstOrderFilter(init_v, 2.0, self.dt)
-    self.a_cruise = 0.0
-    self.output_a_target = 0.0
+    self.a_cruise = init_a
+    self.output_a_target = init_a
    self.output_should_stop = False

    self.v_desired_trajectory = np.zeros(CONTROL_N)
@@ -105,7 +103,8 @@ class LongitudinalPlanner(LongitudinalPlannerSP):

    if reset_state:
      self.v_desired_filter.x = v_ego
-      self.a_desired = np.clip(sm['carState'].aEgo, ACCEL_MIN, ACCEL_MAX)
+      self.output_a_target = np.clip(sm['carState'].aEgo, ACCEL_MIN, ACCEL_MAX)
+      self.a_cruise = self.output_a_target

    # Prevent divergence, smooth in current v_ego
    self.v_desired_filter.x = max(0.0, self.v_desired_filter.update(v_ego))
@@ -113,11 +112,11 @@ class LongitudinalPlanner(LongitudinalPlannerSP):
    # No change cost when user is controlling the speed, or when standstill
    prev_accel_constraint = not (reset_state or sm['carState'].standstill)

-    # Get new v_cruise and a_desired from Smart Cruise Control and Speed Limit Assist
-    v_cruise, self.a_desired = LongitudinalPlannerSP.update_targets(self, sm, self.v_desired_filter.x, self.a_desired, v_cruise)
+    # Get new v_cruise and a_target from Smart Cruise Control and Speed Limit Assist
+    v_cruise, self.output_a_target = LongitudinalPlannerSP.update_targets(self, sm, self.v_desired_filter.x, self.output_a_target, v_cruise)

    self.mpc.set_weights(prev_accel_constraint, personality=sm['selfdriveState'].personality)
-    self.mpc.set_cur_state(self.v_desired_filter.x, self.a_desired)
+    self.mpc.set_cur_state(self.v_desired_filter.x, self.output_a_target)
    self.mpc.update(sm['radarState'], personality=sm['selfdriveState'].personality)

    self.v_desired_trajectory = np.interp(CONTROL_N_T_IDX, T_IDXS_MPC, self.mpc.v_solution)
@@ -130,7 +129,7 @@ class LongitudinalPlanner(LongitudinalPlannerSP):
      cloudlog.info("FCW triggered")

    # Save starting point for next iteration
-    a_prev = self.a_desired
+    a_prev = self.output_a_target

    action_t =  self.CP.longitudinalActuatorDelay + DT_MDL
    output_a_target_mpc = get_accel_from_plan(self.v_desired_trajectory, self.a_desired_trajectory, CONTROL_N_T_IDX,
@@ -155,7 +154,6 @@ class LongitudinalPlanner(LongitudinalPlannerSP):
    self.output_should_stop = any(should_stop for _, _, should_stop in candidates)
    self.output_a_target = np.clip(output_a_target, ACCEL_MIN, ACCEL_MAX)

-    self.a_desired = float(self.output_a_target)
    self.v_desired_filter.x = self.v_desired_filter.x + self.dt * (self.output_a_target + a_prev) / 2.0

  def publish(self, sm, pm):
@@ -73,42 +73,45 @@ compile_modeld_script = [
 model_w, model_h = MEDMODEL_INPUT_SIZE
 frame_skip = ModelConstants.MODEL_RUN_FREQ // ModelConstants.MODEL_CONTEXT_FREQ

-for usbgpu in [False, True] if USBGPU else [False]:
-  target_pkl_path = File(modeld_pkl_path(usbgpu)).abspath
-  # BIG_INTO_SMALL=1 builds the default target from the big model, e.g. to test it without a USB GPU
-  file_prefix, cmd_flags = ('big_', usbgpu_tg_flags) if usbgpu else ('big_' if os.getenv('BIG_INTO_SMALL') else '', tg_flags)
-  driving_onnx_deps = get_existing_chunks(File(f"models/{file_prefix}driving_supercombo.onnx").abspath)
-  camera_res_args = ' '.join(f'{cw}x{ch}' for cw, ch in CAMERA_CONFIGS)
-  cmd = (f'{cmd_flags} {mac_brew_string} python3 {modeld_dir}/compile_modeld.py '
-        f'--model-size {model_w}x{model_h} '
-        f'--camera-resolutions {camera_res_args} '
-        f'--onnx {File(f"models/{file_prefix}driving_supercombo.onnx").abspath} '
-        f'--output {target_pkl_path} --frame-skip {frame_skip}')
-  onnx_sizes_sum = sum(os.path.getsize(f) for f in driving_onnx_deps)
-  chunk_targets = get_chunk_targets(target_pkl_path, estimate_pickle_max_size(onnx_sizes_sum))
-  def do_compile(target, source, env, command=cmd, pkl=target_pkl_path, chunks=chunk_targets):
-    from openpilot.system.hardware.chestnut.flash import link_up
-    # chestnut can enumerate before its PCIe link is up due to varying 12V power behavior across cars
-    for _ in range(10):
-      if link_up():
-        break
-      time.sleep(1)
-    else:
-      print("Chestnut not ready, skipping big model build")
-      return
-    if ret := env.Execute(command):
-      return ret
-    chunk_file(pkl, chunks)
-  def do_chunk(target, source, env, pkl=target_pkl_path, chunks=chunk_targets):
-    chunk_file(pkl, chunks)
-  actions = Action(do_compile, "  [USBGPU] $TARGET") if usbgpu else [cmd, Action(do_chunk, "  [CHUNK] $TARGET")]
-  node = lenv.Command(
-    chunk_targets,
-    tinygrad_files + compile_modeld_script + driving_onnx_deps + [Value(chunk_targets), chunker_file],
-    actions,
-  )
-  if usbgpu:
-    lenv.SideEffect(usbgpu_lock, node)
+if not os.getenv('SKIP_TINYGRAD_COMPILE'):
+  for usbgpu in [False, True] if USBGPU else [False]:
+    target_pkl_path = File(modeld_pkl_path(usbgpu)).abspath
+    # BIG_INTO_SMALL=1 builds the default target from the big model, e.g. to test it without a USB GPU
+    file_prefix, cmd_flags = ('big_', usbgpu_tg_flags) if usbgpu else ('big_' if os.getenv('BIG_INTO_SMALL') else '', tg_flags)
+    driving_onnx_deps = get_existing_chunks(File(f"models/{file_prefix}driving_supercombo.onnx").abspath)
+    camera_res_args = ' '.join(f'{cw}x{ch}' for cw, ch in CAMERA_CONFIGS)
+    # CPU 7 is isolated with isolcpus on AGNOS, so explicitly pin the compiler to it.
+    taskset = 'taskset -c 7 ' if arch == 'comma_arm64' else ''
+    cmd = (f'{cmd_flags} {mac_brew_string} {taskset}python3 {modeld_dir}/compile_modeld.py '
+          f'--model-size {model_w}x{model_h} '
+          f'--camera-resolutions {camera_res_args} '
+          f'--onnx {File(f"models/{file_prefix}driving_supercombo.onnx").abspath} '
+          f'--output {target_pkl_path} --frame-skip {frame_skip}')
+    onnx_sizes_sum = sum(os.path.getsize(f) for f in driving_onnx_deps)
+    chunk_targets = get_chunk_targets(target_pkl_path, estimate_pickle_max_size(onnx_sizes_sum))
+    def do_compile(target, source, env, command=cmd, pkl=target_pkl_path, chunks=chunk_targets):
+      from openpilot.system.hardware.chestnut.flash import link_up
+      # chestnut can enumerate before its PCIe link is up due to varying 12V power behavior across cars
+      for _ in range(10):
+        if link_up():
+          break
+        time.sleep(1)
+      else:
+        print("Chestnut not ready, skipping big model build")
+        return
+      if ret := env.Execute(command):
+        return ret
+      chunk_file(pkl, chunks)
+    def do_chunk(target, source, env, pkl=target_pkl_path, chunks=chunk_targets):
+      chunk_file(pkl, chunks)
+    actions = Action(do_compile, "  [USBGPU] $TARGET") if usbgpu else [cmd, Action(do_chunk, "  [CHUNK] $TARGET")]
+    node = lenv.Command(
+      chunk_targets,
+      tinygrad_files + compile_modeld_script + driving_onnx_deps + [Value(chunk_targets), chunker_file],
+      actions,
+    )
+    if usbgpu:
+      lenv.SideEffect(usbgpu_lock, node)

 # get model metadata
 fn = File(f"models/dmonitoring_model").abspath
@@ -140,4 +143,5 @@ def tg_compile(flags, model_name):
     Action(do_chunk, "  [CHUNK] $TARGET")],
  )

-tg_compile(tg_flags, 'dmonitoring_model')
+if not os.getenv('SKIP_TINYGRAD_COMPILE'):
+  tg_compile(tg_flags, 'dmonitoring_model')
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:10926f2c0911821ca0e72439c1c3bf3ec11f0a08789aa14b7ee8f25379b2afa4
-size 1753235978
+oid sha256:a501760a9d1d5fef0eab2b8c5d122d06124fc26dc8e0782e0aa94b82a208f0ff
+size 1757355221
@@ -102,7 +102,6 @@ class TestBoarddSpi(OpenpilotTestCase):
        edt = 1e3 / SERVICE_LIST[service].frequency
        assert edt*0.9 < np.mean(dts) < edt*1.1
        assert np.max(dts) < edt*8
-        assert np.min(dts) < edt
        assert len(dts) >= ((et-0.5)*SERVICE_LIST[service].frequency*0.8)

    with subtests.test(msg="CAN traffic"):
@@ -17,8 +17,8 @@
    "severity": 1,
    "_comment": "Set extra field to the failed reason."
  },
-  "Offroad_NeosUpdate": {
-    "text": "An update to your device's operating system is downloading in the background. You will be prompted to update when it's ready to install.",
+  "Offroad_ChestnutBranch": {
+    "text": "Chestnut detected! Switch to the %1 branch to use chestnut-class models.",
    "severity": 0
  },
  "Offroad_UnregisteredHardware": {
@@ -234,7 +234,8 @@ EVENTS: dict[int, dict[str, Alert | AlertCallbackType]] = {
  },

  EventName.bigModelFailed: {
-    ET.PERMANENT: NormalPermanentAlert("Big Model Failed ", "Restart the car to retry,\nnow driving on small model", duration=20.),
+    ET.SOFT_DISABLE: soft_disable_alert("Big Model Failed"),
+    ET.PERMANENT: NormalPermanentAlert("Big Model Failed ", "Restart the car to retry,\nsmall model is still available", duration=20.),
  },

  EventName.lateralManeuver: {
@@ -198,6 +198,7 @@ class SelfdriveD(CruiseHelper):
    loading = self.params.get_bool("UsbGpuLoading")
    if self.big_model_loading and not loading:
      self.big_model_ready_t = time.monotonic()
+      self.events_sp.add(custom.OnroadEventSP.EventName.bigModelReady)
    self.big_model_loading = loading
    if self.big_model_loading:
      self.events.add(EventName.bigModelLoading)
@@ -337,7 +338,7 @@ class SelfdriveD(CruiseHelper):
      device_motion = Pose.from_device_motion(self.sm['deviceMotion'])
      self.calibrated_pose = self.pose_calibrator.build_calibrated_pose(device_motion)

-    if self.calibrated_pose is not None:
+    if self.calibrated_pose is not None and not self.CP.notCar:
      excessive_actuation = self.excessive_actuation_check.update(self.sm, CS, self.calibrated_pose)
      if not self.excessive_actuation and excessive_actuation is not None:
        set_offroad_alert("Offroad_ExcessiveActuation", True, extra_text=str(excessive_actuation))
@@ -397,6 +398,9 @@ class SelfdriveD(CruiseHelper):
    # All events here should at least have NO_ENTRY and SOFT_DISABLE.
    num_events = len(self.events)

+    if self.big_model_active and big_failed:
+      self.events.add(EventName.bigModelFailed)
+
    not_running = {p.name for p in self.sm['managerState'].processes if not p.running and p.shouldBeRunning}
    if self.sm.recv_frame['managerState'] and len(not_running):
      if not_running != self.not_running_prev:
@@ -7,7 +7,7 @@ import traceback
 from collections import defaultdict
 from tqdm import tqdm
 from typing import Any
-from opendbc.car.car_helpers import interface_names
+from opendbc.car.car_helpers import interface_names, interfaces
 from openpilot.common.git import get_commit
 from openpilot.tools.lib.openpilotci import get_url
 from openpilot.selfdrive.test.process_replay.compare_logs import compare_logs, format_diff
@@ -64,7 +64,8 @@ segments = [
 ]

 # dashcamOnly makes don't need to be tested until a full port is done
-excluded_interfaces = ["mock", "body", "psa"]
+excluded_interfaces = {brand for brand, platforms in interface_names.items()
+                       if all(interfaces[platform].get_non_essential_params(platform).dashcamOnly for platform in platforms)} | {"body"}

 BASE_URL = "https://raw.githubusercontent.com/sunnypilot/ci-artifacts/refs/heads/process-replay/"
 REF_COMMIT_FN = os.path.join(PROC_REPLAY_DIR, "ref_commit")
@@ -67,7 +67,7 @@ PROCS = {
  "openpilot.selfdrive.pandad.pandad": 0,
  "openpilot.system.loggerd.uploader": 15.0,
  "openpilot.system.loggerd.deleter": 1.0,
-  "./pandad": 19.0,
+  "./pandad": 40.0,
  "openpilot.system.qcomgpsd.qcomgpsd": 1.0,
  "openpilot.common.hardware.comma.modem": 10.0,
 }
@@ -107,6 +107,10 @@ def cputime_total(ct):
 class TestOnroad(OpenpilotTestCase):
  COMMA_HARDWARE_TEST = True

+  def setUp(self):
+    # Hardware setup is handled once for the full onroad test in setup_class.
+    unittest.TestCase.setUp(self)
+
  @classmethod
  def setup_class(cls):
    if "DEBUG" in os.environ:
@@ -332,26 +336,34 @@ class TestOnroad(OpenpilotTestCase):
            assert np.all(eof_sof_diff < 50*1e6)

        first_fid = {min(self.ts[c]['frameId']) for c in cams}
-        assert len(first_fid) == 1, "Cameras don't start on same frame ID"
-        if cam.endswith('CameraState'):
+        if cams[0].endswith('CameraState'):
          # camerad guarantees that all cams start on frame ID 0
          # (note loggerd also needs to start up fast enough to catch it)
-          assert next(iter(first_fid)) < 100, "Cameras start on frame ID too high"
+          assert min(first_fid) < 100, "Cameras start on frame ID too high"
+        else:
+          # encoderd synchronizes all camera encoders to the same starting frame
+          assert len(first_fid) == 1, "Camera encoders don't start on same frame ID"

        # we don't do a full segment rotation, so these might not match exactly
        last_fid = {max(self.ts[c]['frameId']) for c in cams}
        assert max(last_fid) - min(last_fid) < 10

-        start, end = min(first_fid), min(last_fid)
-        for i in range(end-start):
+        timestamps = {
+          cam: dict(zip(self.ts[cam]['frameId'], self.ts[cam]['timestampSof'], strict=True))
+          for cam in cams
+        }
+        common_frame_ids = set.intersection(*(set(ts) for ts in timestamps.values()))
+        assert common_frame_ids, "Cameras have no overlapping frame IDs"
+
+        for frame_id in sorted(common_frame_ids):
          # road and wide cameras (first two) should be synced within 2ms
-          ts = {c: round(self.ts[c]['timestampSof'][i]/1e6, 1) for c in cams[:2]}
-          diff = (max(ts.values()) - min(ts.values()))
-          assert diff < 2, f"Cameras not synced properly: frame_id={start+i}, {diff=:.1f}ms, {ts=}"
+          ts = {cam: timestamps[cam][frame_id] / 1e6 for cam in cams[:2]}
+          diff = max(ts.values()) - min(ts.values())
+          assert diff < 2, f"Cameras not synced properly: {frame_id=}, {diff=:.1f}ms, {ts=}"

          # cabin camera should be staggered ~25ms from road camera
-          offset_ms = abs(self.ts[cams[2]]['timestampSof'][i] - self.ts[cams[0]]['timestampSof'][i]) / 1e6
-          assert 20 < offset_ms < 30, f"cabin camera stagger out of range at frame {start+i}: {offset_ms:.1f}ms"
+          offset_ms = abs(timestamps[cams[2]][frame_id] - timestamps[cams[0]][frame_id]) / 1e6
+          assert 20 < offset_ms < 30, f"cabin camera stagger out of range at frame {frame_id}: {offset_ms:.1f}ms"

  def test_camera_encoder_matches(self, subtests):
    # sanity check that the frame metadata is consistent with the encoded frames
@@ -3,7 +3,6 @@ from enum import IntEnum
 import openpilot.cereal.messaging as messaging
 from openpilot.system.ui.lib.application import gui_app
 from openpilot.system.ui.widgets import Widget
-from openpilot.selfdrive.ui.sunnypilot.custom_button import CustomButtonAction, handle_custom_button
 from openpilot.selfdrive.ui.layouts.sidebar import Sidebar, SIDEBAR_WIDTH
 from openpilot.selfdrive.ui.layouts.home import HomeLayout
 from openpilot.selfdrive.ui.layouts.settings.settings import SettingsLayout, PanelType
@@ -28,7 +27,6 @@ class MainLayout(Widget):
    super().__init__()

    self._pm = messaging.PubMaster(['bookmarkButton', 'userBookmark'])
-    self._custom_button_sock = messaging.sub_sock('carState')

    self._sidebar = Sidebar()
    self._current_mode = MainState.HOME
@@ -42,10 +40,6 @@ class MainLayout(Widget):
      MainState.SETTINGS: SettingsLayout(),
      MainState.ONROAD: AugmentedRoadView(),
    }
-    self._custom_button_callbacks = {
-      CustomButtonAction.BOOKMARK: self._on_bookmark_clicked,
-      CustomButtonAction.CYCLE_UI: self._cycle_ui,
-    }

    self._sidebar_rect = rl.Rectangle(0, 0, 0, 0)
    self._content_rect = rl.Rectangle(0, 0, 0, 0)
@@ -61,7 +55,6 @@ class MainLayout(Widget):
      gui_app.push_widget(self._onboarding_window)

  def _render(self, _):
-    handle_custom_button(messaging.drain_sock(self._custom_button_sock), ui_state.params, self._custom_button_callbacks)
    self._handle_onroad_transition()
    self._render_main_content()

@@ -121,18 +114,6 @@ class MainLayout(Widget):
  def _on_settings_clicked(self):
    self.open_settings(PanelType.DEVICE)

-  def _show_onroad(self):
-    self._set_current_layout(MainState.ONROAD)
-    self._sidebar.set_visible(False)
-
-  def _cycle_ui(self):
-    if self._current_mode == MainState.ONROAD and not self._sidebar.is_visible:
-      self._sidebar.set_visible(True)
-    elif self._current_mode == MainState.SETTINGS:
-      self._show_onroad()
-    else:
-      self._on_settings_clicked()
-
  def _on_bookmark_clicked(self):
    for service in ('bookmarkButton', 'userBookmark'):
      msg = messaging.new_message(service, valid=True)
@@ -168,9 +168,16 @@ class Sidebar(Widget, SidebarSP):
    # Home/Flag button
    flag_pressed = mouse_down and rl.check_collision_point_rec(mouse_pos, HOME_BTN)
    button_img = self._flag_img if ui_state.started else self._home_img
+    button_pos = rl.Vector2(HOME_BTN.x, HOME_BTN.y)
+    icon_opacity = 1.0
+
+    if gui_app.sunnypilot_ui():
+      button_img, button_pos, icon_opacity = SidebarSP._get_home_icon(self, button_img)

    tint = Colors.BUTTON_PRESSED if (ui_state.started and flag_pressed) else Colors.BUTTON_NORMAL
-    rl.draw_texture_ex(button_img, rl.Vector2(HOME_BTN.x, HOME_BTN.y), 0.0, 1.0, tint)
+    if icon_opacity < 1.0:
+      tint = rl.Color(tint[0], tint[1], tint[2], int(255 * icon_opacity))
+    rl.draw_texture_ex(button_img, button_pos, 0.0, 1.0, tint)

    # Microphone button
    if self._recording_audio:
@@ -248,8 +248,11 @@ class MiciHomeLayout(Widget):

    # ***** Center-aligned bottom section icons *****
    self._experimental_icon.set_visible(ui_state.experimental_mode)
-    self._egpu_icon.set_visible(ui_state.sm["deviceState"].chestnutPresent and ui_state.usbgpu_compiled)
-    self._egpu_icon_gray.set_visible(ui_state.sm["deviceState"].chestnutPresent and not ui_state.usbgpu_compiled)
+    if gui_app.sunnypilot_ui():
+      self._set_egpu_visibility()
+    else:
+      self._egpu_icon.set_visible(ui_state.sm["deviceState"].chestnutPresent and ui_state.usbgpu_compiled)
+      self._egpu_icon_gray.set_visible(ui_state.sm["deviceState"].chestnutPresent and not ui_state.usbgpu_compiled)
    self._mic_icon.set_visible(ui_state.recording_audio)
    self._body_icon.set_visible(bool(ui_state.is_body))

@@ -4,7 +4,6 @@ from openpilot.selfdrive.ui.mici.layouts.home import MiciHomeLayout
 from openpilot.selfdrive.ui.mici.layouts.settings.settings import SettingsLayout
 from openpilot.selfdrive.ui.mici.layouts.offroad_alerts import MiciOffroadAlerts
 from openpilot.selfdrive.ui.mici.onroad.augmented_road_view import AugmentedRoadView
-from openpilot.selfdrive.ui.sunnypilot.custom_button import CustomButtonAction, handle_custom_button
 from openpilot.selfdrive.ui.ui_state import device, ui_state
 from openpilot.selfdrive.ui.mici.layouts.onboarding import OnboardingWindow
 from openpilot.selfdrive.ui.body.layouts.onroad import BodyLayout
@@ -24,7 +23,6 @@ class MiciMainLayout(Scroller):
    super().__init__(snap_items=True, spacing=0, pad=0, scroll_indicator=False, edge_shadows=False)

    self._pm = messaging.PubMaster(['bookmarkButton', 'userBookmark'])
-    self._custom_button_sock = messaging.sub_sock('carState')

    self._prev_onroad = False
    self._prev_standstill = False
@@ -37,10 +35,6 @@ class MiciMainLayout(Scroller):
    self._settings_layout = SettingsLayout()
    self._car_onroad_layout = AugmentedRoadView(bookmark_callback=self._on_bookmark_clicked)
    self._body_onroad_layout = BodyLayout()
-    self._custom_button_callbacks = {
-      CustomButtonAction.BOOKMARK: self._on_bookmark_clicked,
-      CustomButtonAction.CYCLE_UI: self._cycle_ui,
-    }

    # Initialize widget rects
    for widget in (self._home_layout, self._alerts_layout, self._settings_layout,
@@ -101,8 +95,6 @@ class MiciMainLayout(Scroller):
    self._alerts_layout._update_state()

  def _render(self, _):
-    handle_custom_button(messaging.drain_sock(self._custom_button_sock), ui_state.params, self._custom_button_callbacks)
-
    if not self._setup:
      if self._alerts_layout.active_alerts() > 0:
        self._scroller.scroll_to(self._alerts_layout.rect.x)
@@ -158,23 +150,6 @@ class MiciMainLayout(Scroller):
      msg = messaging.new_message(service, valid=True)
      self._pm.send(service, msg)

-  def _show_layout(self, layout: Widget):
-    if gui_app.widget_in_stack(self._onboarding_window):
-      return
-    gui_app.pop_widgets_to(self, lambda: self._scroll_to(layout))
-
-  def _layout_visible(self, layout: Widget) -> bool:
-    return abs(layout.rect.x - self._rect.x) < self._rect.width / 2
-
-  def _cycle_ui(self):
-    if gui_app.widget_in_stack(self._settings_layout):
-      self._show_layout(self._onroad_layout)
-    elif gui_app.get_active_widget() is self and self._layout_visible(self._home_layout):
-      if not gui_app.widget_in_stack(self._onboarding_window):
-        gui_app.push_widget(self._settings_layout)
-    else:
-      self._show_layout(self._home_layout)
-
  def _on_body_changed(self):
    self._car_onroad_layout.set_visible(not ui_state.is_body)
    self._body_onroad_layout.set_visible(bool(ui_state.is_body))
@@ -47,7 +47,7 @@ class SoftwareInfoLayoutMici(Widget):

    self._branch_label = UnifiedLabel("branch", 48, max_width=max_width, font_weight=FontWeight.DISPLAY, wrap_text=False)
    self._branch_text_label = UnifiedLabel("", 32, max_width=max_width, text_color=subheader_color,
-                                           font_weight=FontWeight.ROMAN, wrap_text=False)
+                                           font_weight=FontWeight.ROMAN, wrap_text=False, scroll=True)

  def _update_state(self):
    desc = _split_description(ui_state.params.get("UpdaterCurrentDescription") or "")
@@ -132,7 +132,7 @@ class AlertRenderer(Widget, SpeedLimitAlertRenderer):

      # 1. Never received selfdriveState since going onroad
      waiting_for_startup = recv_frame < ui_state.started_frame
-      if waiting_for_startup and time_since_onroad > 5:
+      if waiting_for_startup and time_since_onroad > 10:
        return ALERT_STARTUP_PENDING

      # 2. Lost communication with selfdriveState after receiving it
@@ -149,11 +149,15 @@ class BigButton(Widget):
  def set_touch_valid_callback(self, touch_callback: Callable[[], bool]) -> None:
    super().set_touch_valid_callback(lambda: touch_callback() and self._grow_animation_until is None)

-  def _width_hint(self) -> int:
-    # Single line if scrolling, so hide behind icon if exists
-    icon_size = self._txt_icon.width if self._txt_icon and self._scroll and self.value else 0
+  def _title_width_hint(self) -> int:
+    # A value moves the title to the top, where it shares space with the icon
+    icon_size = self._txt_icon.width if self._txt_icon and self.value else 0
    return int(self._rect.width - self.LABEL_HORIZONTAL_PADDING * 2 - icon_size)

+  def _subtitle_width_hint(self) -> int:
+    # Bottom aligned, so it sits below the icon
+    return int(self._rect.width - self.LABEL_HORIZONTAL_PADDING * 2)
+
  def _get_label_font_size(self):
    if len(self.text) <= 18:
      return 48
@@ -228,14 +232,14 @@ class BigButton(Widget):

    label_color = LABEL_COLOR if self.enabled else rl.Color(255, 255, 255, int(255 * 0.35))
    self._label.set_color(label_color)
-    label_rect = rl.Rectangle(label_x, btn_y + self.LABEL_VERTICAL_PADDING, self._width_hint(),
+    label_rect = rl.Rectangle(label_x, btn_y + self.LABEL_VERTICAL_PADDING, self._title_width_hint(),
                              self._rect.height - self.LABEL_VERTICAL_PADDING * 2)
    self._label.render(label_rect)

    if self.value:
-      label_y = btn_y + self.LABEL_VERTICAL_PADDING + self._label.get_content_height(self._width_hint())
+      label_y = label_rect.y + self._label.get_content_height(int(label_rect.width))
      sub_label_height = btn_y + self._rect.height - self.LABEL_VERTICAL_PADDING - label_y
-      sub_label_rect = rl.Rectangle(label_x, label_y, self._width_hint(), sub_label_height)
+      sub_label_rect = rl.Rectangle(label_x, label_y, self._subtitle_width_hint(), sub_label_height)
      self._sub_label.render(sub_label_rect)

    # ICON -------------------------------------------------------------------
@@ -312,9 +316,6 @@ class BigMultiToggle(BigToggle):

    self.set_value(self._options[0])

-  def _width_hint(self) -> int:
-    return int(self._rect.width - self.LABEL_HORIZONTAL_PADDING * 2 - self._txt_enabled_toggle.width)
-
  def _handle_mouse_release(self, mouse_pos: MousePos):
    super()._handle_mouse_release(mouse_pos)
    cur_idx = self._options.index(self.value)
@@ -363,9 +364,6 @@ class GreyBigButton(BigButton):
  def LABEL_VERTICAL_PADDING(self):
    return BigButton.LABEL_VERTICAL_PADDING if self._label.text else 18

-  def _width_hint(self) -> int:
-    return int(self._rect.width - self.LABEL_HORIZONTAL_PADDING * 2)
-
  def _get_label_font_size(self):
    return 36

@@ -92,7 +92,7 @@ class AlertRenderer(Widget):

      # 1. Never received selfdriveState since going onroad
      waiting_for_startup = recv_frame < ui_state.started_frame
-      if waiting_for_startup and time_since_onroad > 5:
+      if waiting_for_startup and time_since_onroad > 10:
        return ALERT_STARTUP_PENDING

      # 2. Lost communication with selfdriveState after receiving it
@@ -192,7 +192,7 @@ class ModelRenderer(Widget, ChevronMetrics, ModelRendererSP):

    max_idx = self._get_path_length_idx(path_x_array, max_distance)
    self._path.projected_points = self._map_line_to_polygon(
-      self._path.raw_points, 0.9, self._path_offset_z, max_idx, max_distance, allow_invert=False
+      self._path.raw_points, self._get_path_half_width(), self._path_offset_z, max_idx, max_distance, allow_invert=False
    )

    self._update_experimental_gradient()
@@ -292,7 +292,7 @@ class ModelRenderer(Widget, ChevronMetrics, ModelRendererSP):
    allow_throttle = sm['longitudinalPlan'].allowThrottle or not self._longitudinal_control
    self._blend_filter.update(int(allow_throttle))

-    if ui_state.rainbow_path:
+    if ui_state.rainbow_path and self._lateral_active:
      self.rainbow_path.draw_rainbow_path(self._rect, self._path)
      return

@@ -1,19 +0,0 @@
-from enum import IntEnum
-
-from opendbc.car.structs import car
-
-
-class CustomButtonAction(IntEnum):
-  NONE = 0
-  BOOKMARK = 1
-  CYCLE_UI = 3
-
-
-def handle_custom_button(messages, params, callbacks):
-  for msg in messages:
-    custom_pressed = any(be.type == car.CarState.ButtonEvent.Type.altButton2 and be.pressed
-                         for be in msg.carState.buttonEvents)
-    if custom_pressed:
-      action = CustomButtonAction(params.get('CustomButtonAction', return_default=True))
-      if callback := callbacks.get(action):
-        callback()
@@ -10,9 +10,10 @@ import time
 import pyray as rl

 from openpilot.cereal import custom
-from openpilot.sunnypilot.models.default_model import DEFAULT_MODEL
+from openpilot.sunnypilot.models.helpers import ACTIVE_BUNDLE_KEYS, get_selected_bundle, resolve_bundle_by_ref
 from openpilot.common.constants import CV
 from openpilot.selfdrive.ui.ui_state import device, ui_state
+from openpilot.selfdrive.ui.sunnypilot.model_info import big_model_state, bundles_for_source, carrying_model, default_model_name, queued_name
 from openpilot.system.ui.lib.multilang import tr
 from openpilot.system.ui.lib.application import gui_app
 from openpilot.system.ui.widgets import DialogResult, Widget
@@ -22,9 +23,9 @@ from openpilot.system.ui.widgets.toggle import ON_COLOR

 from openpilot.sunnypilot.models.runners.constants import CUSTOM_MODEL_PATH
 from openpilot.system.ui.sunnypilot.lib.styles import style
-from openpilot.system.ui.sunnypilot.lib.utils import NoElideButtonAction
+from openpilot.system.ui.sunnypilot.lib.utils import NoElideButtonAction, ScrollingButtonAction
 from openpilot.system.ui.sunnypilot.widgets.list_view import ListItemSP, toggle_item_sp, option_item_sp
-from openpilot.system.ui.sunnypilot.widgets.progress_bar import progress_item
+from openpilot.system.ui.sunnypilot.widgets.download_status import download_status_item
 from openpilot.system.ui.sunnypilot.widgets.tree_dialog import TreeOptionDialog, TreeNode, TreeFolder

 if gui_app.sunnypilot_ui():
@@ -35,9 +36,11 @@ class ModelsLayout(Widget):
  def __init__(self):
    super().__init__()
    self.model_manager = None
-    self.download_status = None
-    self.prev_download_status = None
    self.model_dialog = None
+    self._selection_source = None
+    self._downloading = False
+    self._verifying = False
+    self._last_note = None
    self.last_cache_calc_time = 0

    self._initialize_items()
@@ -49,21 +52,24 @@ class ModelsLayout(Widget):
    self._scroller = Scroller(self.items, line_separator=True, spacing=0)

  def _initialize_items(self):
-    self.current_model_item = ListItemSP(
-      title=tr("Current Model"),
+    self.small_model_item = ListItemSP(
+      title=tr("Small Model"),
      description="",
-      action_item=NoElideButtonAction(tr("SELECT")),
-      callback=self._handle_current_model_clicked
+      action_item=ScrollingButtonAction(tr("SELECT")),
+      callback=lambda: self._open_source_dialog("qcom")
    )

-    self.supercombo_label = progress_item(tr("Driving Model"))
-    self.vision_label = progress_item(tr("Vision Model"))
-    self.policy_label = progress_item(tr("Policy Model"))
-    self.off_policy_label = progress_item(tr("Off-Policy Model"))
-    self.on_policy_label = progress_item(tr("On-Policy Model"))
+    self.big_model_item = ListItemSP(
+      title=tr("Big Model"),
+      action_item=ScrollingButtonAction(tr("SELECT")),
+      callback=lambda: self._open_source_dialog("usbgpu")
+    )
+
+    self.download_item = download_status_item(lambda: tr("Download") if self._downloading else tr("Model Status"))

    self.refresh_item = button_item(tr("Refresh Model List"), tr("REFRESH"), "",
                                    lambda: (ui_state.params.put("ModelManager_LastSyncTime", 0),
+                                             ui_state.params.put("ModelManager_LastSyncTime_USBGPU", 0),
                                             gui_app.push_widget(alert_dialog(tr("Fetching Latest Models")))))

    self.clear_cache_item = ListItemSP(
@@ -73,7 +79,9 @@ class ModelsLayout(Widget):
      callback=self._clear_cache
    )

-    self.cancel_download_item = button_item(tr("Cancel Download"), tr("Cancel"), "", lambda: ui_state.params.remove("ModelManager_DownloadIndex"))
+    self.cancel_download_item = button_item(lambda: tr("Cancel Verification") if self._verifying else tr("Cancel Download"),
+                                            tr("Cancel"), "",
+                                            lambda: ui_state.params.remove("ModelManager_DownloadRef"))

    self.lane_turn_value_control = option_item_sp(tr("Adjust Lane Turn Speed"), "LaneTurnValue", 500, 2000,
                                                  tr("Set the maximum speed for lane turn desires. Default is 19 mph."),
@@ -98,8 +106,7 @@ class ModelsLayout(Widget):
                                        1, None, True, "", style.BUTTON_ACTION_WIDTH, None, True,
                                        lambda v: f"{v / 100:.2f} m")

-    self.items = [self.current_model_item, self.cancel_download_item, self.supercombo_label, self.vision_label,
-                  self.policy_label, self.off_policy_label, self.on_policy_label, self.refresh_item, self.clear_cache_item,
+    self.items = [self.small_model_item, self.big_model_item, self.cancel_download_item, self.download_item, self.refresh_item, self.clear_cache_item,
                  self.lane_turn_desire_toggle, self.lane_turn_value_control, self.lagd_toggle, self.delay_control, self.camera_offset]

  def _update_lagd_description(self, lagd_toggle: bool):
@@ -113,16 +120,16 @@ class ModelsLayout(Widget):
      desc += f"<br>{tr('Actuator Delay:')} {cp:.2f} s + {tr('Software Delay:')} {sw:.2f} s = {tr('Total Delay:')} {cp + sw:.2f} s"
    self.lagd_toggle.set_description(desc)

-  def _is_downloading(self):
-    return (self.model_manager and self.model_manager.selectedBundle and
-            self.model_manager.selectedBundle.status == custom.ModelManagerSP.DownloadStatus.downloading)
-
  @staticmethod
  def calculate_cache_size():
    cache_size = 0.0
    if os.path.exists(CUSTOM_MODEL_PATH):
-      cache_size = sum(os.path.getsize(os.path.join(CUSTOM_MODEL_PATH, file)) for file in os.listdir(CUSTOM_MODEL_PATH)) / (1024**2)
-    return cache_size
+      for file in os.listdir(CUSTOM_MODEL_PATH):
+        try:
+          cache_size += os.path.getsize(os.path.join(CUSTOM_MODEL_PATH, file))
+        except OSError:
+          continue
+    return cache_size / (1024**2)

  def _clear_cache(self):
    def _callback(response):
@@ -135,109 +142,178 @@ class ModelsLayout(Widget):
    gui_app.push_widget(dialog)

  def _handle_bundle_download_progress(self):
-    labels = {custom.ModelManagerSP.Model.Type.supercombo: self.supercombo_label,
-              custom.ModelManagerSP.Model.Type.vision: self.vision_label,
-              custom.ModelManagerSP.Model.Type.policy: self.policy_label,
-              custom.ModelManagerSP.Model.Type.offPolicy: self.off_policy_label,
-              custom.ModelManagerSP.Model.Type.onPolicy: self.on_policy_label}
-    for label in labels.values():
-      label.set_visible(False)
    self.cancel_download_item.set_visible(False)
-
-    if not self.model_manager or (not self.model_manager.selectedBundle and not self.model_manager.activeBundle):
-      return
-
-    bundle = self.model_manager.selectedBundle if self._is_downloading() or (
-      self.model_manager.selectedBundle and self.model_manager.selectedBundle.status == custom.ModelManagerSP.DownloadStatus.failed
-    ) else self.model_manager.activeBundle
-    if not bundle:
-      return
-
-    self.download_status = bundle.status
-    status_changed = self.prev_download_status != self.download_status
-    self.prev_download_status = self.download_status
-
-    self.cancel_download_item.set_visible(bool(self.model_manager.selectedBundle) and ui_state.params.get("ModelManager_DownloadIndex") is not None)
+    self._downloading = False
+    self._verifying = False
+    self.download_item.set_visible(True)

    if (current_time := time.monotonic()) - self.last_cache_calc_time > 0.5:
      self.last_cache_calc_time = current_time
      self.clear_cache_item.action_item.set_value(f"{self.calculate_cache_size():.2f} MB")

-    if self.download_status == custom.ModelManagerSP.DownloadStatus.downloading:
+    bundle = self.model_manager.selectedBundle if self.model_manager else None
+    progresses = [model.artifact.downloadProgress for model in bundle.models if model.artifact.fileName] if bundle else []
+    if not progresses or bundle.status not in (custom.ModelManagerSP.DownloadStatus.downloading,
+                                               custom.ModelManagerSP.DownloadStatus.failed):
+      self.download_item.action_item.update(name="", segments=self._slot_segments())
+      return
+
+    self.cancel_download_item.set_visible(ui_state.params.get("ModelManager_DownloadRef") is not None)
+    if bundle.status == custom.ModelManagerSP.DownloadStatus.downloading:
      device._reset_interactive_timeout()

-    for model in bundle.models:
-      if label := labels.get(getattr(model.type, 'raw', model.type)):
-        label.set_visible(True)
-        p = model.artifact.downloadProgress
-        text, show, color = f"pending - {bundle.displayName}", False, rl.GRAY
-        if p.status == custom.ModelManagerSP.DownloadStatus.downloading:
-          text, show = f"{int(p.progress)}% - {bundle.displayName}", True
-        elif p.status in (custom.ModelManagerSP.DownloadStatus.downloaded, custom.ModelManagerSP.DownloadStatus.cached):
-          status_text = tr("from cache" if p.status == custom.ModelManagerSP.DownloadStatus.cached else "downloaded")
-          text, color = f"{bundle.displayName} - {status_text if status_changed else tr('ready')}", ON_COLOR
-        elif p.status == custom.ModelManagerSP.DownloadStatus.failed:
-          text, color = f"download failed - {bundle.displayName}", rl.RED
-        label.action_item.update(p.progress, text, show, color)
+    state = self._download_row_state(progresses, bundle.internalName)
+    if queued := queued_name(bundle.ref):
+      state["name"] += f"  |  {queued} {tr('queued')}"
+    self.download_item.action_item.update(**state)
+    self._downloading = self.download_item.action_item.downloading
+    ds = custom.ModelManagerSP.DownloadStatus
+    self._verifying = any(getattr(p.status, 'raw', p.status) == ds.verifying for p in progresses)
+
+  def _slot_segments(self):
+    """small and big slots side by side; green marks the slot whose pick is actually
+    driving (runner-matched, so a failed Default big greens neither slot), an empty
+    slot shows its default."""
+    big_state = big_model_state()
+    carry_source, carry_internal, _ = carrying_model()
+    segments = []
+    for source, label in (("qcom", tr("small")), ("usbgpu", tr("big"))):
+      if segments:
+        segments.append(("|", rl.GRAY, None, None))
+      bundle = get_selected_bundle(ui_state.params, source)
+      name = bundle.internalName if bundle else default_model_name(source)
+      color = ON_COLOR if (source == carry_source and name == carry_internal) else rl.LIGHTGRAY
+      name = "● " + name
+      if source == "usbgpu":
+        if big_state == 'failed':
+          color = rl.RED
+        elif big_state == 'loading':
+          color = rl.GOLD
+      segments.append((label, rl.GRAY, None, None))
+      segments.append((name, color, None, None))
+    return segments

  @staticmethod
-  def _show_reset_params_dialog():
-    def _callback(response):
-      if response == DialogResult.CONFIRM:
-        ui_state.params.remove("CalibrationParams")
-        ui_state.params.remove("LiveTorqueParameters")
-    msg = tr("Model download has started in the background. We suggest resetting calibration. Would you like to do that now?")
-    dialog = ConfirmDialog(msg, tr("Reset Calibration"), callback=_callback)
-    gui_app.push_widget(dialog)
+  def _set_item_note(item, text):
+    # a description renders only while shown; hide before clearing or the
+    # empty description keeps its visible state
+    if text:
+      item.set_description(text)
+      item.show_description(True)
+    else:
+      item.show_description(False)
+      item.set_description("")
+
+  def _status_note(self) -> str:
+    """The failover story for the Model Status row. One-way big -> small, and the
+    fallback is runner-matched: a Default big can only fall back to the Default
+    small (stock modeld), a custom big has no automatic fallback yet."""
+    if not ui_state.usbgpu:
+      return ""
+    big_bundle = get_selected_bundle(ui_state.params, "usbgpu")
+    big_name = big_bundle.internalName if big_bundle else default_model_name("usbgpu")
+    big_is_default = big_bundle is None
+    fallback_name = default_model_name("qcom")
+    state = big_model_state()
+    if state == 'failed':
+      if big_is_default:
+        return tr("Big model unavailable, {} is driving until the next drive.").format(fallback_name)
+      return tr("Big model unavailable until the next drive.")
+    if state == 'loading':
+      if big_is_default:
+        return tr("{} drives until the big model is ready.").format(fallback_name)
+      return tr("Getting the big model ready.")
+    if big_is_default:
+      return tr("{} will drive. If it fails during a drive, {} takes over until the next drive.").format(big_name, fallback_name)
+    return tr("{} will drive when the eGPU is ready.").format(big_name)
+
+  @staticmethod
+  def _download_row_state(progresses, name: str) -> dict:
+    """Maps a bundle's artifact progress to DownloadStatusAction.update kwargs."""
+    # .raw: _DynamicEnum equals its int but does not hash like it
+    statuses = {getattr(p.status, 'raw', p.status) for p in progresses}
+    progress = sum(p.progress for p in progresses) / len(progresses)
+    ds = custom.ModelManagerSP.DownloadStatus
+
+    if ds.failed in statuses:
+      # close.png is authored black and a tint cannot lift it, hence close2
+      return {"name": name, "status_text": tr("download failed"), "text_color": rl.RED, "icon": "icons/close2.png"}
+    if ds.verifying in statuses:
+      return {"name": name, "downloading": True, "progress": progress, "status_text": tr("verifying")}
+    if ds.downloading in statuses:
+      return {"name": name, "downloading": True, "progress": progress}
+    if statuses <= {ds.downloaded, ds.cached}:
+      return {"name": name, "text_color": ON_COLOR, "icon": "icons/checkmark.png"}
+    # circled_slash is authored grey; tinting it again only darkens it
+    return {"name": name, "text_color": rl.GRAY, "icon": "icons/circled_slash.png", "icon_color": rl.WHITE}

  def _on_model_selected(self, result):
    if result != DialogResult.CONFIRM:
+      self.model_dialog = None
      return
    selected_ref = self.model_dialog.selection_ref
-    if selected_ref == "Default":
-      ui_state.params.remove("ModelManager_ActiveBundle")
-      self._show_reset_params_dialog()
-    elif selected_bundle := next((bundle for bundle in self.model_manager.availableBundles if bundle.ref == selected_ref), None):
-      ui_state.params.put("ModelManager_DownloadIndex", selected_bundle.index)
-      if self.model_manager.activeBundle and selected_bundle.generation != self.model_manager.activeBundle.generation:
-        self._show_reset_params_dialog()
    self.model_dialog = None
+    if selected_ref == "Default":
+      if self._selection_source in ACTIVE_BUNDLE_KEYS:
+        ui_state.params.remove(ACTIVE_BUNDLE_KEYS[self._selection_source])
+      return
+    if selected_bundle := self._resolve_selected_bundle(selected_ref):
+      ui_state.params.put("ModelManager_DownloadRef", selected_bundle.ref)
+
+  def _resolve_selected_bundle(self, ref):
+    source_bundles = {source: bundles_for_source(source) for source in ("qcom", "usbgpu")}
+    resolved = resolve_bundle_by_ref(ref, source_bundles)
+    return resolved[0] if resolved else None

  @staticmethod
  def _bundle_to_node(bundle):
    return TreeNode(bundle.ref, {'display_name': bundle.displayName, 'short_name': bundle.internalName})

-  def _get_folders(self, favorites):
-    bundles = self.model_manager.availableBundles
+  def _get_folders(self, favorites, bundles):
    folders = {}
    for bundle in bundles:
      folders.setdefault(next((ov_ride.value for ov_ride in bundle.overrides if ov_ride.key == "folder"), ""), []).append(bundle)

-    folders_list = [TreeFolder("", [TreeNode("Default", {'display_name': f"{DEFAULT_MODEL} (Default)", 'short_name': "Default"})])]
+    folders_list = []
    for folder, folder_bundles in sorted(folders.items(), key=lambda x: max((bundle.index for bundle in x[1]), default=-1), reverse=True):
      folder_bundles.sort(key=lambda bundle: bundle.index, reverse=True)
      name = folder + (f" - (Updated: {m.group(1)})" if folder_bundles and (m := re.search(r'\(([^)]*)\)[^(]*$', folder_bundles[0].displayName)) else "")
      folders_list.append(TreeFolder(name, [self._bundle_to_node(bundle) for bundle in folder_bundles]))

    if favorites and (fav_bundles := [bundle for bundle in bundles if bundle.ref in favorites]):
-      folders_list.insert(1, TreeFolder("Favorites", [self._bundle_to_node(bundle) for bundle in fav_bundles]))
+      folders_list.insert(0, TreeFolder("Favorites", [self._bundle_to_node(bundle) for bundle in fav_bundles]))
    return folders_list

-  def _handle_current_model_clicked(self):
+  def _open_source_dialog(self, source):
+    self._selection_source = source
    favs = ui_state.params.get("ModelManager_Favs")
    favorites = set(favs.split(';')) if favs else set()
-    folders_list = self._get_folders(favorites)
-
-    active_ref = self.model_manager.activeBundle.ref if self.model_manager.activeBundle else "Default"
-    self.model_dialog = TreeOptionDialog(tr("Select a Model"), folders_list, active_ref, "ModelManager_Favs",
-                                         get_folders_fn=self._get_folders, on_exit=self._on_model_selected)
+    folders_list = self._source_folders(favorites, source)
+    if not folders_list:
+      gui_app.push_widget(alert_dialog(tr("No models are available for this hardware yet. Connect to the internet and refresh the model list.")))
+      return
+    self.model_dialog = TreeOptionDialog(tr("Select a Model"), folders_list, self._slot_active_ref(source), "ModelManager_Favs",
+                                         get_folders_fn=lambda favs: self._source_folders(favs, source), on_exit=self._on_model_selected)
    gui_app.push_widget(self.model_dialog)

+  def _source_folders(self, favorites, source):
+    bundles = bundles_for_source(source)
+    if not bundles:
+      return []
+    folders_list = [TreeFolder("", [TreeNode("Default", {'display_name': default_model_name(source)})])]
+    folders_list.extend(self._get_folders(favorites, bundles))
+    return folders_list
+
+  @staticmethod
+  def _slot_active_ref(source: str) -> str:
+    bundle = get_selected_bundle(ui_state.params, source)
+    return bundle.ref if bundle else "Default"
+
  def _update_state(self):
    advanced_controls: bool = ui_state.params.get_bool("ShowAdvancedControls")
    turn_desire: bool = ui_state.params.get_bool("LaneTurnDesire")
    live_delay: bool = ui_state.params.get_bool("LagdToggle")
-    camera_offset: bool = ui_state.params.get("ModelManager_ActiveBundle") is not None
+    camera_offset: bool = ui_state.active_bundle is not None

    self.lane_turn_desire_toggle.action_item.set_state(turn_desire)
    self.lane_turn_value_control.set_visible(turn_desire and advanced_controls)
@@ -251,18 +327,27 @@ class ModelsLayout(Widget):
    self._update_lagd_description(live_delay)
    self.model_manager = ui_state.sm["modelManagerSP"]
    self._handle_bundle_download_progress()
-    active_name = self.model_manager.activeBundle.internalName if self.model_manager and self.model_manager.activeBundle.ref else f"{DEFAULT_MODEL} (Default)"
-    self.current_model_item.action_item.set_value(active_name)

-    if not ui_state.is_offroad():
-      self.current_model_item.action_item.set_enabled(False)
-      self.current_model_item.set_description(tr("Only available when vehicle is off, or always offroad mode is on"))
-    else:
-      self.current_model_item.action_item.set_enabled(True)
-      self.current_model_item.set_description("")
+    carry_source, _, carry_display = carrying_model()
+    for item, item_source in ((self.small_model_item, "qcom"), (self.big_model_item, "usbgpu")):
+      bundle = get_selected_bundle(ui_state.params, item_source)
+      name = bundle.displayName if bundle else default_model_name(item_source)
+      color = ON_COLOR if (item_source == carry_source and name == carry_display) else style.ITEM_TEXT_VALUE_COLOR
+      item.action_item.set_value(name, color)
+
+    note = self._status_note()
+    if note != self._last_note:
+      self._last_note = note
+      self._set_item_note(self.download_item, note)
+
+    offroad = ui_state.is_offroad()
+    self.small_model_item.action_item.set_enabled(offroad)
+    self.big_model_item.action_item.set_enabled(offroad)
+    self.small_model_item.set_description("" if offroad else tr("Only available when vehicle is off, or always offroad mode is on"))

  def _render(self, rect):
    self._scroller.render(rect)

  def show_event(self):
    self._scroller.show_event()
+    self._last_note = None  # re-expand the failover note every time the page opens
@@ -4,11 +4,14 @@ Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
 This file is part of sunnypilot and is licensed under the MIT License.
 See the LICENSE.md file in the root directory for more details.
 """
+import math
+
 import pyray as rl
 import time
 from dataclasses import dataclass
 from openpilot.selfdrive.ui.ui_state import ui_state
 from openpilot.sunnypilot.sunnylink.api import UNREGISTERED_SUNNYLINK_DONGLE_ID
+from openpilot.system.ui.lib.application import gui_app
 from openpilot.system.ui.lib.multilang import tr_noop


@@ -18,6 +21,9 @@ METRIC_MARGIN = 30
 METRIC_START_Y = 300
 HOME_BTN = rl.Rectangle(60, 860, 180, 180)

+EGPU_ICON_WIDTH = 180
+EGPU_ICON_HEIGHT = 133
+

 # Color scheme
 class Colors:
@@ -53,6 +59,10 @@ class MetricData:
 class SidebarSP:
  def __init__(self):
    self._sunnylink_status = MetricData(tr_noop("SUNNYLINK"), tr_noop("OFFLINE"), Colors.WARNING)
+    self._egpu_green_img = gui_app.texture("icons_mici/egpu_green.png", EGPU_ICON_WIDTH, EGPU_ICON_HEIGHT)
+    self._egpu_default_img = gui_app.texture("icons_mici/egpu.png", EGPU_ICON_WIDTH, EGPU_ICON_HEIGHT)
+    self._egpu_orange_img = gui_app.texture("icons_mici/egpu_orange.png", EGPU_ICON_WIDTH, EGPU_ICON_HEIGHT)
+    self._egpu_gray_img = gui_app.texture("icons_mici/egpu_gray.png", EGPU_ICON_WIDTH, EGPU_ICON_HEIGHT)

  def _update_sunnylink_status(self):
    if not ui_state.params.get_bool("SunnylinkEnabled"):
@@ -78,6 +88,29 @@ class SidebarSP:

    self._sunnylink_status.update(tr_noop("SUNNYLINK"), status, color)

+  def _get_home_icon(self, default_img: rl.Texture) -> tuple[rl.Texture, rl.Vector2, float]:
+    default_pos = rl.Vector2(HOME_BTN.x, HOME_BTN.y)
+    if not ui_state.sm["deviceState"].chestnutPresent:
+      return default_img, default_pos, 1.0
+
+    big_model_selected = ui_state.usbgpu_compiled or ui_state.model_runner_tinygrad
+    big_model_failed = ui_state.started and ui_state.big_model_failed
+    loading = ui_state.usbgpu_loading or (big_model_selected and ui_state.started and ui_state.usbgpu_active is None)
+
+    if loading:
+      icon = self._egpu_default_img
+      opacity = 0.35 + 0.65 * (0.5 - 0.5 * math.cos(rl.get_time() * 6.0))
+    elif big_model_selected and big_model_failed:
+      icon, opacity = self._egpu_orange_img, 1.0
+    elif big_model_selected:
+      icon, opacity = self._egpu_green_img, 1.0
+    else:
+      icon, opacity = self._egpu_gray_img, 1.0
+
+    x = HOME_BTN.x + (HOME_BTN.width - icon.width) / 2
+    y = HOME_BTN.y + (HOME_BTN.height - icon.height) / 2
+    return icon, rl.Vector2(x, y), opacity
+
  def _draw_metrics_w_sunnylink(self, rect: rl.Rectangle, _temp, _panda, _connect):
    metrics = [_temp, _panda, _connect, self._sunnylink_status]
    start_y = int(rect.y) + METRIC_START_Y
@@ -4,8 +4,14 @@ Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
 This file is part of sunnypilot and is licensed under the MIT License.
 See the LICENSE.md file in the root directory for more details.
 """
+import math
+
+import pyray as rl
+
 from openpilot.selfdrive.ui.mici.layouts.home import MiciHomeLayout
+from openpilot.selfdrive.ui.ui_state import ui_state
 from openpilot.system.ui.lib.application import FontWeight
+from openpilot.system.ui.widgets.icon_widget import IconWidget
 from openpilot.system.ui.widgets.label import UnifiedLabel


@@ -13,3 +19,35 @@ class MiciHomeLayoutSP(MiciHomeLayout):
  def __init__(self):
    super().__init__()
    self._openpilot_label = UnifiedLabel("sunnypilot", font_size=88, font_weight=FontWeight.AUDIOWIDE, max_width=480, wrap_text=False)
+    self._egpu_icon_default = IconWidget("icons_mici/egpu.png", (50, 37))
+    self._egpu_icon_default.set_visible(False)
+    self._egpu_icon_orange = IconWidget("icons_mici/egpu_orange.png", (50, 37))
+    self._egpu_icon_orange.set_visible(False)
+    gray_idx = self._status_bar_layout.widgets.index(self._egpu_icon_gray)
+    self._status_bar_layout.widgets.insert(gray_idx + 1, self._egpu_icon_default)
+    self._status_bar_layout.widgets.insert(gray_idx + 2, self._egpu_icon_orange)
+
+  def _set_egpu_visibility(self):
+    chestnut = ui_state.sm["deviceState"].chestnutPresent
+    if not chestnut:
+      self._egpu_icon.set_visible(False)
+      self._egpu_icon_default.set_visible(False)
+      self._egpu_icon_orange.set_visible(False)
+      self._egpu_icon_gray.set_visible(False)
+      return
+
+    big_model_selected = ui_state.usbgpu_compiled or ui_state.model_runner_tinygrad
+    big_model_failed = ui_state.started and ui_state.big_model_failed
+    loading = ui_state.usbgpu_loading or (big_model_selected and ui_state.started and ui_state.usbgpu_active is None)
+
+    if loading:
+      self._egpu_icon_default._opacity = 0.35 + 0.65 * (0.5 - 0.5 * math.cos(rl.get_time() * 6.0))
+      self._egpu_icon_default.set_visible(True)
+      self._egpu_icon.set_visible(False)
+      self._egpu_icon_orange.set_visible(False)
+      self._egpu_icon_gray.set_visible(False)
+    else:
+      self._egpu_icon_default.set_visible(False)
+      self._egpu_icon.set_visible(big_model_selected and not big_model_failed)
+      self._egpu_icon_orange.set_visible(big_model_selected and big_model_failed)
+      self._egpu_icon_gray.set_visible(not big_model_selected)
@@ -7,16 +7,37 @@ See the LICENSE.md file in the root directory for more details.
 import pyray as rl

 from openpilot.cereal import custom
-from openpilot.sunnypilot.models.default_model import DEFAULT_MODEL
+from openpilot.selfdrive.ui.mici.widgets.dialog import BigDialog
+from openpilot.sunnypilot.models.helpers import ACTIVE_BUNDLE_KEYS, get_selected_bundle
 from openpilot.selfdrive.ui.mici.widgets.button import BigButton
-from openpilot.selfdrive.ui.sunnypilot.layouts.settings.models import ModelsLayout
 from openpilot.selfdrive.ui.ui_state import ui_state, device
+from openpilot.selfdrive.ui.sunnypilot.model_info import (active_source, big_model_state, bundles_for_source, carrying_model,
+                                                           default_model_name, model_info, queued_name)
 from openpilot.system.ui.lib.application import FontWeight, gui_app
 from openpilot.system.ui.lib.multilang import tr
 from openpilot.system.ui.widgets import Widget
 from openpilot.system.ui.widgets.label import UnifiedLabel
 from openpilot.system.ui.widgets.scroller import NavScroller

+def _model_info() -> tuple[str, str, str]:
+  """(active model, info header, info text) for the panel. Runner-matched: the
+  active line names what actually drives, and a notable big-model state takes
+  the info pair."""
+  source, active_name, other_name = model_info()
+  state = big_model_state()
+  _, _, carry_display = carrying_model()
+  if carry_display is None:
+    big = get_selected_bundle(ui_state.params, "usbgpu")
+    carry_display = big.displayName if big else default_model_name("usbgpu")
+  active_text = (carry_display or active_name).lower()
+  if state == 'failed':
+    return active_text, tr("big model"), tr("unavailable")
+  if state == 'loading':
+    return active_text, tr("big model"), tr("getting ready")
+  header = tr("small model") if source == "usbgpu" else tr("big model")
+  return active_text, header, other_name.lower()
+
+
 class CurrentModelInfo(Widget):
  def __init__(self):
    super().__init__()
@@ -26,12 +47,12 @@ class CurrentModelInfo(Widget):
    header_color = rl.Color(255, 255, 255, int(255 * 0.9))
    subheader_color = rl.Color(255, 255, 255, int(255 * 0.9 * 0.65))
    max_width = int(self._rect.width - 20)
+    active_text, info_header, info_text = _model_info()
    self.current_model_header = UnifiedLabel(tr("active model"), 48, max_width=max_width, text_color=header_color, font_weight=FontWeight.DISPLAY)
-    default_text = f"{DEFAULT_MODEL} (Default)".lower()
-    self.current_model_text = UnifiedLabel(default_text, 32, max_width=max_width, text_color=subheader_color, font_weight=FontWeight.ROMAN, scroll=True)
+    self.current_model_text = UnifiedLabel(active_text, 32, max_width=max_width, text_color=subheader_color, font_weight=FontWeight.ROMAN, scroll=True)

-    self.info_header = UnifiedLabel("cache size", 48, max_width=max_width, text_color=header_color, font_weight=FontWeight.DISPLAY)
-    self.info_text = UnifiedLabel("0 mb", 32, max_width=max_width, text_color=subheader_color, font_weight=FontWeight.ROMAN)
+    self.info_header = UnifiedLabel(info_header, 48, max_width=max_width, text_color=header_color, font_weight=FontWeight.DISPLAY)
+    self.info_text = UnifiedLabel(info_text, 32, max_width=max_width, text_color=subheader_color, font_weight=FontWeight.ROMAN, scroll=True)

  def _render(self, _):
    self.current_model_header.set_position(self._rect.x + 20, self._rect.y - 10)
@@ -55,12 +76,13 @@ class ModelsLayoutMici(NavScroller):
    self._download_progress = "."
    self._download_frame = 0
    self._was_downloading = False
+    self._selection_source: str | None = None

    self.select_model_btn = BigButton(tr("select model"))
    self.select_model_btn.set_click_callback(self._show_folders)

    self.cancel_download_btn = BigButton(tr("cancel download"))
-    self.cancel_download_btn.set_click_callback(lambda: ui_state.params.remove("ModelManager_DownloadIndex"))
+    self.cancel_download_btn.set_click_callback(lambda: ui_state.params.remove("ModelManager_DownloadRef"))

    self.main_items = [self.current_model_info, self.select_model_btn, self.cancel_download_btn]
    self._scroller.add_widgets(self.main_items)
@@ -69,8 +91,7 @@ class ModelsLayoutMici(NavScroller):
  def model_manager(self):
    return ui_state.sm["modelManagerSP"]

-  def _get_grouped_bundles(self, favorites = None):
-    bundles = self.model_manager.availableBundles
+  def _get_grouped_bundles(self, bundles, favorites = None):
    folders = {}
    for bundle in bundles:
      folder = next((override.value for override in bundle.overrides if override.key == "folder"), "")
@@ -90,47 +111,70 @@ class ModelsLayoutMici(NavScroller):
  def _show_folders(self):
    self.focused_widget = self.select_model_btn

+    hardware_btns = []
+    active = active_source()
+    for source, label in (("qcom", tr("small models")), ("usbgpu", tr("big models"))):
+      bundle = get_selected_bundle(ui_state.params, source)
+      value = (bundle.internalName if bundle else default_model_name(source)).lower()
+      if source == active:
+        value += f" ({tr('active')})"
+      btn = BigButton(label.lower(), value=value)
+      btn.set_click_callback(lambda s=source: self._select_hardware(s))
+      hardware_btns.append(btn)
+    self._push_selection_view(hardware_btns)
+
+  def _select_hardware(self, source):
+    self._selection_source = source
+
    favs = ui_state.params.get("ModelManager_Favs")
    favorites = set(favs.split(';')) if favs else set()

-    folders = self._get_grouped_bundles(favorites)
+    bundles = bundles_for_source(source)
+    if not bundles:
+      gui_app.push_widget(BigDialog(title=tr("No models available"),
+                                    description=tr("No models are available for this hardware yet. Connect to the internet and refresh the model list.")))
+      return
+    folders = self._get_grouped_bundles(bundles, favorites)
+
    folder_buttons = []
-    default_btn = BigButton(f"{DEFAULT_MODEL} (Default)".lower())
-    default_btn.set_click_callback(self._select_default)
+    default_btn = BigButton(default_model_name(source).lower())
+    default_btn.set_click_callback(lambda s=source: self._select_default(s))
    folder_buttons.append(default_btn)

    for folder in sorted(folders.keys(), key=lambda f: max((bundle.index for bundle in folders[f]), default=-1), reverse=True):
-      if folder.lower() in ["release models", "master models", "favorites"]:
-        btn = BigButton(folder.lower())
-        btn.set_click_callback(lambda f=folder: self._select_folder(f))
-        if folder.lower() == "favorites":
-          folder_buttons.insert(0, btn)
-        else:
-          folder_buttons.append(btn)
+      btn = BigButton(folder.lower())
+      btn.set_click_callback(lambda f=folder: self._select_folder(f))
+      if folder.lower() == "favorites":
+        folder_buttons.insert(0, btn)
+      else:
+        folder_buttons.append(btn)
    self._push_selection_view(folder_buttons)

  def _pop_to_main(self):
    gui_app.pop_widgets_to(self)
+    self._scroller.scroll_panel.set_offset(0.0)

  def _select_model(self, bundle):
-    ui_state.params.put("ModelManager_DownloadIndex", bundle.index)
+    ui_state.params.put("ModelManager_DownloadRef", bundle.ref)
    self._pop_to_main()

-  def _select_default(self):
-    ui_state.params.remove("ModelManager_ActiveBundle")
+  def _select_default(self, source):
+    ui_state.params.remove(ACTIVE_BUNDLE_KEYS[source])
    self._pop_to_main()

  def _select_folder(self, folder_name):
+    source = self._selection_source
+    if source is None:  # folders are only reachable after picking a hardware
+      return
    favs = ui_state.params.get("ModelManager_Favs")
    favorites = set(favs.split(';')) if favs else set()

-    folders = self._get_grouped_bundles(favorites)
+    folders = self._get_grouped_bundles(bundles_for_source(source), favorites)
    bundles = sorted(folders.get(folder_name, []), key=lambda b: b.index, reverse=True)

    btns = []
    for bundle in bundles:
-      txt = bundle.displayName.lower()
-      btn = BigButton(txt)
+      btn = BigButton(bundle.displayName.lower())
      btn.set_click_callback(lambda b=bundle: self._select_model(b))
      btns.append(btn)
    self._push_selection_view(btns)
@@ -162,10 +206,10 @@ class ModelsLayoutMici(NavScroller):
    self._was_downloading = is_downloading

    self.current_model_info.current_model_header.set_text(tr("active model"))
-    model_text = manager.activeBundle.displayName.lower() if manager.activeBundle.ref else f"{DEFAULT_MODEL} (Default)".lower()
-    self.current_model_info.current_model_text.set_text(model_text)
-    self.current_model_info.info_header.set_text(tr("cache size"))
-    self.current_model_info.info_text.set_text(f"{ModelsLayout.calculate_cache_size():.2f} MB")
+    active_text, info_header, info_text = _model_info()
+    self.current_model_info.current_model_text.set_text(active_text)
+    self.current_model_info.info_header.set_text(info_header)
+    self.current_model_info.info_text.set_text(info_text)

    if manager.selectedBundle and manager.selectedBundle.status == custom.ModelManagerSP.DownloadStatus.failed:
      self.current_model_info.info_header.set_text(tr("error") + self._download_progress)
@@ -176,19 +220,29 @@ class ModelsLayoutMici(NavScroller):
      device.set_override_interactive_timeout(5)
      progress = 0.0
      count = 0
+      verifying = False
      for model in manager.selectedBundle.models:
        count += 1
        p = model.artifact.downloadProgress
-        if p.status == custom.ModelManagerSP.DownloadStatus.downloading:
+        if p.status in (custom.ModelManagerSP.DownloadStatus.downloading,
+                        custom.ModelManagerSP.DownloadStatus.verifying):
          progress += p.progress
+          verifying = verifying or p.status == custom.ModelManagerSP.DownloadStatus.verifying
        elif p.status in (custom.ModelManagerSP.DownloadStatus.downloaded,
                          custom.ModelManagerSP.DownloadStatus.cached):
          progress += 100.0

-      self.current_model_info.current_model_header.set_text(tr("downloading"))
+      self.current_model_info.current_model_header.set_text(tr("verifying") if verifying else tr("downloading"))
+      self.cancel_download_btn.set_text(tr("cancel verification") if verifying else tr("cancel download"))
      self.current_model_info.current_model_header._shimmer = True
-      self.current_model_info.current_model_text.set_text(f"{manager.selectedBundle.internalName.lower()}")
+      name_text = manager.selectedBundle.internalName.lower()
+      if queued := queued_name(manager.selectedBundle.ref):
+        name_text += f"  |  {queued.lower()} {tr('queued')}"
+      self.current_model_info.current_model_text.set_text(name_text)
      self.current_model_info.info_header.set_text(tr("progress") + self._download_progress)
      self.current_model_info.info_header._shimmer = True
      self.current_model_info.info_text.set_text(f"{progress/count:.2f}%")

+    elif manager.selectedBundle and manager.selectedBundle.status == custom.ModelManagerSP.DownloadStatus.downloaded:
+      self.current_model_info.info_header.set_text(tr("downloaded"))
+      self.current_model_info.info_text.set_text(tr("downloaded"))
@@ -12,13 +12,23 @@ from openpilot.selfdrive.ui.mici.widgets.dialog import BigConfirmationDialog, Bi
 from openpilot.selfdrive.ui.sunnypilot.mici.layouts.sunnylink import SunnylinkLayoutMici
 from openpilot.selfdrive.ui.sunnypilot.mici.layouts.models import ModelsLayoutMici
 from openpilot.selfdrive.ui.ui_state import ui_state
-from openpilot.system.ui.lib.application import gui_app
+from openpilot.system.ui.lib.application import gui_app, FontWeight
 from openpilot.system.ui.lib.multilang import tr

 ICON_SIZE = 70
 BIG_ICON_SIZE = 110


+class SunnylinkBigButton(SettingsBigButton):
+  def __init__(self, *args, **kwargs):
+    super().__init__(*args, **kwargs)
+    self._label.set_font_weight(FontWeight.AUDIOWIDE)
+
+  def _get_label_font_size(self):
+    # Audiowide runs wider than Inter: "sunnylink" wraps to two lines at 64
+    return 56
+
+
 class SettingsLayoutSP(OP.SettingsLayout):
  def __init__(self):
    OP.SettingsLayout.__init__(self)
@@ -33,7 +43,7 @@ class SettingsLayoutSP(OP.SettingsLayout):
    self.icon_offroad_slider = gui_app.texture("icons_mici/settings/device/lkas.png", BIG_ICON_SIZE, BIG_ICON_SIZE)

    sunnylink_panel = SunnylinkLayoutMici()
-    sunnylink_btn = SettingsBigButton(tr("sunnylink"), "", gui_app.texture("icons_mici/settings/developer/ssh.png", 55, 55))
+    sunnylink_btn = SunnylinkBigButton(tr("sunnylink"), "", gui_app.texture("../../sunnypilot/selfdrive/assets/icons_mici/sunnylink.png", 76, 44))
    sunnylink_btn.set_click_callback(lambda: gui_app.push_widget(sunnylink_panel))

    models_panel = ModelsLayoutMici()
@@ -56,8 +66,8 @@ class SettingsLayoutSP(OP.SettingsLayout):

    items = self._scroller._items.copy()

-    items.insert(1, sunnylink_btn)
-    items.insert(2, models_btn)
+    items.insert(1, models_btn)
+    items.insert(5, sunnylink_btn)

    # front slots (only one ever visible at a time): exit-always-offroad, then enable-onroad
    items.insert(0, self._enable_offroad_btn_onroad)
@@ -7,6 +7,7 @@ See the LICENSE.md file in the root directory for more details.
 import pyray as rl

 from openpilot.selfdrive.ui.mici.onroad.hud_renderer import HudRenderer
+from openpilot.selfdrive.ui.ui_state import ui_state
 from openpilot.selfdrive.ui.sunnypilot.onroad.blind_spot_indicators import BlindSpotIndicators


@@ -21,6 +22,8 @@ class HudRendererSP(HudRenderer):

  def _render(self, rect: rl.Rectangle) -> None:
    super()._render(rect)
+    if ui_state.usbgpu and not ui_state.usbgpu_compiled and ui_state.model_runner_tinygrad:
+      self._draw_model_source(rect)
    self.blind_spot_indicators.render(rect)

  def _has_blind_spot_detected(self) -> bool:
@@ -0,0 +1,88 @@
+"""
+Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
+
+This file is part of sunnypilot and is licensed under the MIT License.
+See the LICENSE.md file in the root directory for more details.
+"""
+from openpilot.selfdrive.ui.ui_state import ui_state
+from openpilot.sunnypilot.models.fetcher import get_cached_bundles
+from openpilot.sunnypilot.models.helpers import get_active_source, get_selected_bundle, resolve_bundle_by_ref
+from openpilot.sunnypilot.models.model_name import DEFAULT_BIG_MODEL, DEFAULT_MODEL
+
+
+def active_source() -> str:
+  return get_active_source(usbgpu=ui_state.usbgpu,
+                           usbgpu_active=ui_state.usbgpu_active, usbgpu_loading=ui_state.usbgpu_loading,
+                           offroad=ui_state.is_offroad())
+
+
+def bundles_for_source(source: str):
+  if source == active_source():
+    return ui_state.sm["modelManagerSP"].availableBundles
+  return get_cached_bundles(ui_state.params, source)
+
+
+def default_model(source: str) -> str:
+  return DEFAULT_BIG_MODEL if source == 'usbgpu' else DEFAULT_MODEL
+
+
+def default_model_name(source: str) -> str:
+  return f"{default_model(source)} (Default)"
+
+
+def big_model_state() -> str | None:
+  """'failed' | 'loading' | None, mirroring the sidebar's detection (#1969)."""
+  if ui_state.started and ui_state.usbgpu and ui_state.big_model_failed:
+    return 'failed'
+  big_selected = ui_state.usbgpu_compiled or ui_state.model_runner_tinygrad
+  if ui_state.usbgpu_loading or (big_selected and ui_state.started and ui_state.usbgpu_active is None):
+    return 'loading'
+  return None
+
+
+def carrying_model() -> tuple[str | None, str | None, str | None]:
+  """(source, internal name, display name) of what actually drives. Runner-matched:
+  when a Default big cannot carry, stock modeld runs the Default small, never the
+  small slot's pick; a custom big has no automatic fallback yet -> (None, None, None)."""
+  source = active_source()
+  if source == "usbgpu":
+    bundle = get_selected_bundle(ui_state.params, "usbgpu")
+    if bundle:
+      return "usbgpu", bundle.internalName, bundle.displayName
+    name = default_model_name("usbgpu")
+    return "usbgpu", name, name
+  if ui_state.usbgpu:
+    if get_selected_bundle(ui_state.params, "usbgpu") is None:
+      name = default_model_name("qcom")
+      return "qcom", name, name
+    return None, None, None
+  bundle = get_selected_bundle(ui_state.params, "qcom")
+  if bundle:
+    return "qcom", bundle.internalName, bundle.displayName
+  name = default_model_name("qcom")
+  return "qcom", name, name
+
+
+def queued_name(current_ref) -> str | None:
+  ref = ui_state.params.get("ModelManager_DownloadRef")
+  if ref and ref != current_ref:
+    source_bundles = {source: bundles_for_source(source) for source in ("qcom", "usbgpu")}
+    if resolved := resolve_bundle_by_ref(ref, source_bundles):
+      return resolved[0].internalName
+  return None
+
+
+def model_info() -> tuple[str, str, str]:
+  """returns (active source, active model name, other model name)
+
+  Names come from the params slots, never modelManagerSP.activeBundle — the
+  manager republishes a tick after a chestnut change, so the stale bundle
+  would flash the wrong model."""
+  source = active_source()
+  other = "qcom" if source == "usbgpu" else "usbgpu"
+  active_bundle = get_selected_bundle(ui_state.params, source)
+  other_bundle = get_selected_bundle(ui_state.params, other)
+
+  active_name = active_bundle.displayName if active_bundle else default_model_name(source)
+  other_name = other_bundle.displayName if other_bundle else default_model_name(other)
+  return source, active_name, other_name
@@ -4,11 +4,29 @@ Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
 This file is part of sunnypilot and is licensed under the MIT License.
 See the LICENSE.md file in the root directory for more details.
 """
+from openpilot.common.filter_simple import FirstOrderFilter
+from openpilot.selfdrive.ui.ui_state import ui_state, UIStatus
 from openpilot.selfdrive.ui.sunnypilot.onroad.chevron_metrics import ChevronMetrics
 from openpilot.selfdrive.ui.sunnypilot.onroad.rainbow_path import RainbowPath
+from openpilot.selfdrive.ui.sunnypilot.ui_state import MADSState
+from openpilot.system.ui.lib.application import gui_app


 class ModelRendererSP:
  def __init__(self):
    self.rainbow_path = RainbowPath()
    self.chevron_metrics = ChevronMetrics()
+    self._width_filter = FirstOrderFilter(0.9, 0.1, 1 / gui_app.target_fps)
+
+  @property
+  def _lateral_active(self) -> bool:
+    sm = ui_state.sm
+    if sm.valid["selfdriveStateSP"]:
+      mads = sm["selfdriveStateSP"].mads
+      if mads.available:
+        return mads.enabled and mads.state != MADSState.paused
+    return ui_state.status in (UIStatus.ENGAGED, UIStatus.LAT_ONLY)
+
+  def _get_path_half_width(self) -> float:
+    target = 0.9 if self._lateral_active else 0.40
+    return self._width_filter.update(target)
@@ -10,6 +10,7 @@ from openpilot.cereal import messaging, log, custom
 from opendbc.car.structs import car
 from openpilot.common.params import Params
 from openpilot.selfdrive.ui.sunnypilot.layouts.settings.display import OnroadBrightness
+from openpilot.sunnypilot.models.helpers import ACTIVE_BUNDLE_KEYS, get_active_source
 from openpilot.sunnypilot.sunnylink.sunnylink_state import SunnylinkState
 from openpilot.system.ui.lib.application import gui_app
 from openpilot.system.ui.sunnypilot.widgets.screen_saver import ScreenSaverSP
@@ -43,6 +44,7 @@ class UIStateSP:
    self.screensaver_enabled: bool = False

    self.active_bundle = None
+    self.model_runner_tinygrad: bool = False
    self.blindspot: bool = False
    self.chevron_metrics = None
    self.custom_interactive_timeout: int = 0
@@ -150,7 +152,10 @@ class UIStateSP:
      self.has_icbm = self.CP_SP.intelligentCruiseButtonManagementAvailable and self.params.get_bool("IntelligentCruiseButtonManagement")

    self._enforce_constraints()
-    self.active_bundle = self.params.get("ModelManager_ActiveBundle")
+    source = get_active_source(usbgpu=self.usbgpu, usbgpu_active=self.usbgpu_active,
+                               usbgpu_loading=self.usbgpu_loading, offroad=self.is_offroad())
+    self.active_bundle = self.params.get(ACTIVE_BUNDLE_KEYS[source])
+    self.model_runner_tinygrad = self.active_bundle is not None and self.active_bundle.get("runner") == "tinygrad"
    self.blindspot = self.params.get_bool("BlindSpot")
    self.chevron_metrics = self.params.get("ChevronInfo")
    self.custom_interactive_timeout = self.params.get("InteractivityTimeout", return_default=True)
@@ -1,21 +0,0 @@
-from types import SimpleNamespace
-from unittest.mock import Mock
-
-from opendbc.car.structs import car
-
-from openpilot.selfdrive.ui.sunnypilot.custom_button import CustomButtonAction, handle_custom_button
-
-
-def test_custom_button_actions():
-  params = Mock()
-  press = SimpleNamespace(carState=SimpleNamespace(buttonEvents=[SimpleNamespace(
-      type=car.CarState.ButtonEvent.Type.altButton2,
-      pressed=True,
-    )]))
-  messages = [press, SimpleNamespace(carState=SimpleNamespace(buttonEvents=[])), press]
-  callbacks = {action: Mock() for action in CustomButtonAction if action != CustomButtonAction.NONE}
-
-  for action, callback in callbacks.items():
-    params.get.return_value = action
-    handle_custom_button(messages, params, callbacks)
-    assert callback.call_count == 2
@@ -20,14 +20,14 @@ class TestSoundd(OpenpilotTestCase):
    sm.update(100)
    assert sm.updated['selfdriveState']

-    received_at = sm.recv_time['selfdriveState']
-    clock = mocker.patch("openpilot.selfdrive.ui.soundd.time.monotonic", return_value=received_at + SELFDRIVE_STATE_TIMEOUT)
+    sm.recv_time['selfdriveState'] = 0
+    clock = mocker.patch("openpilot.selfdrive.ui.soundd.time.monotonic", return_value=SELFDRIVE_STATE_TIMEOUT)
    assert not check_selfdrive_timeout_alert(sm)

-    clock.return_value = received_at + SELFDRIVE_STATE_TIMEOUT + 0.1
+    clock.return_value = SELFDRIVE_STATE_TIMEOUT + 0.1
    assert check_selfdrive_timeout_alert(sm)

-    clock.return_value = received_at + SELFDRIVE_STATE_TIMEOUT + 10
+    clock.return_value = SELFDRIVE_STATE_TIMEOUT + 10
    assert not check_selfdrive_timeout_alert(sm)

  def test_check_selfdrive_timeout_alert_mads_lateral_only(self):
@@ -112,6 +112,15 @@ class UIState(UIStateSP):
  def add_on_body_changed_callbacks(self, callback: Callable[[], None]):
    self._on_body_changed_callbacks.append(callback)

+  @property
+  def big_model_failed(self) -> bool:
+    # Mirrors the onroad HUD's four-condition check so sidebar and home icons reflect the same failure states
+    return (self.usbgpu_active is False or
+            not self.sm['deviceState'].chestnutPresent or
+            (self.usbgpu_active is True and self.sm.recv_frame['modelV2'] > self.started_frame and
+             not self.sm.alive['modelV2']) or
+            (self.usbgpu_active is None and self.sm.recv_frame['modelV2'] > self.started_frame))
+
  @property
  def engaged(self) -> bool:
    return self.started and (self.sm["selfdriveState"].enabled or self.sm["selfdriveStateSP"].mads.enabled)
@@ -1,3 +1,2 @@
 SConscript(['common/transformations/SConscript'])
-SConscript(['modeld_v2/SConscript'])
 SConscript(['selfdrive/locationd/SConscript'])
@@ -8,7 +8,10 @@ from openpilot.common.params import Params


 def get_lat_delay(params: Params, stock_lat_delay: float) -> float:
-  if params.get_bool("LagdToggle"):
-    return float(params.get("LagdValueCache", return_default=True))
+# live learning on: use what lagd publishes.
+# off: use the fixed steerActuatorDelay + software delay sum that LagdToggle caches.

-  return stock_lat_delay
+  if params.get_bool("LagdToggle"):
+    return stock_lat_delay
+
+  return float(params.get("LagdValueCache", return_default=True))
@@ -1,84 +0,0 @@
-import os
-import glob
-
-from openpilot.common.transformations.camera import _ar_ox_fisheye, _os_fisheye
-from openpilot.common.transformations.model import MEDMODEL_INPUT_SIZE
-from openpilot.common.hardware import HARDWARE, PC
-
-Import('env', 'arch', 'release')
-lenv = env.Clone()
-tinygrad_files = ["#"+x for x in glob.glob(env.Dir("#tinygrad_repo").relpath + "/**", recursive=True, root_dir=env.Dir("#").abspath) if 'pycache' not in x]
-
-
-def get_camera_configs():
-  DEVICE_RESOLUTIONS = {
-    "tici": (_ar_ox_fisheye.width, _ar_ox_fisheye.height),
-    "tizi": (_ar_ox_fisheye.width, _ar_ox_fisheye.height),
-    "mici": (_os_fisheye.width, _os_fisheye.height),
-  }
-  if release or PC or 'CI' in os.environ:
-    return set(DEVICE_RESOLUTIONS.values())
-  return [DEVICE_RESOLUTIONS[HARDWARE.get_device_type()]]
-
-CAMERA_CONFIGS = get_camera_configs()
-
-tg_flags = {
-  'larch64': 'DEV=QCOM FLOAT16=1 NOLOCALS=1 JIT_BATCH_SIZE=0',
-  'Darwin': f'DEV=CPU HOME={os.path.expanduser("~")}',
-}.get(arch, 'DEV=CPU:LLVM')
-
-image_flag = {
-  'larch64': 'IMAGE=2',
-}.get(arch, 'IMAGE=0')
-
-model_w, model_h = MEDMODEL_INPUT_SIZE
-from openpilot.selfdrive.modeld.constants import ModelConstants
-frame_skip = ModelConstants.MODEL_RUN_FREQ // ModelConstants.MODEL_CONTEXT_FREQ
-camera_res_args = ' '.join(f'{cw}x{ch}' for cw, ch in CAMERA_CONFIGS)
-
-pythonpath_string = 'PYTHONPATH="${PYTHONPATH}:' + env.Dir("#tinygrad_repo").abspath + ':' + env.Dir("#").abspath + '"'
-compile_modeld_script = File("compile_modeld.py").abspath
-upstream_compile_script = File(Dir("#openpilot/selfdrive/modeld").File("compile_modeld.py").abspath)
-script_deps = [File("compile_modeld.py"), upstream_compile_script]
-
-def compile_combined(model_type, onnx_args, output_name):
-  output_pkl = File(f"models/{output_name}").abspath
-  cmd = (f'{pythonpath_string} {tg_flags} {image_flag} python3 {compile_modeld_script} '
-         f'--model-type {model_type} '
-         f'--model-size {model_w}x{model_h} '
-         f'--camera-resolutions {camera_res_args} '
-         f'{onnx_args} '
-         f'--frame-skip {frame_skip} '
-         f'--output {output_pkl}')
-  onnx_files = [f for f in onnx_args.split() if f.endswith('.onnx')]
-  return lenv.Command(output_pkl, tinygrad_files + script_deps + [File(f) for f in onnx_files if os.path.isfile(f)], cmd)
-
-# Vision + Policy (stock default model)
-vision_onnx = File("models/driving_vision.onnx").abspath
-policy_onnx = File("models/driving_policy.onnx").abspath
-if os.path.isfile(vision_onnx) and os.path.isfile(policy_onnx):
-  compile_combined('vision_policy',
-                   f'--vision-onnx {vision_onnx} --policy-onnx {policy_onnx}',
-                   'driving_combined_tinygrad.pkl')
-
-# Vision + Off-Policy
-off_policy_onnx = File("models/driving_off_policy.onnx").abspath
-if os.path.isfile(vision_onnx) and os.path.isfile(off_policy_onnx):
-  policy_arg = f'--policy-onnx {policy_onnx}' if os.path.isfile(policy_onnx) else ''
-  compile_combined('vision_multi_policy',
-                   f'--vision-onnx {vision_onnx} {policy_arg} --off-policy-onnx {off_policy_onnx}',
-                   'driving_combined_multi_tinygrad.pkl')
-
-# Vision + On-Policy + Off-Policy
-on_policy_onnx = File("models/driving_on_policy.onnx").abspath
-if os.path.isfile(vision_onnx) and os.path.isfile(on_policy_onnx) and os.path.isfile(off_policy_onnx):
-  compile_combined('vision_multi_policy',
-                   f'--vision-onnx {vision_onnx} --off-policy-onnx {off_policy_onnx} --on-policy-onnx {on_policy_onnx}',
-                   'driving_combined_tri_tinygrad.pkl')
-
-# Supercombo
-supercombo_onnx = File("models/supercombo.onnx").abspath
-if os.path.isfile(supercombo_onnx):
-  compile_combined('supercombo',
-                   f'--supercombo-onnx {supercombo_onnx}',
-                   'driving_combined_supercombo_tinygrad.pkl')
@@ -7,11 +7,12 @@ See the LICENSE.md file in the root directory for more details.
 """

 import argparse
+import math
 import os
-import pickle
+import tempfile
 import time
-from collections import defaultdict
 from functools import partial
+from openpilot.selfdrive.modeld.helpers import dump_oob, load_oob
 import numpy as np
 os.environ['GMMU'] = '0'

@@ -38,6 +39,9 @@ from tinygrad.engine.jit import TinyJit
 from tinygrad.tensor import Tensor

 MODEL_TYPES = ('vision_policy', 'supercombo', 'vision_multi_policy')
+WARP_INPUTS = ['tfm', 'big_tfm']
+POLICY_INPUTS = ['img_q', 'big_img_q', 'feat_q', 'desire_q', 'packed_npy_inputs']
+WARP_DEV = os.getenv('WARP_DEV')


 def _detect_desire_key(shapes: dict) -> str | None:
@@ -63,20 +67,21 @@ def get_policy_npy_shapes(input_shapes: dict, is_supercombo: bool = False) -> tu
  if desire_key:
    shapes['desire'] = (input_shapes[desire_key][2],)

-  if is_supercombo and 'features_buffer' in input_shapes:
-    fb = input_shapes['features_buffer']
-    shapes['prev_feat'] = (fb[0], fb[2])
-
  for key, shape in input_shapes.items():
    if key not in (desire_key, 'features_buffer') and 'img' not in key:
      shapes[key] = tuple(shape)

+  if is_supercombo and 'features_buffer' in input_shapes:
+    fb = input_shapes['features_buffer']
+    feat_dim = math.prod(fb[2:])
+    shapes['prev_feat'] = (fb[0], feat_dim)
+
  sizes = [int(np.prod(size)) for size in shapes.values()]
  return shapes, sizes


 def generate_queues_and_npy(input_shapes: dict, frame_skip: int, device: str = Device.DEFAULT,
-                            is_supercombo: bool = False, use_packed: bool = True) -> tuple[dict, dict]:
+                            is_supercombo: bool = False) -> tuple[dict, dict]:
  road_key, _ = _detect_vision_keys(input_shapes)
  if not road_key:
    raise ValueError("Vision road key missing from input shapes.")
@@ -92,74 +97,77 @@ def generate_queues_and_npy(input_shapes: dict, frame_skip: int, device: str = D
  desire_shape = input_shapes[desire_key]
  features_buffer = input_shapes.get('features_buffer')

-  if use_packed:  # remove packed detection block after all models are recompiled
-    npy_arrays = {
-      'tfm': np.zeros((3, 3), dtype=np.float32),
-      'big_tfm': np.zeros((3, 3), dtype=np.float32)
-    }
+  npy_arrays = {
+    'tfm': np.zeros((3, 3), dtype=np.float32),
+    'big_tfm': np.zeros((3, 3), dtype=np.float32)
+  }

-    shapes, sizes = get_policy_npy_shapes(input_shapes, is_supercombo=is_supercombo)
-    packed_npy_inputs = np.zeros(sum(sizes), dtype=np.float32)
+  shapes, sizes = get_policy_npy_shapes(input_shapes, is_supercombo=is_supercombo)
+  packed_npy_inputs = np.zeros(sum(sizes), dtype=np.float32)

-    split_indices = np.cumsum(sizes[:-1]) if len(sizes) > 1 else []
-    split_views = np.split(packed_npy_inputs, split_indices) if len(sizes) > 0 else []
-    for (k, s), v in zip(shapes.items(), split_views, strict=True):
-      npy_arrays[k] = v.reshape(s)
+  split_indices = np.cumsum(sizes[:-1]) if len(sizes) > 1 else []
+  split_views = np.split(packed_npy_inputs, split_indices) if len(sizes) > 0 else []
+  for (k, s), v in zip(shapes.items(), split_views, strict=True):
+    npy_arrays[k] = v.reshape(s)

-    queues = {
-      'img_q': Tensor(np.zeros(img_buf_shape, dtype=np.uint8), device=device).contiguous().realize(),
-      'big_img_q': Tensor(np.zeros(img_buf_shape, dtype=np.uint8), device=device).contiguous().realize(),
-      'desire_q': Tensor(np.zeros((frame_skip * desire_shape[1], desire_shape[0], desire_shape[2]),
-                    dtype=np.float32), device=device).contiguous().realize(),
-      'packed_npy_inputs': Tensor(packed_npy_inputs, device='NPY').realize(),
-    }
+  queues = {
+    'img_q': Tensor(np.zeros(img_buf_shape, dtype=np.uint8), device=device).contiguous().realize(),
+    'big_img_q': Tensor(np.zeros(img_buf_shape, dtype=np.uint8), device=device).contiguous().realize(),
+    'desire_q': Tensor(np.zeros((frame_skip * desire_shape[1], desire_shape[0], desire_shape[2]),
+                  dtype=np.float32), device=device).contiguous().realize(),
+    'packed_npy_inputs': Tensor(packed_npy_inputs, device='NPY').realize(),
+  }

-    if features_buffer:
-      queues['feat_q'] = Tensor(np.zeros((frame_skip * (features_buffer[1] - 1) + 1, features_buffer[0], features_buffer[2]),
-                         dtype=np.float32), device=device).contiguous().realize()
+  if features_buffer:
+    feat_dim = math.prod(features_buffer[2:])
+    feat_q_len = frame_skip * features_buffer[1] if is_supercombo else frame_skip * (features_buffer[1] - 1) + 1
+    queues['feat_q'] = Tensor(np.zeros((feat_q_len, features_buffer[0], feat_dim),
+                       dtype=np.float32), device=device).contiguous().realize()

-    queues.update({key: Tensor(value, device='NPY').realize() for key, value in npy_arrays.items() if key in ('tfm', 'big_tfm')})
-  else:
-    # TODO-SP: Remove legacy queuing fallback else block after all models are recompiled
-    npy_arrays = {
-      'desire': np.zeros(desire_shape[2], dtype=np.float32),
-      'tfm': np.zeros((3, 3), dtype=np.float32),
-      'big_tfm': np.zeros((3, 3), dtype=np.float32)
-    }
-
-    for key, shape in input_shapes.items():
-      if key not in npy_arrays and 'img' not in key and key not in ('features_buffer', desire_key):
-        npy_arrays[key] = np.zeros(shape, dtype=np.float32)
-
-    queues = {
-      'img_q': Tensor(np.zeros(img_buf_shape, dtype=np.uint8), device=device).contiguous().realize(),
-      'big_img_q': Tensor(np.zeros(img_buf_shape, dtype=np.uint8), device=device).contiguous().realize(),
-      'desire_q': Tensor(np.zeros((frame_skip * desire_shape[1], desire_shape[0], desire_shape[2]),
-                    dtype=np.float32), device=device).contiguous().realize()
-    }
-
-    if features_buffer:
-      queues['feat_q'] = Tensor(np.zeros((frame_skip * (features_buffer[1] - 1) + 1, features_buffer[0], features_buffer[2]),
-                         dtype=np.float32), device=device).contiguous().realize()
-
-    queues.update({key: Tensor(value, device='NPY').realize() for key, value in npy_arrays.items()})
+  queues.update({key: Tensor(value, device='NPY').realize() for key, value in npy_arrays.items() if key in ('tfm', 'big_tfm')})

  return queues, npy_arrays


 def make_split_input_queues(vision_input_shapes: dict, policy_input_shapes: dict,
-                            frame_skip: int, device: str = Device.DEFAULT, use_packed: bool = True) -> tuple[dict, dict]:
-  return generate_queues_and_npy({**vision_input_shapes, **policy_input_shapes}, frame_skip, device, is_supercombo=False, use_packed=use_packed)
+                            frame_skip: int, device: str = Device.DEFAULT) -> tuple[dict, dict]:
+  return generate_queues_and_npy({**vision_input_shapes, **policy_input_shapes}, frame_skip, device, is_supercombo=False)


 def make_supercombo_input_queues(input_shapes: dict, frame_skip: int,
-                                 device: str = Device.DEFAULT, use_packed: bool = True) -> tuple[dict, dict]:
-  return generate_queues_and_npy(input_shapes, frame_skip, device, is_supercombo=True, use_packed=use_packed)
+                                 device: str = Device.DEFAULT) -> tuple[dict, dict]:
+  return generate_queues_and_npy(input_shapes, frame_skip, device, is_supercombo=True)


-def create_jit_runner(vision_runner, policy_runners: list, nv12: NV12Frame, model_size: tuple[int, int],
-            features_slice: slice, frame_skip: int, input_shapes: dict, prepare_only: bool):
-  frame_prepare = make_frame_prepare(nv12, *model_size)
+def make_random_images(keys, shape, device):
+  return {k: Tensor.randint(shape, low=0, high=256, dtype=dtypes.uint8, device=device).realize() for k in keys}
+
+
+def make_warp_queues(device=Device.DEFAULT):
+  npy = {
+    'tfm': np.zeros((3, 3), dtype=np.float32),
+    'big_tfm': np.zeros((3, 3), dtype=np.float32),
+  }
+  queues = {k: Tensor(v, device='NPY').realize() for k, v in npy.items()}
+  return queues, npy
+
+
+def make_warp(nv12: NV12Frame, model_w: int, model_h: int):
+  frame_prepare = make_frame_prepare(nv12, model_w, model_h)
+  WARP_DEV = os.getenv('WARP_DEV', Device.DEFAULT)
+
+  def warp(tfm, big_tfm, frame, big_frame):
+    tfm = tfm.to(WARP_DEV)
+    big_tfm = big_tfm.to(WARP_DEV)
+    Tensor.realize(tfm, big_tfm)
+
+    warped_frame = frame_prepare(frame, tfm).unsqueeze(0)
+    warped_big_frame = frame_prepare(big_frame, big_tfm).unsqueeze(0)
+    return Tensor.cat(warped_frame, warped_big_frame)
+  return warp
+
+
+def make_run_policy(vision_runner, policy_runners: list, features_slice: slice, frame_skip: int, input_shapes: dict):
  sample_skip_fn = partial(sample_skip, frame_skip=frame_skip)
  sample_desire_fn = partial(sample_desire, frame_skip=frame_skip)

@@ -172,26 +180,20 @@ def create_jit_runner(vision_runner, policy_runners: list, nv12: NV12Frame, mode
  is_supercombo = vision_runner is None
  npy_shapes, npy_sizes = get_policy_npy_shapes(input_shapes, is_supercombo=is_supercombo)

-  def runner(img_q, big_img_q, feat_q, packed_npy_inputs, frame, big_frame, tfm, big_tfm, **kwargs):
+  def run_policy(warped, img_q, big_img_q, feat_q, packed_npy_inputs, **kwargs):
    desire_q = kwargs['desire_q']
-
    packed_npy_inputs_dev = packed_npy_inputs.to(Device.DEFAULT)
-    tfm_dev = tfm.to(Device.DEFAULT)
-    big_tfm_dev = big_tfm.to(Device.DEFAULT)
+    warped_dev = warped.to(Device.DEFAULT)
+    Tensor.realize(packed_npy_inputs_dev, warped_dev)

-    Tensor.realize(packed_npy_inputs_dev, tfm_dev, big_tfm_dev)
-
-    img = shift_and_sample(img_q, frame_prepare(frame, tfm_dev).unsqueeze(0), sample_skip_fn).realize()
-    big_img = shift_and_sample(big_img_q, frame_prepare(big_frame, big_tfm_dev).unsqueeze(0), sample_skip_fn).realize()
-
-    if prepare_only:
-      return img, big_img
+    img = shift_and_sample(img_q, warped_dev[0:1], sample_skip_fn)
+    big_img = shift_and_sample(big_img_q, warped_dev[1:2], sample_skip_fn)

    unpacked_tensors = [tensor.reshape(shape) for tensor, shape in zip(packed_npy_inputs_dev.split(npy_sizes), npy_shapes.values(), strict=True)]
    unpacked_dict = dict(zip(npy_shapes.keys(), unpacked_tensors, strict=True))

    desire_dev = unpacked_dict['desire']
-    desire_buf = shift_and_sample(desire_q, desire_dev.reshape(1, 1, -1), sample_desire_fn).realize()
+    desire_buf = shift_and_sample(desire_q, desire_dev.reshape(1, 1, -1), sample_desire_fn)

    inputs = {desire_key: desire_buf}
    for key, tensor_val in unpacked_dict.items():
@@ -200,7 +202,7 @@ def create_jit_runner(vision_runner, policy_runners: list, nv12: NV12Frame, mode

    if 'prev_feat' in unpacked_dict:
      prev_feat_dev = unpacked_dict['prev_feat']
-      inputs['features_buffer'] = shift_and_sample(feat_q, prev_feat_dev.reshape(1, 1, -1), sample_skip_fn).realize()
+      inputs['features_buffer'] = shift_and_sample(feat_q, prev_feat_dev.reshape(1, 1, -1), sample_skip_fn).reshape(input_shapes['features_buffer'])

    if vision_runner:
      vision_out_cast = next(iter(vision_runner({road_key: img, wide_key: big_img}).values())).cast('float32').realize()
@@ -212,7 +214,7 @@ def create_jit_runner(vision_runner, policy_runners: list, nv12: NV12Frame, mode

    inputs.update({road_key: img, wide_key: big_img})
    if 'features_buffer' not in inputs:
-      inputs['features_buffer'] = sample_skip_fn(feat_q)
+      inputs['features_buffer'] = sample_skip_fn(feat_q).reshape(input_shapes['features_buffer'])

    policy_out = next(iter(policy_runners[0](inputs).values())).cast('float32').realize()
    if 'features_buffer' not in inputs and features_slice is not None:
@@ -220,42 +222,52 @@ def create_jit_runner(vision_runner, policy_runners: list, nv12: NV12Frame, mode
      shift_and_sample(feat_q, new_feat, sample_skip_fn).realize()
    return policy_out

-  return runner
+  return run_policy


-def compile_and_warmup(nv12: NV12Frame, model_size: tuple[int, int], prepare_only: bool, frame_skip: int, vision_runner, policy_runners: list, metadata: dict):
-  print(f"Compiling combined JIT for {nv12.width}x{nv12.height} (prepare_only={prepare_only})...")
+def compile_jit(jit, make_random_inputs, input_keys, make_queues):
+  SEED = 42
+  def random_inputs_run(fn, seed, test_val=None, test_buffers=None, expect_match=True):
+    input_queues, npy = make_queues(Device.DEFAULT)
+    rng = np.random.default_rng(seed)
+    Tensor.manual_seed(seed)

-  all_shapes = {key: value for meta in metadata.values() for key, value in meta['input_shapes'].items()}
+    testing = test_val is not None or test_buffers is not None
+    n_runs = 1 if testing else 3

-  feat_meta = metadata.get('vision') or metadata.get('model') or metadata.get('policy')
-  if not feat_meta:
-    raise ValueError("Could not find vision, model, or policy metadata.")
+    for i in range(n_runs):
+      for v in npy.values():
+        v[:] = rng.standard_normal(v.shape).astype(v.dtype)
+      Device.default.synchronize()
+      random_inputs = make_random_inputs()
+      st = time.perf_counter()
+      outs = fn(**{k: input_queues[k] for k in input_keys if k in input_queues}, **random_inputs)
+      mt = time.perf_counter()
+      Device.default.synchronize()
+      et = time.perf_counter()
+      print(f"  [{i+1}/{n_runs}] enqueue {(mt-st)*1e3:6.2f} ms -- total {(et-st)*1e3:6.2f} ms")

-  features_slice = feat_meta['output_slices']['hidden_state']
-  WARP_DEV = 'CPU' if "USBGPU" in os.environ else Device.DEFAULT
+      if i == 0:
+        val = [np.copy(v.numpy()) for v in (outs if isinstance(outs, tuple) else [outs])] if outs is not None else []
+        buffers = [np.copy(v.numpy().copy()) for v in input_queues.values()]

-  is_supercombo = vision_runner is None
-  run_func = create_jit_runner(vision_runner, policy_runners, nv12, model_size, features_slice, frame_skip, all_shapes, prepare_only)
-  run_jit = TinyJit(run_func, prune=True)
-  queues, npy_arrays = generate_queues_and_npy(all_shapes, frame_skip, Device.DEFAULT, is_supercombo=is_supercombo)
+    if test_val is not None:
+      match = all(np.array_equal(a, b) for a, b in zip(val, test_val, strict=True))
+      assert match == expect_match, f"outputs {'differ from' if expect_match else 'match'} baseline (seed={seed})"
+    if test_buffers is not None:
+      match = all(np.array_equal(a, b) for a, b in zip(buffers, test_buffers, strict=True))
+      assert match == expect_match, f"buffers {'differ from' if expect_match else 'match'} baseline (seed={seed})"
+    return val, buffers

-  for i in range(3):
-    rng = np.random.default_rng(42 + i)
-    frame = Tensor.randint(nv12.size, low=0, high=256, dtype=dtypes.uint8, device=WARP_DEV).realize()
-    big_frame = Tensor.randint(nv12.size, low=0, high=256, dtype=dtypes.uint8, device=WARP_DEV).realize()
-    for arr in npy_arrays.values():
-      arr[:] = rng.standard_normal(arr.shape).astype(arr.dtype)
-
-    Device.default.synchronize()
-    start_time = time.perf_counter()
-    run_jit(**queues, frame=frame, big_frame=big_frame)
-    mid_time = time.perf_counter()
-    Device.default.synchronize()
-    print(f"  [{i + 1}/3] enqueue {(mid_time - start_time) * 1e3:6.2f} ms -- total {(time.perf_counter() - start_time) * 1e3:6.2f} ms")
-
-  # TODO-SP: switch to dump_oob/load_oob on next full recompile of all models
-  return pickle.loads(pickle.dumps(run_jit)) if not prepare_only else run_jit
+  print('capture + replay')
+  test_val, test_buffers = random_inputs_run(jit, SEED)
+  print('pickle round trip')
+  with tempfile.TemporaryFile(dir=".") as f:
+    dump_oob(jit, f)
+    f.seek(0)
+    deserialized_jit = load_oob(f)
+  random_inputs_run(deserialized_jit, SEED, test_val=test_val, test_buffers=test_buffers)
+  return deserialized_jit


 def _parse_size(size_str: str) -> tuple[int, int]:
@@ -263,31 +275,17 @@ def _parse_size(size_str: str) -> tuple[int, int]:
  return int(width), int(height)


-def read_file_chunked_to_shm(path):
+def read_file_chunked_to_disk(path):
  if not path:
    return None
  import atexit
  import shutil
  from openpilot.common.file_chunker import open_file_chunked
-  from openpilot.common.hardware.hw import Paths
-  shm_path = os.path.join(Paths.shm_path(), os.path.basename(path))
-  atexit.register(lambda: os.path.exists(shm_path) and os.remove(shm_path))
-  with open(shm_path, 'wb') as dst, open_file_chunked(path) as src:
-    shutil.copyfileobj(src, dst)
-  return shm_path
-
-
-def _compile_for_resolutions(camera_resolutions: list, model_size: tuple[int, int], frame_skip: int,
-               vision_runner, policy_runners: list, metadata: dict) -> dict:
-  from openpilot.system.camerad.cameras.nv12_info import get_nv12_info
-  return {
-    (cam_w, cam_h): {
-      name: compile_and_warmup(NV12Frame(cam_w, cam_h, *get_nv12_info(cam_w, cam_h)), model_size, prepare_only,
-                   frame_skip, vision_runner, policy_runners, metadata)
-      for name, prepare_only in [('warp_enqueue', True), ('run_policy', False)]
-    }
-    for cam_w, cam_h in camera_resolutions
-  }
+  tmp_path = f'{path}.unchunked'
+  with open(tmp_path, 'wb') as f, open_file_chunked(path) as src:
+    shutil.copyfileobj(src, f)
+  atexit.register(lambda: os.path.exists(tmp_path) and os.remove(tmp_path))
+  return tmp_path


 def _load_policy_runners(args: argparse.Namespace) -> tuple[list, list]:
@@ -300,7 +298,18 @@ def _load_policy_runners(args: argparse.Namespace) -> tuple[list, list]:


 if __name__ == "__main__":
+  if 'USB' in os.getenv('DEV', '') or os.getenv('USBGPU'):
+    from openpilot.system.hardware.chestnut.flash import link_up
+    for _ in range(10):
+      if link_up():
+        break
+      time.sleep(1)
+    else:
+      raise RuntimeError("Chestnut not ready, skipping big model build")
+
+  from openpilot.common.file_chunker import chunk_file, get_chunk_targets
  from openpilot.selfdrive.modeld.get_model_metadata import make_metadata_dict
+  from openpilot.system.camerad.cameras.nv12_info import get_nv12_info
  from tinygrad.nn.onnx import OnnxRunner

  parser = argparse.ArgumentParser(description="Compile combined JIT pkl for sunnypilot modeld_v2")
@@ -317,13 +326,14 @@ if __name__ == "__main__":
  parser.add_argument('--supercombo-onnx', help='supercombo ONNX (for supercombo)')

  args = parser.parse_args()
-  output_data = defaultdict(dict)
+  model_w, model_h = args.model_size
+  output_data = {}

-  args.vision_onnx = read_file_chunked_to_shm(args.vision_onnx)
-  args.policy_onnx = read_file_chunked_to_shm(args.policy_onnx)
-  args.off_policy_onnx = read_file_chunked_to_shm(args.off_policy_onnx)
-  args.on_policy_onnx = read_file_chunked_to_shm(args.on_policy_onnx)
-  args.supercombo_onnx = read_file_chunked_to_shm(args.supercombo_onnx)
+  args.vision_onnx = read_file_chunked_to_disk(args.vision_onnx)
+  args.policy_onnx = read_file_chunked_to_disk(args.policy_onnx)
+  args.off_policy_onnx = read_file_chunked_to_disk(args.off_policy_onnx)
+  args.on_policy_onnx = read_file_chunked_to_disk(args.on_policy_onnx)
+  args.supercombo_onnx = read_file_chunked_to_disk(args.supercombo_onnx)

  vision_runner = OnnxRunner(args.vision_onnx) if args.vision_onnx else None

@@ -348,17 +358,31 @@ if __name__ == "__main__":
  vision_meta = output_data['metadata'].get('vision', {})

  derived_frame_skip = args.frame_skip or derive_frame_skip(vision_meta.get('input_shapes', {}), first_policy_meta.get('input_shapes', {}))
-  output_data.update(_compile_for_resolutions(args.camera_resolutions, args.model_size, derived_frame_skip,
-                        vision_runner, policy_runners, output_data['metadata']))
+  all_shapes = {key: value for meta in output_data['metadata'].values() for key, value in meta['input_shapes'].items()}
+  feat_meta = output_data['metadata'].get('vision') or output_data['metadata'].get('model') or output_data['metadata'].get('policy')
+  assert feat_meta is not None
+  features_slice = feat_meta['output_slices']['hidden_state']
+  is_supercombo = vision_runner is None
+
+  print(f"Compiling run_policy JIT (model_size={model_w}x{model_h}, frame_skip={derived_frame_skip})...")
+  run_policy_func = make_run_policy(vision_runner, policy_runners, features_slice, derived_frame_skip, all_shapes)
+  run_policy_jit = TinyJit(run_policy_func, prune=True)
+  make_policy_queues = partial(generate_queues_and_npy, all_shapes, derived_frame_skip, is_supercombo=is_supercombo)
+  make_random_model_inputs = partial(make_random_images, keys=['warped'], shape=(2, 6, model_h // 2, model_w // 2), device=WARP_DEV)
+  output_data['run_policy'] = compile_jit(run_policy_jit, make_random_model_inputs, POLICY_INPUTS, make_policy_queues)
+
+  for cam_w, cam_h in args.camera_resolutions:
+    print(f"Compiling warp JIT for {cam_w}x{cam_h}...")
+    nv12 = NV12Frame(cam_w, cam_h, *get_nv12_info(cam_w, cam_h))
+    make_random_warp_inputs = partial(make_random_images, keys=['frame', 'big_frame'], shape=nv12.size, device=WARP_DEV)
+    warp = TinyJit(make_warp(nv12, model_w, model_h), prune=True)
+    output_data[(cam_w, cam_h)] = compile_jit(warp, make_random_warp_inputs, WARP_INPUTS, make_warp_queues)

  with open(args.output, "wb") as file:
-    # TODO-SP: switch to dump_oob from openpilot/selfdrive/helpers on next full recompile of all models
-    pickle.dump(output_data, file)
+    dump_oob(output_data, file)

  pkl_size = os.path.getsize(args.output)
  print(f"Saved combined JIT to {args.output} ({pkl_size / 1e6:.2f} MB)")
-
-  from openpilot.common.file_chunker import chunk_file, get_chunk_targets
  chunk_targets = get_chunk_targets(args.output, pkl_size)
  chunk_file(args.output, chunk_targets)
  print(f"Chunked into {len(chunk_targets) - 1} file(s)")
@@ -9,17 +9,13 @@ See the LICENSE.md file in the root directory for more details.
 import os
 os.environ['GMMU'] = '0'
 from openpilot.common.hardware import COMMA_HARDWARE
-os.environ['DEV'] = 'QCOM' if COMMA_HARDWARE else 'CPU'
-USBGPU = "USBGPU" in os.environ
-if USBGPU:
-  os.environ['DEV'] = 'AMD'
-  os.environ['AMD_IFACE'] = 'USB'
-import pickle
+from openpilot.selfdrive.modeld.helpers import usbgpu_present, load_oob
 import time
 import numpy as np
 import openpilot.cereal.messaging as messaging
 from openpilot.cereal import log
 from opendbc.car.structs import car
+from openpilot.cereal.services import SERVICE_LIST
 from setproctitle import setproctitle
 from openpilot.cereal.messaging import PubMaster, SubMaster
 from openpilot.cereal.visionipc import VisionStreamType
@@ -27,7 +23,6 @@ from msgq.visionipc import VisionIpcClient, VisionBuf
 from opendbc.car.car_helpers import get_demo_car_params

 from tinygrad.tensor import Tensor
-from tinygrad.device import Device

 from openpilot.common.file_chunker import open_file_chunked
 from openpilot.common.swaglog import cloudlog
@@ -40,12 +35,13 @@ from openpilot.system import sentry
 from openpilot.system.camerad.cameras.nv12_info import get_nv12_info
 from openpilot.selfdrive.controls.lib.desire_helper import DesireHelper
 from openpilot.selfdrive.controls.lib.drive_helpers import get_accel_from_plan, smooth_value
+from openpilot.selfdrive.modeld.modeld import ChestnutState

 from openpilot.sunnypilot.modeld_v2.fill_model_msg import fill_model_msg, fill_pose_msg, PublishState, get_curvature_from_output
 from openpilot.sunnypilot.modeld_v2.constants import Plan
 from openpilot.sunnypilot.modeld_v2.meta_helper import load_meta_constants
 from openpilot.sunnypilot.modeld_v2.camera_offset_helper import CameraOffsetHelper
-from openpilot.sunnypilot.modeld_v2.compile_modeld import derive_frame_skip, make_split_input_queues
+from openpilot.sunnypilot.modeld_v2.compile_modeld import derive_frame_skip, make_split_input_queues, make_supercombo_input_queues, WARP_INPUTS, POLICY_INPUTS

 from openpilot.sunnypilot.livedelay.helpers import get_lat_delay
 from openpilot.sunnypilot.modeld_v2.modeld_base import ModelStateBase
@@ -88,14 +84,14 @@ class ModelState(ModelStateBase):
  inputs: dict[str, np.ndarray]
  prev_desire: np.ndarray

-  def __init__(self, cam_w: int, cam_h: int):
+  def __init__(self, cam_w: int, cam_h: int, usbgpu: bool = False):
    ModelStateBase.__init__(self)

    env_pkl = os.environ.get('COMBINED_MODEL_PKL')
    if env_pkl and os.path.exists(env_pkl):
      model_bundle = None
    else:
-      model_bundle = get_active_bundle()
+      model_bundle = get_active_bundle(usbgpu=usbgpu)
    self.generation = model_bundle.generation if model_bundle is not None else None
    overrides = {override.key: override.value for override in model_bundle.overrides} if model_bundle else {}

@@ -103,6 +99,7 @@ class ModelState(ModelStateBase):
    self.LONG_SMOOTH_SECONDS = float(overrides.get('long', ".0"))
    self.MIN_LAT_CONTROL_SPEED = 0.3
    self.PLANPLUS_CONTROL: float = 1.0
+    self.usbgpu = usbgpu

    pkl_path = _find_driving_pkl(model_bundle)
    assert pkl_path is not None, "No driving pkl found — all models must be compiled with compile_modeld.py"
@@ -110,24 +107,20 @@ class ModelState(ModelStateBase):

  def _init_combined(self, pkl_path, cam_w, cam_h, bundle):
    cloudlog.warning(f"loading combined pkl: {pkl_path}")
-    # TODO-SP: switch to load_oob from openpilot/selfdrive/helpers on next full recompile of all models
-    jits = pickle.load(open_file_chunked(pkl_path))
+    jits = load_oob(open_file_chunked(pkl_path))

-    self.DEV = Device.DEFAULT
-    self.WARP_DEV = 'CPU' if USBGPU else self.DEV
+    self.WARP_DEV = 'QCOM' if COMMA_HARDWARE else 'CPU'
+    self.DEV = 'AMD' if self.usbgpu else self.WARP_DEV
    self.QUEUE_DEV = self.DEV
-
    metadata = jits['metadata']

-    self._run_policy = jits[(cam_w, cam_h)]['run_policy']
-    self._warp_enqueue = jits[(cam_w, cam_h)]['warp_enqueue']
-
-    # TODO-SP: Remove legacy use_packed detection block after all models are recompiled
-    captured = getattr(self._run_policy, 'captured', None)
-    if captured is not None:
-      use_packed = 'packed_npy_inputs' in getattr(captured, 'expected_names', [])
+    self.is_legacy_model = 'run_policy' not in jits  # remove after next recompile
+    if self.is_legacy_model:
+      self.warp = jits[(cam_w, cam_h)]['warp_enqueue']
+      self.run_policy = jits[(cam_w, cam_h)]['run_policy']
    else:
-      use_packed = True
+      self.run_policy = jits['run_policy']
+      self.warp = jits[(cam_w, cam_h)]

    if 'model' in metadata:
      model_metadata = metadata['model']
@@ -136,10 +129,9 @@ class ModelState(ModelStateBase):
      self._policy_slices_list = []
      self._combined_model_type = 'supercombo'
      self._vision_input_names = [key for key in model_metadata['input_shapes'] if 'img' in key]
-      from openpilot.sunnypilot.modeld_v2.compile_modeld import make_supercombo_input_queues
      frame_skip = derive_frame_skip({}, model_metadata['input_shapes'])
      self.input_queues, self.numpy_inputs = make_supercombo_input_queues(model_metadata['input_shapes'],
-                                                                          frame_skip, device=self.QUEUE_DEV, use_packed=use_packed)
+                                                                          frame_skip, device=self.QUEUE_DEV)
    else:
      vision_metadata = metadata['vision']
      policy_keys = [k for k in metadata if k != 'vision']
@@ -152,13 +144,12 @@ class ModelState(ModelStateBase):
      self._policy_slices_list = [metadata[k]['output_slices'] for k in policy_keys]
      self.policy_output_slices = self._policy_slices_list[0]
      self._has_on_policy = any('on' in k.lower() for k in policy_keys)
-      first_policy_metadata = metadata[policy_keys[0]]
-      vision_input_shapes = vision_metadata['input_shapes']
-      policy_input_shapes = first_policy_metadata['input_shapes']
-      self._vision_input_names = [k for k in vision_input_shapes if 'img' in k]
-      frame_skip = derive_frame_skip(vision_input_shapes, policy_input_shapes)
-      self.input_queues, self.numpy_inputs = make_split_input_queues(vision_input_shapes, policy_input_shapes,
-                                                                     frame_skip, device=self.QUEUE_DEV, use_packed=use_packed)
+      self._vision_input_names = [key for key in vision_metadata['input_shapes'] if 'img' in key]
+      first_policy_meta = metadata[policy_keys[0]]
+      frame_skip = derive_frame_skip(vision_metadata['input_shapes'], first_policy_meta['input_shapes'])
+      self.input_queues, self.numpy_inputs = make_split_input_queues(vision_metadata['input_shapes'],
+                                                                     first_policy_meta['input_shapes'],
+                                                                     frame_skip, device=self.QUEUE_DEV)

    self._desire_key = next(key for key in self.numpy_inputs if key.startswith('desire'))
    self._road_key = next(key for key in self._vision_input_names if 'big' not in key)
@@ -186,10 +177,33 @@ class ModelState(ModelStateBase):
    self.frame_buf_params = dict.fromkeys(self._vision_input_names, nv12_info)

    yuv_size = self.frame_buf_params[self._road_key][3]
-    self._warp_enqueue(
-      **self.input_queues,
-      frame=Tensor(np.zeros(yuv_size, dtype=np.uint8), device=self.WARP_DEV).contiguous().realize(),
-      big_frame=Tensor(np.zeros(yuv_size, dtype=np.uint8), device=self.WARP_DEV).contiguous().realize())
+    frame_tensor = Tensor(np.zeros(yuv_size, dtype=np.uint8), device=self.WARP_DEV).contiguous().realize()
+    big_frame_tensor = Tensor(np.zeros(yuv_size, dtype=np.uint8), device=self.WARP_DEV).contiguous().realize()
+
+    if self.is_legacy_model: # Remove this conditional hack after recompile
+      self.warp(**self.input_queues, frame=frame_tensor, big_frame=big_frame_tensor)
+    else:
+      self.warp(**{k: self.input_queues[k] for k in WARP_INPUTS}, frame=frame_tensor, big_frame=big_frame_tensor)
+
+    if self.usbgpu:
+      self.warmup()
+
+  def warmup(self) -> None:
+    dummy_frames = {k: np.zeros(self.frame_buf_params[k][3], dtype=np.uint8) for k in self._vision_input_names}
+    transforms = {k: np.eye(3, dtype=np.float32) for k in [self._road_key, self._wide_key] if k}
+
+    dummy_inputs = {}
+    for k, v in self.numpy_inputs.items():
+      if k not in ['tfm', 'big_tfm', 'prev_feat']:
+        dummy_inputs[k] = np.zeros(v.shape, dtype=v.dtype)
+
+    self.run(dummy_frames, transforms, dummy_inputs, prepare_only=False)
+
+    for v in self.numpy_inputs.values():
+      v[:] = 0
+    self.prev_desire[:] = 0
+    self.full_frames.clear()
+    self._blob_cache.clear()


  @property
@@ -227,11 +241,17 @@ class ModelState(ModelStateBase):
    self.numpy_inputs['tfm'][:, :] = transforms[road_key].reshape(3, 3)
    self.numpy_inputs['big_tfm'][:, :] = transforms[wide_key].reshape(3, 3)

-    if prepare_only:
-      self._warp_enqueue(**self.input_queues, frame=self.full_frames[road_key], big_frame=self.full_frames[wide_key])
-      return None
-
-    raw_outputs = self._run_policy(**self.input_queues, frame=self.full_frames[road_key], big_frame=self.full_frames[wide_key])
+    if self.is_legacy_model:  # remove after next recompile
+      if prepare_only:
+        self.warp(**self.input_queues, frame=self.full_frames[road_key], big_frame=self.full_frames[wide_key])
+        return None
+      raw_outputs = self.run_policy(**self.input_queues, frame=self.full_frames[road_key], big_frame=self.full_frames[wide_key])
+    else:
+      if prepare_only:
+        self.warp(**{k: self.input_queues[k] for k in WARP_INPUTS}, frame=self.full_frames[road_key], big_frame=self.full_frames[wide_key])
+        return None
+      warped = self.warp(**{k: self.input_queues[k] for k in WARP_INPUTS}, frame=self.full_frames[road_key], big_frame=self.full_frames[wide_key])
+      raw_outputs = self.run_policy(**{k: self.input_queues[k] for k in POLICY_INPUTS if k in self.input_queues}, warped=warped)

    if self._combined_model_type == 'supercombo':
      model_output = raw_outputs.numpy().flatten()
@@ -267,10 +287,9 @@ class ModelState(ModelStateBase):
      buf[0, :-1] = buf[0, 1:]
      buf[0, -1, :] = outputs['desired_curvature'][0, :] if not self.mlsim else 0

-    # TODO-SP: This is a hack to prevent GPU corruption by calculating in CPU space, it can be removed on next recompile
-    if 'prev_feat' not in self.numpy_inputs and 'feat_q' in self.input_queues:
-      feat_val = self.input_queues['feat_q'].numpy()
-      self.input_queues['feat_q'].assign(feat_val).realize()
+    if self.usbgpu and not np.all(np.isfinite(outputs.get('plan', np.array([0.])))):
+      cloudlog.error("model output not finite, dropping frame")
+      return None

    return outputs

@@ -278,8 +297,8 @@ class ModelState(ModelStateBase):
                            lat_action_t: float, long_action_t: float, v_ego: float) -> log.ModelDataV2.Action:
    if 'action' not in model_output:
      plan = model_output['plan'][0]
-      desired_accel, should_stop = get_accel_from_plan(plan[:, Plan.VELOCITY][:, 0], plan[:, Plan.ACCELERATION][:, 0], self.constants.T_IDXS,
-                                                       action_t=long_action_t)
+      desired_accel = get_accel_from_plan(plan[:, Plan.VELOCITY][:, 0], plan[:, Plan.ACCELERATION][:, 0], self.constants.T_IDXS,
+                                          action_t=long_action_t)

      curvature_plan = (plan + (self.PLANPLUS_CONTROL - 1.0) * model_output['planplus'][0]
                        if 'planplus' in model_output and self.PLANPLUS_CONTROL != 1.0 else plan)
@@ -287,8 +306,8 @@ class ModelState(ModelStateBase):
    else:
      desired_accel = model_output['action'][0, 1]
      desired_curvature = model_output['action'][0, 0] / (max(1.0, v_ego))**2
-      should_stop = (v_ego < 0.3 and desired_accel < 0.1)

+    stop = v_ego < 0.3 and desired_accel < 0.1
    desired_accel = smooth_value(desired_accel, prev_action.desiredAcceleration, self.LONG_SMOOTH_SECONDS)

    if self.generation is not None and self.generation >= 10: # smooth curvature for post FOF models
@@ -297,7 +316,7 @@ class ModelState(ModelStateBase):
      else:
        desired_curvature = prev_action.desiredCurvature

-    return log.ModelDataV2.Action(desiredCurvature=float(desired_curvature),desiredAcceleration=float(desired_accel), shouldStop=bool(should_stop))
+    return log.ModelDataV2.Action(desiredCurvature=float(desired_curvature), desiredAcceleration=float(desired_accel), shouldStop=bool(stop))


 def main(demo=False):
@@ -308,6 +327,14 @@ def main(demo=False):
  setproctitle(PROCESS_NAME)
  config_realtime_process(7, 54)

+  USBGPU = usbgpu_present()
+  if USBGPU:
+    os.environ['HCQDEV_WAIT_TIMEOUT_MS'] = '3000'
+
+  params = Params()
+  params.put_bool("UsbGpuLoading", USBGPU)
+  params.remove("UsbGpuActive")
+
  # visionipc clients
  while True:
    available_streams = VisionIpcClient.available_streams("camerad", block=False)
@@ -332,15 +359,34 @@ def main(demo=False):
    cloudlog.warning(f"connected extra cam with buffer size: {vipc_client_extra.buffer_len} ({vipc_client_extra.width} x {vipc_client_extra.height})")

  cloudlog.warning("loading model")
-  model = ModelState(cam_w=vipc_client_main.width, cam_h=vipc_client_main.height)
-  cloudlog.warning("models loaded, modeld starting")
+  st = time.monotonic()
+
+  model = None
+  if USBGPU:
+    import threading
+    def load():
+      nonlocal model
+      model = ModelState(cam_w=vipc_client_main.width, cam_h=vipc_client_main.height, usbgpu=True)
+    t = threading.Thread(target=load, daemon=True)
+    t.start()
+    t.join(60)
+    if model is None:
+      params.put_bool("UsbGpuActive", False)
+      raise RuntimeError("eGPU model load failed or timed out (60s)")
+    params.put_bool("UsbGpuActive", True)
+  else:
+    model = ModelState(cam_w=vipc_client_main.width, cam_h=vipc_client_main.height, usbgpu=False)
+
+  params.put_bool("UsbGpuLoading", False)
+  cloudlog.warning(f"models loaded in {time.monotonic() - st:.1f}s, modeld starting")

  # messaging
-  pm = PubMaster(["modelV2", "drivingModelData", "cameraOdometry", "modelDataV2SP"])
+  pub_socks = ["modelV2", "drivingModelData", "cameraOdometry", "modelDataV2SP"] + (["chestnutState"] if USBGPU else [])
+  pm = PubMaster(pub_socks)
  sm = SubMaster(["deviceState", "carState", "narrowRoadCameraState", "extrinsicsCalibration", "driverMonitoringState", "carControl", "lateralDelay"])

  publish_state = PublishState()
-  params = Params()
+  chestnut_state = ChestnutState(pm, USBGPU) if USBGPU else None

  # setup filter to track dropped frames
  frame_dropped_filter = FirstOrderFilter(0., 10., 1. / model.constants.MODEL_FREQ)
@@ -478,6 +524,7 @@ def main(demo=False):
      fill_model_msg(drivingdata_send, modelv2_send, model_output, action,
                     publish_state, meta_main.frame_id, meta_extra.frame_id, frame_id,
                     frame_drop_ratio, meta_main.timestamp_eof, model_execution_time, live_calib_seen, meta_constants)
+      modelv2_send.modelV2.big = model.usbgpu

      desire_state = modelv2_send.modelV2.meta.desireState
      l_lane_change_prob = desire_state[log.Desire.laneChangeLeft]
@@ -498,6 +545,8 @@ def main(demo=False):
      pm.send('modelDataV2SP', mdv2sp_send)
    last_vipc_frame_id = meta_main.frame_id

+    if chestnut_state is not None and run_count % round(model.constants.MODEL_FREQ / SERVICE_LIST['chestnutState'].frequency) == 0:
+      chestnut_state.send()

 if __name__ == "__main__":
  try:
@@ -6,7 +6,6 @@ See the LICENSE.md file in the root directory for more details.
 """

 import pathlib
-import pickle
 import tempfile

 import openpilot.sunnypilot.models.helpers as helpers
@@ -164,14 +163,16 @@ ARCHETYPES = {
 def make_pkl_data(archetype):
  return {
    'metadata': archetype.metadata_structure,
-    (CAM_W, CAM_H): {'run_policy': _noop_jit, 'warp_enqueue': _noop_jit},
+    'run_policy': _noop_jit,
+    (CAM_W, CAM_H): _noop_jit,
  }


 def write_pkl(tmp_path, archetype):
+  from openpilot.selfdrive.modeld.helpers import dump_oob
  pkl_path = tmp_path / 'driving_test_tinygrad.pkl'
  with open(pkl_path, 'wb') as f:
-    pickle.dump(make_pkl_data(archetype), f)
+    dump_oob(make_pkl_data(archetype), f)
  return pkl_path


@@ -189,8 +190,8 @@ def tmp_path():

 def patch_modeld(monkeypatch):
  def _patch(bundle):
-    monkeypatch.setattr(helpers, 'get_active_bundle', lambda params=None: bundle)
-    monkeypatch.setattr(modeld_module, 'get_active_bundle', lambda params=None: bundle)
+    monkeypatch.setattr(helpers, 'get_active_bundle', lambda params=None, *, usbgpu=None: bundle)
+    monkeypatch.setattr(modeld_module, 'get_active_bundle', lambda params=None, *, usbgpu=None: bundle)

  return _patch

@@ -59,8 +59,8 @@ class TestFindDrivingPkl(OpenpilotTestCase):
 class TestModelStateCombinedInit(OpenpilotTestCase):
  def test_asserts_when_no_pkl(self, monkeypatch):
    bundle = DummyBundle(models=[], is_20hz=True)
-    monkeypatch.setattr(helpers, 'get_active_bundle', lambda params=None: bundle)
-    monkeypatch.setattr(modeld_module, 'get_active_bundle', lambda params=None: bundle)
+    monkeypatch.setattr(helpers, 'get_active_bundle', lambda params=None, *, usbgpu=None: bundle)
+    monkeypatch.setattr(modeld_module, 'get_active_bundle', lambda params=None, *, usbgpu=None: bundle)
    with self.assertRaisesRegex(AssertionError, "No driving pkl found"):
      ModelState(cam_w=CAM_W, cam_h=CAM_H)

@@ -5,10 +5,15 @@ This file is part of sunnypilot and is licensed under the MIT License.
 See the LICENSE.md file in the root directory for more details.
 """

+import os
+import tempfile
+from pathlib import Path
+
 import numpy as np
 from openpilot.common.parameterized import parameterized

-from openpilot.sunnypilot.modeld_v2.compile_modeld import derive_frame_skip, _detect_desire_key
+from openpilot.common.file_chunker import chunk_file, get_chunk_targets
+from openpilot.sunnypilot.modeld_v2.compile_modeld import derive_frame_skip, _detect_desire_key, read_file_chunked_to_disk
 from openpilot.common.test import OpenpilotTestCase


@@ -160,3 +165,115 @@ class TestOutputSlicePreservation(OpenpilotTestCase):
    policy_slices = {'plan': slice(0, 495), 'meta': slice(495, 550)}
    assert set(vision_slices.keys()) & set(policy_slices.keys()) == set(), \
      "vision and policy slices should not overlap in keys"
+
+
+class TestReadFileChunkedToDisk(OpenpilotTestCase):
+  def test_none_passthrough(self):
+    assert read_file_chunked_to_disk(None) is None
+
+  def test_unchunked_source_staged_on_disk(self):
+    with tempfile.TemporaryDirectory() as d:
+      src = Path(d) / "driving_supercombo.onnx"
+      payload = os.urandom(1024)
+      src.write_bytes(payload)
+
+      out = Path(read_file_chunked_to_disk(str(src)))
+
+      assert out.parent == Path(d)
+      assert out.name == "driving_supercombo.onnx.unchunked"
+      assert out.read_bytes() == payload
+
+  def test_chunked_source_reassembled_on_disk(self):
+    with tempfile.TemporaryDirectory() as d:
+      src = Path(d) / "driving_supercombo.onnx"
+      payload = os.urandom(4096)
+      src.write_bytes(payload)
+      chunk_file(str(src), get_chunk_targets(str(src), len(payload)))
+      assert not src.exists()
+
+      out = Path(read_file_chunked_to_disk(str(src)))
+
+      assert out.parent == Path(d)
+      assert out.read_bytes() == payload
+
+
+class Test4DFeaturesBuffer(OpenpilotTestCase):
+  def test_get_policy_npy_shapes_4d(self):
+    from openpilot.sunnypilot.modeld_v2.compile_modeld import get_policy_npy_shapes
+    input_shapes = {
+      'desire_pulse': (1, 25, 8),
+      'features_buffer': (1, 24, 32, 512),  # compare 4d to 3d for regression
+      'traffic_convention': (1, 2),
+      'action_t': (1, 2)
+    }
+    shapes, sizes = get_policy_npy_shapes(input_shapes, is_supercombo=True)
+    assert shapes['prev_feat'] == (1, 16384)
+    assert sizes == [8, 2, 2, 16384]
+
+  def test_get_policy_npy_shapes_3d(self):
+    from openpilot.sunnypilot.modeld_v2.compile_modeld import get_policy_npy_shapes
+    input_shapes = {
+      'desire_pulse': (1, 25, 8),
+      'features_buffer': (1, 24, 512),
+      'traffic_convention': (1, 2),
+      'action_t': (1, 2)
+    }
+    shapes, sizes = get_policy_npy_shapes(input_shapes, is_supercombo=True)
+    assert shapes['prev_feat'] == (1, 512)
+    assert sizes == [8, 2, 2, 512]
+
+
+class TestStockCompileModeldEquivalence(OpenpilotTestCase):
+  def test_get_policy_npy_shapes_matches_stock(self):
+    from openpilot.selfdrive.modeld.compile_modeld import get_policy_npy_shapes as stock_get_policy_npy_shapes
+    from openpilot.sunnypilot.modeld_v2.compile_modeld import get_policy_npy_shapes as sunny_get_policy_npy_shapes
+
+    stock_input_shapes = {
+      'desire_pulse': (1, 25, 8),
+      'features_buffer': (1, 24, 512), # see below comment
+      'traffic_convention': (1, 2),
+      'action_t': (1, 2),
+    }
+
+    stock_shapes, stock_sizes = stock_get_policy_npy_shapes(stock_input_shapes)
+    sunny_shapes, sunny_sizes = sunny_get_policy_npy_shapes(stock_input_shapes, is_supercombo=True)
+
+    assert sunny_shapes == stock_shapes
+    assert sunny_sizes == stock_sizes
+    assert sunny_shapes['prev_feat'] == (1, 512)
+
+  def test_make_input_queues_full_stock_equivalence(self):
+    from openpilot.selfdrive.modeld.compile_modeld import make_input_queues as stock_make_input_queues
+    from openpilot.sunnypilot.modeld_v2.compile_modeld import make_supercombo_input_queues as sunny_make_supercombo_input_queues
+    input_shapes = {
+      'img': (1, 12, 128, 256),
+      'desire_pulse': (1, 25, 8),
+      'features_buffer': (1, 24, 512),  # when https://github.com/commaai/openpilot/pull/38681 merges, update to 1,24,32,512
+      'traffic_convention': (1, 2),
+      'action_t': (1, 2),
+    }
+    frame_skip = 4
+
+    stock_queues, stock_npy = stock_make_input_queues(input_shapes, frame_skip, device='NPY')
+    sunny_queues, sunny_npy = sunny_make_supercombo_input_queues(input_shapes, frame_skip, device='NPY')
+    assert set(sunny_queues.keys()) == set(stock_queues.keys())
+    for key in stock_queues:
+      assert sunny_queues[key].shape == stock_queues[key].shape, \
+        f"Queue shape mismatch for {key}: sunny {sunny_queues[key].shape} != stock {stock_queues[key].shape}"
+    assert set(sunny_npy.keys()) == set(stock_npy.keys())
+    for key in stock_npy:
+      assert sunny_npy[key].shape == stock_npy[key].shape, \
+        f"Numpy array shape mismatch for {key}: sunny {sunny_npy[key].shape} != stock {stock_npy[key].shape}"
+
+  def test_make_warp_queues_stock_equivalence(self):
+    from openpilot.selfdrive.modeld.compile_modeld import make_warp_input_queues as stock_make_warp_queues
+    from openpilot.sunnypilot.modeld_v2.compile_modeld import make_warp_queues as sunny_make_warp_queues
+    stock_vision_shapes = {'img': (1, 12, 128, 256)}  # for now?
+    stock_queues, stock_npy = stock_make_warp_queues(stock_vision_shapes, frame_skip=4, device='NPY')
+    sunny_queues, sunny_npy = sunny_make_warp_queues(device='NPY')
+
+    assert set(sunny_npy.keys()) == set(stock_npy.keys()) == {'tfm', 'big_tfm'}
+    for key in sunny_npy:
+      assert sunny_npy[key].shape == stock_npy[key].shape == (3, 3)
+
+
@@ -33,7 +33,7 @@ class TestRecoveryPower(OpenpilotTestCase):

    def mock_accel(plan_vel, plan_accel, t_idxs, action_t=0.0):
      recorded_vel.append(plan_vel.copy())
-      return 0.0, False
+      return 0.0

    def mock_curvature(output, plan, vego, lat_action_t, mlsim):
      recorded_curv_plans.append(plan.copy())
@@ -3,8 +3,17 @@ import os
 import hashlib

 from openpilot.common.basedir import BASEDIR
+from openpilot.selfdrive.ui.ui_state import ui_state
 from openpilot.sunnypilot import get_file_hash
-from openpilot.sunnypilot.models.model_name import DEFAULT_MODEL
+from openpilot.sunnypilot.models.model_name import DEFAULT_MODEL, DEFAULT_BIG_MODEL
+
+
+def get_default_model() -> str:
+  show_big_model = (ui_state.usbgpu
+                    and (ui_state.usbgpu_active or ui_state.usbgpu_loading or ui_state.is_offroad()))
+
+  return DEFAULT_BIG_MODEL if show_big_model else DEFAULT_MODEL
+

 DEFAULT_MODEL_NAME_PATH = os.path.join(BASEDIR, "openpilot", "sunnypilot", "models", "model_name.py")
 MODEL_HASH_PATH = os.path.join(BASEDIR, "openpilot", "sunnypilot", "models", "tests", "model_hash")
@@ -13,7 +22,6 @@ SUPERCOMBO_ONNX_PATH = os.path.join(BASEDIR, "openpilot", "selfdrive", "modeld",

 def update_model_hash():
  supercombo_hash = get_file_hash(SUPERCOMBO_ONNX_PATH)
-
  combined_hash = hashlib.sha256(supercombo_hash.encode()).hexdigest()

  with open(MODEL_HASH_PATH, "w") as f:
@@ -22,40 +30,28 @@ def update_model_hash():
  print(f"Generated and updated new combined model hash to {MODEL_HASH_PATH}")


-def get_current_default_model_name():
-  print("[GET DEFAULT MODEL NAME]")
-  name = DEFAULT_MODEL
-  print(f'Current default model name: "{name}"')
-
-  return name
-
-
-def update_default_model_name(name: str):
-  print("[CHANGE DEFAULT MODEL NAME]")
+def update_default_model_names(default_model_name: str, default_big_model_name: str):
+  print("[CHANGE DEFAULT MODEL NAMES]")
  with open(DEFAULT_MODEL_NAME_PATH, "w") as f:
-    f.write(f'DEFAULT_MODEL = "{name}"\n')
-  print(f'New default model name: "{name}"')
+    f.write(f'DEFAULT_MODEL = "{default_model_name}"\n')
+    f.write(f'DEFAULT_BIG_MODEL = "{default_big_model_name}"\n')
+
+  print(f'New default small model name: "{default_model_name}"')
+  print(f'New default big model name: "{default_big_model_name}"')
  print("[DONE]")


 if __name__ == "__main__":
-  parser = argparse.ArgumentParser(description="Update default model name and hash")
-  parser.add_argument("--new_name", type=str, help="New default model name")
+  parser = argparse.ArgumentParser(description="Update default model names and hash")
+  parser.add_argument("--new_small_model_name", type=str, help="New default small model name")
+  parser.add_argument("--new_big_model_name", type=str, help="New default big model name")
  args = parser.parse_args()

-  if not args.new_name:
-    print("Warning: No new default model name provided. Use --new_name to specify")
-    print("Default model name and hash will not be updated! (aborted)")
-    exit(0)
+  if args.new_small_model_name is None and args.new_big_model_name is None:
+    new_name = input(f'Enter new default small model name (current: "{DEFAULT_MODEL}", leave empty to keep): ').strip()
+    new_big_model_name = input(f'Enter new default big model name (current: "{DEFAULT_BIG_MODEL}", leave empty to keep): ').strip()
+  else:
+    new_name, new_big_model_name = args.new_small_model_name, args.new_big_model_name

-  current_name = get_current_default_model_name()
-  new_name = args.new_name
-  if current_name == new_name:
-    print(f'Proposed default model name: "{new_name}"')
-    confirm = input("Proposed default model name is the same as the current default model name. Confirm? (y/n): ").upper().strip()
-    if confirm != "Y":
-      print("Default model name and hash will not be updated! (aborted)")
-      exit(0)
-
-  update_default_model_name(new_name)
+  update_default_model_names(new_name or DEFAULT_MODEL, new_big_model_name or DEFAULT_BIG_MODEL)
  update_model_hash()
@@ -13,7 +13,6 @@ from openpilot.common.params import Params
 from openpilot.common.swaglog import cloudlog
 from openpilot.common.hardware.hw import Paths
 from openpilot.sunnypilot.models.helpers import is_bundle_version_compatible
-
 from openpilot.cereal import custom


@@ -103,11 +102,11 @@ class ModelParser:
 class ModelCache:
  """Handles caching of model data to avoid frequent remote fetches"""

-  def __init__(self, params: Params, cache_timeout: int = int(3600 * 1e9)):
+  def __init__(self, params: Params, cache_timeout: int = int(3600 * 1e9), suffix: str = ""):
    self.params = params
    self.cache_timeout = cache_timeout
-    self._LAST_SYNC_KEY = "ModelManager_LastSyncTime"
-    self._CACHE_KEY = "ModelManager_ModelsCache"
+    self._LAST_SYNC_KEY = f"ModelManager_LastSyncTime{suffix}"
+    self._CACHE_KEY = f"ModelManager_ModelsCache{suffix}"

  def _is_expired(self) -> bool:
    """Checks if the cache has expired"""
@@ -139,32 +138,53 @@ class ModelCache:

 class ModelFetcher:
  """Handles fetching and caching of model data from remote source"""
-  MODEL_URL = "https://raw.githubusercontent.com/sunnypilot/sunnypilot-models/refs/heads/gh-pages/docs/driving_models_v18.json"
+  MODEL_URL = "https://raw.githubusercontent.com/sunnypilot/sunnypilot-models/refs/heads/gh-pages/docs/driving_models_v21.json"
+  MODEL_URL_USBGPU = "https://raw.githubusercontent.com/sunnypilot/sunnypilot-models/refs/heads/gh-pages/docs/driving_models_usbgpu_v22.json"
+
+  MODEL_SOURCES = {
+    "qcom": (MODEL_URL, ""),
+    "usbgpu": (MODEL_URL_USBGPU, "_USBGPU"),
+  }

  def __init__(self, params: Params):
    self.params = params
-    self.model_cache = ModelCache(params)
    self.model_parser = ModelParser()
+    self.model_caches = {
+      source: ModelCache(params, suffix=suffix)
+      for source, (_, suffix) in self.MODEL_SOURCES.items()
+    }
+    self._refetched: set[str] = set()
+    self.params.put("ModelManager_ActiveJson", {
+      "qcom": self.MODEL_URL,
+      "usbgpu": self.MODEL_URL_USBGPU,
+    }, block=True)

-  def _fetch_and_cache_models(self) -> list[custom.ModelManagerSP.ModelBundle] | None:
+  @staticmethod
+  def active_source(chestnut_present: bool) -> str:
+    return "usbgpu" if chestnut_present else "qcom"
+
+  def _fetch_and_cache_models(self, source: str) -> list[custom.ModelManagerSP.ModelBundle] | None:
    """Fetches fresh model data from remote and updates cache.
    Returns None on transport errors. Raises on 404 and other fatal HTTP errors.
    """
+    model_url, _ = self.MODEL_SOURCES[source]
    try:
-      response = requests.get(self.MODEL_URL, timeout=10)
+      response = requests.get(model_url, timeout=10)

      # Explicitly handle 404 differently
      if response.status_code == 404:
-        cloudlog.error(f"Models URL returned 404 Not Found: {self.MODEL_URL}")
-        raise HTTPError(f"404 Not Found: {self.MODEL_URL}", response=response)
+        cloudlog.error(f"Models URL returned 404 Not Found: {model_url}")
+        raise HTTPError(f"404 Not Found: {model_url}", response=response)

      # Raise for any other 4xx/5xx
      response.raise_for_status()

      json_data = response.json()
-      self.model_cache.set(json_data)
-      cloudlog.debug("Successfully updated models cache")
-      return self.model_parser.parse_models(json_data)
+      parsed = self.model_parser.parse_models(json_data)
+      if parsed:
+        self.model_caches[source].set(json_data)
+        cloudlog.debug(f"Successfully updated models cache for {source}")
+      return parsed

    except ConnectionError as e:
      cloudlog.warning(f"DNS/connection error while fetching models: {e}")
@@ -177,15 +197,40 @@ class ModelFetcher:

    return None

-  def get_available_bundles(self) -> list[custom.ModelManagerSP.ModelBundle]:
-    """Gets the list of available models, with smart cache handling"""
-    cached_data, is_expired = self.model_cache.get()
+  @staticmethod
+  def _cache_matches_source(source: str, cached_data: dict) -> bool:
+    bundles = cached_data.get("bundles", [])
+    if source == "usbgpu":
+      return any(bundle.get("is_big") is True for bundle in bundles)
+    return not any(bundle.get("is_big") is True for bundle in bundles)
+
+  def get_bundles_for_source(self, source: str) -> list[custom.ModelManagerSP.ModelBundle]:
+    if source not in self.MODEL_SOURCES:
+      cloudlog.warning(f"Unknown model source: {source}")
+      return []
+
+    cached_data, is_expired = self.model_caches[source].get()

    if cached_data and not is_expired:
-      cloudlog.debug("Using valid cached models data")
-      return self.model_parser.parse_models(cached_data)
+      # a source is refetched over a mismatch at most once per process: if the fresh
+      # manifest still mismatches, the URL is authoritative and the cache is trusted
+      if self._cache_matches_source(source, cached_data) or source in self._refetched:
+        try:
+          parsed = self.model_parser.parse_models(cached_data)
+        except Exception:
+          cloudlog.warning(f"Failed to parse cached models for {source}; refetching", exc_info=True)
+        else:
+          if parsed:
+            cloudlog.debug(f"Using valid cached models data for source {source}")
+            return parsed
+          # a source-matching cache that yields no valid bundles is stale (e.g. an old
+          # manifest version) - do not trust it, refetch so the source is repopulated
+          cloudlog.warning(f"Cached models for {source} have no valid bundles; refetching")
+      else:
+        self._refetched.add(source)
+        cloudlog.warning(f"Cached models for {source} not valid; refetching once")

-    fetched_bundles = self._fetch_and_cache_models()
+    fetched_bundles = self._fetch_and_cache_models(source)
    if fetched_bundles is not None:
      return fetched_bundles

@@ -193,19 +238,37 @@ class ModelFetcher:
      cloudlog.warning("Failed to fetch fresh data and no cache available")

    cloudlog.warning("Failed to fetch fresh data. Using expired cache as fallback")
-    return self.model_parser.parse_models(cached_data)
+    try:
+      return self.model_parser.parse_models(cached_data)
+    except Exception:
+      return []
+
+
+def get_cached_bundles(params: Params, source: str) -> list[custom.ModelManagerSP.ModelBundle]:
+
+  if source not in ModelFetcher.MODEL_SOURCES:
+    cloudlog.warning(f"Unknown model source: {source}")
+    return []
+  _, suffix = ModelFetcher.MODEL_SOURCES[source]
+  cached_data = params.get(f"ModelManager_ModelsCache{suffix}")
+  if not cached_data:
+    return []
+  try:
+    return ModelParser.parse_models(cached_data)
+  except Exception as e:
+    cloudlog.warning(f"Failed to parse cached models for source {source}: {e}")
+    return []
+

 if __name__ == "__main__":
+  from openpilot.selfdrive.modeld.helpers import usbgpu_present
  params = Params()
  model_fetcher = ModelFetcher(params)
-  bundles = model_fetcher.get_available_bundles()
+  bundles = model_fetcher.get_bundles_for_source(ModelFetcher.active_source(usbgpu_present()))
  for bundle in bundles:
    for model in bundle.models:
      model_overrides = {override.key: override.value for override in bundle.overrides}
-      # Print model details
      print(f"Bundle: {bundle.internalName}, Type: {model.type}, Status: {bundle.status}, Overrides: {model_overrides}")
-      # Print artifact details
      print(f"Artifact: {model.artifact.fileName}, Download URI: {model.artifact.downloadUri.uri}")
-      # Print metadata details
      if model.artifact.chunks:
        print(f"Contains {len(model.artifact.chunks)} chunks.")
@@ -16,14 +16,20 @@ from openpilot.common.params import Params
 from openpilot.common.swaglog import cloudlog
 from openpilot.sunnypilot.models.constants import Meta, MetaSimPose, MetaTombRaider
 from openpilot.common.hardware.hw import Paths
+from openpilot.selfdrive.modeld.helpers import usbgpu_present

 # SET ME TO THE EXACT JSON VERSION WE SET IN SUNNYPILOT_MODELS REPO
-REQUIRED_JSON_VERSION = 16
+REQUIRED_JSON_VERSION = 18

 CUSTOM_MODEL_PATH = Paths.model_root()
 METADATA_PATH = Path(__file__).parent / '../models/supercombo_metadata.pkl'
 ModelManager = custom.ModelManagerSP
-_LAST_VALIDATED_RAW = None
+
+ACTIVE_BUNDLE_KEYS = {
+  "qcom": "ModelManager_ActiveBundle",
+  "usbgpu": "ModelManager_ActiveBundleUSBGPU",
+}
+_LAST_VALIDATED_RAW: dict[str, dict | None] = {}


 def _compute_hash(file_path: str) -> str | None:
@@ -86,11 +92,11 @@ def _bundle_needs_reset(active_bundle: custom.ModelManagerSP.ModelBundle, availa
  if available_bundles is not None:
    matching_bundle = None
    for bundle in available_bundles:
-      if getattr(active_bundle, 'ref', None) and getattr(bundle, 'ref', None):
+      if active_bundle.ref and bundle.ref:
        if active_bundle.ref == bundle.ref:
          matching_bundle = bundle
          break
-      elif getattr(active_bundle, 'internalName', None) == getattr(bundle, 'internalName', None):
+      elif active_bundle.internalName == bundle.internalName:
        matching_bundle = bundle
        break

@@ -98,49 +104,81 @@ def _bundle_needs_reset(active_bundle: custom.ModelManagerSP.ModelBundle, availa
      return True
    if active_bundle.minimumSelectorVersion != matching_bundle.minimumSelectorVersion:
      return True
-
-    active_runner = getattr(active_bundle, 'runner', None)
-    matching_runner = getattr(matching_bundle, 'runner', None)
-    if active_runner is not None and matching_runner is not None:
-      if getattr(active_runner, 'raw', active_runner) != getattr(matching_runner, 'raw', matching_runner):
-        return True
+    if active_bundle.runner != matching_bundle.runner:
+      return True
    if set(_bundle_artifacts(active_bundle)) != set(_bundle_artifacts(matching_bundle)):
      return True

  return not _bundle_is_valid_locally(active_bundle)


-def validate_active_bundle(params: Params, available_bundles: list[custom.ModelManagerSP.ModelBundle] | None = None) -> None:
-  global _LAST_VALIDATED_RAW
-
-  raw_bundle = params.get("ModelManager_ActiveBundle")
-  if not raw_bundle:
-    return
-
-  if raw_bundle == _LAST_VALIDATED_RAW:
-    return
-
-  active_bundle = get_active_bundle(params, raw_bundle_dict=raw_bundle)
-  if active_bundle is None or _bundle_needs_reset(active_bundle, available_bundles):
-    cloudlog.warning("Active model bundle invalid; resetting to default")
-    params.remove("ModelManager_ActiveBundle")
-    params.put("ModelRunnerTypeCache", int(custom.ModelManagerSP.Runner.stock), block=True)
-    _LAST_VALIDATED_RAW = None
-  else:
-    _LAST_VALIDATED_RAW = raw_bundle
-
-
-def get_active_bundle(params: Params | None = None, raw_bundle_dict: dict | bytes | None = None) -> "custom.ModelManagerSP.ModelBundle | None":
-  params = params or Params()
+def _parse_active_bundle(raw_bundle) -> "custom.ModelManagerSP.ModelBundle | None":
  try:
-    active_bundle_dict = raw_bundle_dict if raw_bundle_dict is not None else (params.get("ModelManager_ActiveBundle") or {})
-    if isinstance(active_bundle_dict, dict) and active_bundle_dict and is_bundle_version_compatible(active_bundle_dict):
-      return custom.ModelManagerSP.ModelBundle(**active_bundle_dict)
+    if isinstance(raw_bundle, dict) and raw_bundle and is_bundle_version_compatible(raw_bundle):
+      return custom.ModelManagerSP.ModelBundle(**raw_bundle)
  except Exception:
    pass
  return None


+def get_selected_bundle(params: Params | None = None, source: str = "qcom") -> "custom.ModelManagerSP.ModelBundle | None":
+  params = params or Params()
+  return _parse_active_bundle(params.get(ACTIVE_BUNDLE_KEYS[source]))
+
+
+def get_active_source(usbgpu: bool | None = None, usbgpu_active: bool | None = None,
+                      usbgpu_loading: bool | None = None, offroad: bool | None = None) -> str:
+  if usbgpu is None:
+    usbgpu = usbgpu_present()
+  state_valid = usbgpu_active is not None or usbgpu_loading is not None or offroad is not None
+  big_active = usbgpu and (not state_valid or usbgpu_active or usbgpu_loading or offroad)
+  return "usbgpu" if big_active else "qcom"
+
+
+def get_active_bundle(params: Params | None = None, *, usbgpu: bool | None = None) -> "custom.ModelManagerSP.ModelBundle | None":
+  # no cross-slot fallback: an empty active slot means the hardware default, which
+  # only stock modeld can run - modeld_v2 requires a real bundle
+  params = params or Params()
+  return get_selected_bundle(params, get_active_source(usbgpu=usbgpu))
+
+
+def resolve_bundle_by_ref(
+  ref: str, source_bundles: dict[str, list[custom.ModelManagerSP.ModelBundle]],
+) -> "tuple[custom.ModelManagerSP.ModelBundle, str] | None":
+  for source, bundles in source_bundles.items():
+    for bundle in bundles:
+      if bundle.ref == ref:
+        return bundle, source
+  return None
+
+
+def _validate_active_bundle(params: Params, source: str, available_bundles: list[custom.ModelManagerSP.ModelBundle] | None = None) -> None:
+  global _LAST_VALIDATED_RAW
+
+  key = ACTIVE_BUNDLE_KEYS[source]
+  raw_bundle = params.get(key)
+  if not raw_bundle:
+    return
+
+  if _LAST_VALIDATED_RAW.get(key) == raw_bundle:
+    return
+
+  active_bundle = _parse_active_bundle(raw_bundle)
+  if active_bundle is None or _bundle_needs_reset(active_bundle, available_bundles):
+    cloudlog.warning(f"Active model bundle invalid for {source}; resetting to default")
+    params.remove(key)
+    _LAST_VALIDATED_RAW[key] = None
+  else:
+    _LAST_VALIDATED_RAW[key] = raw_bundle
+
+
+def validate_active_bundles(params: Params, source_bundles: dict[str, list[custom.ModelManagerSP.ModelBundle]]) -> None:
+  # an empty list means the fetch failed, not that the catalog dropped the bundle
+  for source, bundles in source_bundles.items():
+    _validate_active_bundle(params, source, bundles or None)
+  get_active_model_runner(params, force_check=True)
+
+
 def get_active_model_runner(params: Params | None = None, force_check: bool = False) -> int:
  params = params or Params()
  cached_runner_type = params.get("ModelRunnerTypeCache")
@@ -17,12 +17,17 @@ from openpilot.common.hardware.hw import Paths

 from openpilot.cereal import messaging, custom
 from openpilot.sunnypilot.models.fetcher import ModelFetcher
-from openpilot.sunnypilot.models.helpers import get_active_bundle, validate_active_bundle, verify_file
+from openpilot.sunnypilot.models.helpers import (ACTIVE_BUNDLE_KEYS, get_active_bundle, get_selected_bundle,
+                                                  resolve_bundle_by_ref, validate_active_bundles, verify_file)

 # (connect, read) seconds. read is per-request inactivity, not a total cap
 DOWNLOAD_TIMEOUT = (30, 30)


+class DownloadCancelled(Exception):
+  pass
+
+
 class ModelManagerSP:
  """Manages model downloads and status reporting"""

@@ -30,11 +35,25 @@ class ModelManagerSP:
    self.params = Params()
    self.model_fetcher = ModelFetcher(self.params)
    self.pm = messaging.PubMaster(["modelManagerSP"])
+    self.sm = messaging.SubMaster(["deviceState"])
+    self.chestnut_present = False
    self.available_models: list[custom.ModelManagerSP.ModelBundle] = []
+    self.source_models: dict[str, list[custom.ModelManagerSP.ModelBundle]] = {}
    self.selected_bundle: custom.ModelManagerSP.ModelBundle = None
-    self.active_bundle: custom.ModelManagerSP.ModelBundle = get_active_bundle(self.params)
+    self.active_bundle: custom.ModelManagerSP.ModelBundle = get_active_bundle(self.params, usbgpu=self.chestnut_present)
    self._chunk_size = 128 * 1000  # 128 KB chunks
    self._download_start_times: dict[str, float] = {}  # Track start time per model
+    self._download_ref: bytes | str | None = None
+
+  def _download_interrupted(self) -> bool:
+    # only removal cancels: a different ref is a queued selection that
+    # _release_download_ref leaves in place for the next tick
+    return self.params.get("ModelManager_DownloadRef") is None
+
+  def _release_download_ref(self) -> None:
+    if self.params.get("ModelManager_DownloadRef") == self._download_ref:
+      self.params.remove("ModelManager_DownloadRef")
+    self._download_ref = None

  def _sync_artifact_progress(self, source_artifact) -> None:
    """Mirror download progress to all artifacts sharing the same filename in the selected bundle."""
@@ -76,8 +95,8 @@ class ModelManagerSP:
          f.write(chunk)
          bytes_downloaded += len(chunk)

-          if self.params.get("ModelManager_DownloadIndex") is None:
-            raise Exception("Download cancelled")
+          if self._download_interrupted():
+            raise DownloadCancelled("Download cancelled")

          if total_size > 0:
            progress = (bytes_downloaded / total_size) * 100
@@ -90,7 +109,7 @@ class ModelManagerSP:
    # Clean up start time after download completes
    del self._download_start_times[model.fileName]

-  async def _download_chunked(self, base_url: str, base_path: str, artifact) -> None:
+  async def _download_chunked(self, base_url: str, base_path: str, artifact, skip: frozenset[int] | set[int] = frozenset()) -> None:
    from openpilot.common.file_chunker import get_chunk_name, get_manifest_path

    num_chunks = len(artifact.chunks)
@@ -102,8 +121,11 @@ class ModelManagerSP:

    # Shared connection saves a TCP+TLS handshake per chunk.
    # Keep sequential: the link saturates on one stream and Session is not thread-safe.
+    completed = len(skip)
    with requests.Session() as session:
      for i, _ in enumerate(artifact.chunks):
+        if i in skip:
+          continue
        chunk_url = get_chunk_name(base_url, i, num_chunks)
        chunk_path = get_chunk_name(base_path, i, num_chunks)
        chunk_downloaded = 0
@@ -114,15 +136,16 @@ class ModelManagerSP:
            for data in response.iter_content(chunk_size=self._chunk_size):
              f.write(data)
              chunk_downloaded += len(data)
-              if self.params.get("ModelManager_DownloadIndex") is None:
-                raise Exception("Download cancelled")
+              if self._download_interrupted():
+                raise DownloadCancelled("Download cancelled")
              intra = chunk_downloaded / max(chunk_size, 1)
-              progress = min(99.0, ((i + intra) / num_chunks) * 100)
+              progress = min(99.0, ((completed + intra) / num_chunks) * 100)
              artifact.downloadProgress.status = custom.ModelManagerSP.DownloadStatus.downloading
              artifact.downloadProgress.progress = progress
              artifact.downloadProgress.eta = self._calculate_eta(artifact.fileName, progress)
              self._sync_artifact_progress(artifact)
              self._report_status()
+        completed += 1

    with open(manifest_path, 'w') as f:  # noqa: ASYNC230
      f.write(str(num_chunks))
@@ -133,6 +156,8 @@ class ModelManagerSP:
  async def _process_artifact(self, artifact, destination_path: str) -> None:
    if not artifact.downloadUri.uri:
      return None
+    if self._download_interrupted():
+      raise DownloadCancelled("Download cancelled")

    url = artifact.downloadUri.uri
    expected_hash = artifact.downloadUri.sha256
@@ -140,17 +165,23 @@ class ModelManagerSP:
    full_path = os.path.join(destination_path, filename)

    try:
+      # progress counts only valid chunks so a resumed download continues the
+      # bar from where verification left it, instead of falling back to zero
      is_cached = False
+      valid_chunks: set[int] = set()
      if len(artifact.chunks) > 0:
        from openpilot.common.file_chunker import get_chunk_name
-        chunks_valid = True
+        num_chunks = len(artifact.chunks)
        for i, chunk in enumerate(artifact.chunks):
-          chunk_path = get_chunk_name(full_path, i, len(artifact.chunks))
-          if not await verify_file(chunk_path, chunk.sha256):
-            chunks_valid = False
-            break
-        if chunks_valid and len(artifact.chunks) > 0:
-          is_cached = True
+          if self._download_interrupted():
+            raise DownloadCancelled("Download cancelled")
+          if await verify_file(get_chunk_name(full_path, i, num_chunks), chunk.sha256):
+            valid_chunks.add(i)
+          artifact.downloadProgress.status = custom.ModelManagerSP.DownloadStatus.verifying
+          artifact.downloadProgress.progress = (len(valid_chunks) / num_chunks) * 100
+          self._sync_artifact_progress(artifact)
+          self._report_status()
+        is_cached = len(valid_chunks) == num_chunks
      else:
        if await verify_file(full_path, expected_hash):
          is_cached = True
@@ -164,7 +195,7 @@ class ModelManagerSP:
        return

      if len(artifact.chunks) > 0:
-        await self._download_chunked(url, full_path, artifact)
+        await self._download_chunked(url, full_path, artifact, skip=valid_chunks)
        from openpilot.common.file_chunker import get_chunk_name
        for i, chunk in enumerate(artifact.chunks):
          chunk_path = get_chunk_name(full_path, i, len(artifact.chunks))
@@ -181,6 +212,17 @@ class ModelManagerSP:
      self._sync_artifact_progress(artifact)
      self._report_status()

+    except DownloadCancelled:
+      # a cancel keeps whatever is on disk: complete chunks resume the next attempt
+      self._download_start_times.pop(artifact.fileName, None)
+      artifact.downloadProgress.status = custom.ModelManagerSP.DownloadStatus.failed
+      artifact.downloadProgress.eta = 0
+      self._sync_artifact_progress(artifact)
+      if self.selected_bundle:
+        self.selected_bundle.status = custom.ModelManagerSP.DownloadStatus.failed
+      self._report_status()
+      raise
+
    except Exception as e:
      cloudlog.error(f"Error downloading {filename}: {str(e)}")
      for f in [full_path] + [p for p in (os.path.join(destination_path, f) for f in os.listdir(destination_path)) if filename in p]:
@@ -212,10 +254,12 @@ class ModelManagerSP:
    model_manager_state.availableBundles = self.available_models
    self.pm.send('modelManagerSP', msg)

-  async def _download_bundle(self, model_bundle: custom.ModelManagerSP.ModelBundle, destination_path: str) -> None:
-    """Downloads all models in a bundle"""
+  async def _download_bundle(self, model_bundle: custom.ModelManagerSP.ModelBundle, destination_path: str, source: str) -> None:
    self.selected_bundle = model_bundle
    self.selected_bundle.status = custom.ModelManagerSP.DownloadStatus.downloading
+    for model in self.selected_bundle.models:
+      model.artifact.downloadProgress.status = custom.ModelManagerSP.DownloadStatus.downloading
+    self._report_status()
    os.makedirs(destination_path, exist_ok=True)

    try:
@@ -232,10 +276,11 @@ class ModelManagerSP:
          seen_artifacts.add(artifact.fileName)
          await self._process_artifact(artifact, destination_path)

-      self.active_bundle = self.selected_bundle
-      self.active_bundle.status = custom.ModelManagerSP.DownloadStatus.downloaded
-      self.params.put("ModelManager_ActiveBundle", self.active_bundle.to_dict(), block=True)
-      self.selected_bundle = None
+      if self._download_interrupted():
+        raise DownloadCancelled("Download cancelled")
+      self.selected_bundle.status = custom.ModelManagerSP.DownloadStatus.downloaded
+      self.params.put(ACTIVE_BUNDLE_KEYS[source], model_bundle.to_dict(), block=True)
+      self.active_bundle = get_active_bundle(self.params, usbgpu=self.chestnut_present)

    except Exception:
      if self.selected_bundle is not None:
@@ -245,9 +290,30 @@ class ModelManagerSP:
    finally:
      self._report_status()

-  def download(self, model_bundle: custom.ModelManagerSP.ModelBundle, destination_path: str) -> None:
+  def download(self, model_bundle: custom.ModelManagerSP.ModelBundle, destination_path: str, source: str) -> None:
    """Main entry point for downloading a model bundle"""
-    asyncio.run(self._download_bundle(model_bundle, destination_path))
+    asyncio.run(self._download_bundle(model_bundle, destination_path, source))
+
+  def _process_download_requests(self) -> None:
+    # loops so a ref queued during a download starts in the same tick, without
+    # the bar dropping to idle for a tick between the two transfers
+    last_ref = None
+    while (ref_to_download := self.params.get("ModelManager_DownloadRef")) is not None:
+      if ref_to_download == last_ref:  # a repeating ref falls back to the next tick instead of spinning
+        return
+      last_ref = ref_to_download
+      resolved = resolve_bundle_by_ref(ref_to_download, self.source_models)
+      if not resolved:
+        return
+      model_to_download, source = resolved
+      self._download_ref = ref_to_download
+      try:
+        self.download(model_to_download, Paths.model_root(), source)
+      except Exception as e:
+        cloudlog.exception(e)
+      finally:
+        self._release_download_ref()
+        self.selected_bundle = None

  def main_thread(self) -> None:
    """Main thread for model management"""
@@ -255,19 +321,14 @@ class ModelManagerSP:

    while True:
      try:
-        self.available_models = self.model_fetcher.get_available_bundles()
-        validate_active_bundle(self.params, self.available_models)
-        self.active_bundle = get_active_bundle(self.params)
+        self.sm.update(0)
+        self.chestnut_present = self.sm['deviceState'].chestnutPresent
+        self.source_models = {source: self.model_fetcher.get_bundles_for_source(source) for source in ModelFetcher.MODEL_SOURCES}
+        self.available_models = self.source_models[ModelFetcher.active_source(self.chestnut_present)]
+        validate_active_bundles(self.params, self.source_models)
+        self.active_bundle = get_active_bundle(self.params, usbgpu=self.chestnut_present)

-        if (index_to_download := self.params.get("ModelManager_DownloadIndex")) is not None:
-          if model_to_download := next((model for model in self.available_models if model.index == index_to_download), None):
-            try:
-              self.download(model_to_download, Paths.model_root())
-            except Exception as e:
-              cloudlog.exception(e)
-            finally:
-              self.params.remove("ModelManager_DownloadIndex")
-              self.selected_bundle = None
+        self._process_download_requests()

        if self.params.get("ModelManager_ClearCache"):
          self.clear_model_cache()
@@ -285,12 +346,14 @@ class ModelManagerSP:
    Clears the model cache directory of all files except those in the active model bundle.
    """

-    # Get list of files used by active model bundle
+    # Get list of files used by both slots' selected bundles (either may become
+    # the truly active bundle depending on hardware availability)
    active_files = []
-    if self.active_bundle is not None: # When the default model is active
-      for model in self.active_bundle.models:
-        if hasattr(model, 'artifact') and model.artifact.fileName:
-          active_files.append(model.artifact.fileName)
+    for source in ACTIVE_BUNDLE_KEYS:
+      if selected_bundle := get_selected_bundle(self.params, source):
+        for model in selected_bundle.models:
+          if model.artifact.fileName:
+            active_files.append(model.artifact.fileName)

    # Remove all files except active ones (including their chunk files)
    model_dir = Paths.model_root()
@@ -1 +1,2 @@
 DEFAULT_MODEL = "CD210"
+DEFAULT_BIG_MODEL = "Lebowski"
@@ -20,4 +20,4 @@ class TestDefaultModel(OpenpilotTestCase):
    with open(MODEL_HASH_PATH) as f:
      current_hash = f.read().strip()

-    assert combined_hash == current_hash, "Run sunnypilot/models/default_model.py to update the default model name and hash"
+    assert combined_hash == current_hash, "Run openpilot/sunnypilot/models/default_model.py to update the default model name and hash"
@@ -11,6 +11,7 @@ import http.server
 import os
 import tempfile
 import threading
+import time
 import unittest
 from typing import Any
 from unittest import mock
@@ -23,6 +24,10 @@ from openpilot.common.test import OpenpilotTestCase
 from openpilot.common.file_chunker import get_chunk_name, get_manifest_path
 from openpilot.selfdrive.test.helpers import http_server_context
 from openpilot.sunnypilot.models import manager as manager_module
+from openpilot.sunnypilot.models.fetcher import ModelFetcher, get_cached_bundles
+from openpilot.sunnypilot.models import helpers
+from openpilot.sunnypilot.models.helpers import (get_active_bundle, get_active_source, get_selected_bundle,
+                                                  resolve_bundle_by_ref, validate_active_bundles)
 from openpilot.sunnypilot.models.manager import ModelManagerSP

 CHUNK_BODIES = [b'A' * 5000, b'B' * 5000, b'C' * 3000]
@@ -98,11 +103,13 @@ class ManagerDownloadTestBase(OpenpilotTestCase):
    self.manager = ModelManagerSP.__new__(ModelManagerSP)
    self.manager.params = mock.MagicMock()
    self.manager.params.get.return_value = b'0'  # not cancelled
+    self.manager._download_ref = b'0'
    self.manager.pm = mock.MagicMock()
    self.manager.pm.send.side_effect = self._record_progress
    self.manager.selected_bundle = None
    self.manager.active_bundle = None
    self.manager.available_models = []
+    self.manager.chestnut_present = False
    self.manager._chunk_size = 1024
    self.manager._download_start_times = {}

@@ -249,6 +256,166 @@ class TestManagerDownload(ManagerDownloadTestBase):
        assert self.manager._download_start_times == {}
    self.run_with_server(body)

+  def test_download_ref_present_keeps_download_alive(self):
+    """A pending download request (DownloadRef set) must not be cancelled mid-transfer."""
+    def body():
+      artifact = self.make_artifact(chunked=True)
+      base_path = os.path.join(self.dest, artifact.fileName)
+      self.manager.params.get.side_effect = lambda key: b"ref" if key == "ModelManager_DownloadRef" else None
+      self.manager._download_ref = b"ref"
+      asyncio.run(self.manager._download_chunked(artifact.downloadUri.uri, base_path, artifact))
+      assert os.path.isfile(get_manifest_path(base_path))
+    self.run_with_server(body)
+
+  def test_cancellation_via_download_ref(self):
+    """Removing DownloadRef mid-transfer cancels the download."""
+    def body():
+      artifact = self.make_artifact(chunked=True)
+      base_path = os.path.join(self.dest, artifact.fileName)
+      checks = {"n": 0}
+
+      def get(key):
+        if key == "ModelManager_DownloadRef":
+          checks["n"] += 1
+          return b"ref" if checks["n"] <= 2 else None
+        return b"0"
+
+      self.manager.params.get.side_effect = get
+      self.manager._download_ref = b"ref"
+      with self.assertRaises(Exception) as ctx:
+        asyncio.run(self.manager._download_chunked(artifact.downloadUri.uri, base_path, artifact))
+      assert 'cancelled' in str(ctx.exception).lower()
+      assert not os.path.isfile(get_manifest_path(base_path))
+    self.run_with_server(body)
+
+  def test_replaced_download_ref_queues_instead_of_cancelling(self):
+    """Selecting another model mid-transfer lets the running download finish."""
+    def body():
+      artifact = self.make_artifact(chunked=True)
+      base_path = os.path.join(self.dest, artifact.fileName)
+      self.manager.params.get.side_effect = lambda key: b"other-ref" if key == "ModelManager_DownloadRef" else None
+      self.manager._download_ref = b"ref"
+      asyncio.run(self.manager._download_chunked(artifact.downloadUri.uri, base_path, artifact))
+      assert os.path.isfile(get_manifest_path(base_path))
+    self.run_with_server(body)
+
+  def test_replaced_download_ref_is_kept(self):
+    """A selection made during a download must survive that download's cleanup."""
+    self.manager.params.get.return_value = b"new-ref"
+    self.manager._download_ref = b"old-ref"
+    self.manager._release_download_ref()
+    self.manager.params.remove.assert_not_called()
+
+  def test_own_download_ref_is_released(self):
+    self.manager.params.get.return_value = b"ref"
+    self.manager._download_ref = b"ref"
+    self.manager._release_download_ref()
+    self.manager.params.remove.assert_called_once_with("ModelManager_DownloadRef")
+
+  def test_cached_bundle_cancel_skips_slot_write(self):
+    """A cancel must stop an already-on-disk bundle before it is applied to the slot."""
+    def body():
+      artifact = self.make_artifact(chunked=True)
+      base_path = os.path.join(self.dest, artifact.fileName)
+      for i, data in enumerate(CHUNK_BODIES):
+        with open(get_chunk_name(base_path, i, len(CHUNK_BODIES)), 'wb') as f:
+          f.write(data)
+      self._bundle.ref = "test-ref"
+      params, store = self._make_params_with_store()
+      store["ModelManager_DownloadRef"] = None  # removed -> cancelled
+      self.manager.params = params
+      self.manager._download_ref = b"ref"
+      with self.assertRaises(Exception) as ctx:
+        asyncio.run(self.manager._download_bundle(self._bundle, self.dest, "qcom"))
+      assert 'cancelled' in str(ctx.exception).lower()
+      assert "ModelManager_ActiveBundle" not in store
+      assert all(os.path.isfile(p) for p in self.chunk_paths(base_path)), "cancel must not delete cached chunks"
+    self.run_with_server(body)
+
+  def test_resume_skips_valid_chunks(self):
+    """A chunk already on disk is kept and not re-downloaded; progress starts above its share."""
+    def body():
+      artifact = self.make_artifact(chunked=True)
+      base_path = os.path.join(self.dest, artifact.fileName)
+      with open(get_chunk_name(base_path, 0, len(CHUNK_BODIES)), 'wb') as f:
+        f.write(CHUNK_BODIES[0])
+
+      asyncio.run(self.manager._process_artifact(artifact, self.dest))
+
+      chunk0_suffix = get_chunk_name('', 0, len(CHUNK_BODIES))
+      assert not any(p.endswith(chunk0_suffix) for p in DownloadHandler.request_paths), "valid chunk was re-downloaded"
+      for i, expected in enumerate(CHUNK_BODIES):
+        with open(get_chunk_name(base_path, i, len(CHUNK_BODIES)), 'rb') as f:
+          assert f.read() == expected
+      assert os.path.isfile(get_manifest_path(base_path))
+      assert min(self.reported) >= (1 / len(CHUNK_BODIES)) * 100 - 1, "progress must not restart below the resumed share"
+    self.run_with_server(body)
+
+  def test_verify_reports_valid_fraction_then_cached(self):
+    """A fully cached bundle publishes climbing verify progress and ends cached."""
+    def body():
+      artifact = self.make_artifact(chunked=True)
+      base_path = os.path.join(self.dest, artifact.fileName)
+      for i, data in enumerate(CHUNK_BODIES):
+        with open(get_chunk_name(base_path, i, len(CHUNK_BODIES)), 'wb') as f:
+          f.write(data)
+
+      asyncio.run(self.manager._process_artifact(artifact, self.dest))
+
+      assert DownloadHandler.request_paths == [], "cached bundle must not hit the network"
+      assert [round(p) for p in self.reported[:3]] == [33, 67, 100]
+      assert artifact.downloadProgress.status == custom.ModelManagerSP.DownloadStatus.cached
+    self.run_with_server(body)
+
+  def _make_params_with_store(self):
+    params = mock.MagicMock()
+    store = {}
+
+    def get(key, *args, **kwargs):
+      return store.get(key, b"0")  # b"0" -> download not cancelled
+
+    def put(key, value, *args, **kwargs):
+      store[key] = value
+
+    params.get.side_effect = get
+    params.put.side_effect = put
+    return params, store
+
+  def test_download_writes_qcom_slot(self):
+    """A download resolved to the qcom source writes the qcom active bundle slot only."""
+    def body():
+      artifact = self.make_artifact(chunked=True)
+      self._bundle.ref = "test-ref"
+      self._bundle.minimumSelectorVersion = 18
+      params, store = self._make_params_with_store()
+      self.manager.params = params
+      asyncio.run(self.manager._download_bundle(self._bundle, self.dest, "qcom"))
+
+      assert "ModelManager_ActiveBundle" in store, "qcom download must write the qcom slot"
+      assert "ModelManager_ActiveBundleUSBGPU" not in store, "qcom download must not touch the usbgpu slot"
+      assert self.manager.selected_bundle.status == custom.ModelManagerSP.DownloadStatus.downloaded
+      assert self.manager.active_bundle is not None and self.manager.active_bundle.ref == "test-ref"
+      assert self.manager.active_bundle.status == custom.ModelManagerSP.DownloadStatus.downloaded
+      chunk_names = [get_chunk_name(artifact.fileName, i, len(artifact.chunks)) for i in range(len(artifact.chunks))]
+      missing = [c for c in chunk_names if not os.path.isfile(os.path.join(self.dest, c))]
+      assert missing == [], f"chunks missing from the cache: {missing}"
+    self.run_with_server(body)
+
+  def test_download_writes_usbgpu_slot(self):
+    """A download resolved to the usbgpu source writes the usbgpu active bundle slot only."""
+    def body():
+      self.make_artifact(chunked=True)
+      self._bundle.ref = "big-ref"
+      self._bundle.minimumSelectorVersion = 18
+      params, store = self._make_params_with_store()
+      self.manager.params = params
+      asyncio.run(self.manager._download_bundle(self._bundle, self.dest, "usbgpu"))
+
+      assert "ModelManager_ActiveBundleUSBGPU" in store, "usbgpu download must write the usbgpu slot"
+      assert "ModelManager_ActiveBundle" not in store, "usbgpu download must not touch the qcom slot"
+      assert self.manager.selected_bundle.status == custom.ModelManagerSP.DownloadStatus.downloaded
+    self.run_with_server(body)
+

 class TestManagerImports(OpenpilotTestCase):
  """Catches undeclared dependencies. aiohttp lived only in the AGNOS venv; 19.6 dropped
@@ -267,6 +434,352 @@ class TestManagerImports(OpenpilotTestCase):
    assert connect > 0 and read > 0, "requests defaults to no timeout; downloads would hang forever"


+class TestResolveBundleByRef(OpenpilotTestCase):
+  """A ref resolves to (bundle, source) across both hardware manifests. Refs are
+  unique per manifest and never overlap across sources, so a ref maps to exactly
+  one slot. Shared by the manager's download flow and the settings UI."""
+
+  @staticmethod
+  def _bundle(ref: str):
+    bundle = custom.ModelManagerSP.ModelBundle.new_message()
+    bundle.ref = ref
+    return bundle
+
+  def test_qcom_ref_resolves_to_qcom_slot(self):
+    small = self._bundle("small")
+    assert resolve_bundle_by_ref("small", {"qcom": [small], "usbgpu": []}) == (small, "qcom")
+
+  def test_usbgpu_ref_resolves_to_usbgpu_slot(self):
+    big = self._bundle("big")
+    assert resolve_bundle_by_ref("big", {"qcom": [], "usbgpu": [big]}) == (big, "usbgpu")
+
+  def test_unknown_ref_returns_none(self):
+    source_bundles = {"qcom": [self._bundle("small")], "usbgpu": []}
+    assert resolve_bundle_by_ref("nope", source_bundles) is None
+
+
+def manifest_bundle(short_name: str, ref: str, index: int = 0, is_big: bool = False) -> dict:
+  """Minimal manifest bundle dict, version-compatible (no chunks to avoid disk side effects).
+  Big (usbgpu) bundles carry `is_big: true` in the manifest JSON."""
+  return {
+    "index": index,
+    "short_name": short_name,
+    "display_name": short_name.upper(),
+    "generation": 1,
+    "environment": "release",
+    "runner": "tinygrad",
+    "is_big": is_big,
+    "minimum_selector_version": "18",
+    "ref": ref,
+    "models": [{
+      "type": "supercombo",
+      "artifact": {
+        "file_name": f"{short_name}.pkl",
+        "download_uri": {"url": f"https://example.com/{short_name}.pkl", "sha256": "s"},
+      },
+    }],
+  }
+
+
+def fresh_sync_time() -> int:
+  return int(time.monotonic() * 1e9)
+
+
+class TestModelFetcherSources(OpenpilotTestCase):
+  """Both manifests are always maintained: get_bundles_for_source exposes either
+  source by name, and active_source picks which one matches the attached hardware."""
+
+  def _make_params(self, qcom_manifest, usbgpu_manifest):
+    params = mock.MagicMock()
+
+    def get(key):
+      if key == "ModelManager_ModelsCache":
+        return qcom_manifest
+      if key == "ModelManager_ModelsCache_USBGPU":
+        return usbgpu_manifest
+      if key in ("ModelManager_LastSyncTime", "ModelManager_LastSyncTime_USBGPU"):
+        return fresh_sync_time()
+      return None
+
+    params.get.side_effect = get
+    return params
+
+  def test_active_source_follows_chestnut_presence(self):
+    assert ModelFetcher.active_source(False) == "qcom"
+    assert ModelFetcher.active_source(True) == "usbgpu"
+
+  def test_get_bundles_for_source_returns_each_source(self):
+    params = self._make_params({"bundles": [manifest_bundle("small", "aaa")]},
+                               {"bundles": [manifest_bundle("big", "bbb", is_big=True)]})
+    fetcher = ModelFetcher(params)
+    assert [bundle.ref for bundle in fetcher.get_bundles_for_source("qcom")] == ["aaa"]
+    assert [bundle.ref for bundle in fetcher.get_bundles_for_source("usbgpu")] == ["bbb"]
+
+  def test_get_bundles_for_source_unknown(self):
+    assert ModelFetcher(mock.MagicMock()).get_bundles_for_source("bogus") == []
+
+  def test_get_cached_bundles_parses_source(self):
+    params = self._make_params({"bundles": [manifest_bundle("small", "aaa")]},
+                               {"bundles": [manifest_bundle("big", "bbb", is_big=True)]})
+    qcom_bundles = get_cached_bundles(params, "qcom")
+    usbgpu_bundles = get_cached_bundles(params, "usbgpu")
+    assert [b.ref for b in qcom_bundles] == ["aaa"]
+    assert [b.ref for b in usbgpu_bundles] == ["bbb"]
+    assert qcom_bundles[0].displayName == "SMALL"
+
+  def test_get_cached_bundles_empty_when_missing(self):
+    params = mock.MagicMock()
+    params.get.return_value = None
+    assert get_cached_bundles(params, "qcom") == []
+    assert get_cached_bundles(params, "usbgpu") == []
+
+  def test_get_cached_bundles_unknown_source(self):
+    assert get_cached_bundles(mock.MagicMock(), "bogus") == []
+
+  def test_active_json_has_both_urls(self):
+    params = mock.MagicMock()
+    ModelFetcher(params)
+    active_json_calls = [call for call in params.put.call_args_list if call.args[0] == "ModelManager_ActiveJson"]
+    assert active_json_calls, "expected ModelManager_ActiveJson to be written"
+    assert active_json_calls[-1].args[1] == {
+      "qcom": ModelFetcher.MODEL_URL,
+      "usbgpu": ModelFetcher.MODEL_URL_USBGPU,
+    }
+
+
+
+class TestSourceCacheIntegrity(OpenpilotTestCase):
+  """Each source's cached manifest must contain only that source's models; the
+  `is_big` flag in the JSON marks the big (usbgpu) models. A mismatched cache is
+  legacy data from before the per-source split (the active manifest was cached
+  under the unsuffixed key regardless of hardware) and is refetched. This
+  replaces the old one-time bundle migration."""
+
+  def _make_params(self, qcom_manifest, usbgpu_manifest):
+    params = mock.MagicMock()
+
+    def get(key):
+      if key == "ModelManager_ModelsCache":
+        return qcom_manifest
+      if key == "ModelManager_ModelsCache_USBGPU":
+        return usbgpu_manifest
+      if key in ("ModelManager_LastSyncTime", "ModelManager_LastSyncTime_USBGPU"):
+        return fresh_sync_time()
+      return None
+
+    params.get.side_effect = get
+    return params
+
+  def _fetched(self, *bundles):
+    return ModelFetcher(mock.MagicMock()).model_parser.parse_models({"bundles": list(bundles)})
+
+  def test_qcom_cache_with_big_models_is_refetched(self):
+    """Legacy: the unsuffixed cache holds the big manifest. is_big confirms it is
+    the wrong set for qcom, so a fresh fetch replaces it."""
+    params = self._make_params({"bundles": [manifest_bundle("big", "bbb", is_big=True)]},
+                               {"bundles": [manifest_bundle("big2", "ccc", is_big=True)]})
+    fetcher = ModelFetcher(params)
+    fetched = self._fetched(manifest_bundle("small", "aaa"))
+    with mock.patch.object(fetcher, "_fetch_and_cache_models", return_value=fetched):
+      bundles = fetcher.get_bundles_for_source("qcom")
+    assert [bundle.ref for bundle in bundles] == ["aaa"]
+
+  def test_usbgpu_cache_without_big_models_is_refetched(self):
+    params = self._make_params({"bundles": [manifest_bundle("small", "aaa")]},
+                               {"bundles": [manifest_bundle("big2", "ccc")]})
+    fetcher = ModelFetcher(params)
+    fetched = self._fetched(manifest_bundle("big", "bbb", is_big=True))
+    with mock.patch.object(fetcher, "_fetch_and_cache_models", return_value=fetched):
+      bundles = fetcher.get_bundles_for_source("usbgpu")
+    assert [bundle.ref for bundle in bundles] == ["bbb"]
+
+  def test_matching_caches_are_used_without_fetch(self):
+    params = self._make_params({"bundles": [manifest_bundle("small", "aaa")]},
+                               {"bundles": [manifest_bundle("big", "bbb", is_big=True)]})
+    fetcher = ModelFetcher(params)
+    with mock.patch.object(fetcher, "_fetch_and_cache_models", side_effect=AssertionError("cache should be used")):
+      assert [bundle.ref for bundle in fetcher.get_bundles_for_source("qcom")] == ["aaa"]
+      assert [bundle.ref for bundle in fetcher.get_bundles_for_source("usbgpu")] == ["bbb"]
+
+  def test_stale_version_cache_is_refetched(self):
+    """A source-matching cache whose bundles are all filtered by the selector version
+    check parses to zero valid bundles; it is stale (e.g. an old manifest) and must be
+    refetched instead of silently returning an empty list forever."""
+    stale = manifest_bundle("small", "aaa")
+    stale["minimum_selector_version"] = "16"
+    params = self._make_params({"bundles": [stale]},
+                               {"bundles": [manifest_bundle("big", "bbb", is_big=True)]})
+    fetcher = ModelFetcher(params)
+    fetched = self._fetched(manifest_bundle("small2", "ddd"))
+    with mock.patch.object(fetcher, "_fetch_and_cache_models", return_value=fetched) as fetch:
+      bundles = fetcher.get_bundles_for_source("qcom")
+    fetch.assert_called_once_with("qcom")
+    assert [bundle.ref for bundle in bundles] == ["ddd"]
+
+  def test_mismatched_refetch_happens_once(self):
+    """If the fresh manifest still fails the source check, the URL is authoritative:
+    trust it instead of refetching at 1 Hz forever."""
+    params = self._make_params({"bundles": [manifest_bundle("big", "bbb", is_big=True)]},
+                               {"bundles": [manifest_bundle("big2", "ccc", is_big=True)]})
+    fetcher = ModelFetcher(params)
+    fetched = self._fetched(manifest_bundle("big", "bbb", is_big=True))
+    with mock.patch.object(fetcher, "_fetch_and_cache_models", return_value=fetched) as fetch:
+      first = fetcher.get_bundles_for_source("qcom")
+      second = fetcher.get_bundles_for_source("qcom")
+    fetch.assert_called_once_with("qcom")
+    assert [bundle.ref for bundle in first] == ["bbb"]
+    assert [bundle.ref for bundle in second] == ["bbb"]
+
+  def test_corrupt_cache_is_refetched(self):
+    """A cache that fails to parse (e.g. truncated/foreign JSON) must trigger a
+    refetch instead of raising every loop and never recovering."""
+    corrupt = {"bundles": [{"short_name": "broken"}]}  # missing required fields
+    params = self._make_params(corrupt, {"bundles": [manifest_bundle("big", "bbb", is_big=True)]})
+    fetcher = ModelFetcher(params)
+    fetched = self._fetched(manifest_bundle("small", "aaa"))
+    with mock.patch.object(fetcher, "_fetch_and_cache_models", return_value=fetched) as fetch:
+      bundles = fetcher.get_bundles_for_source("qcom")
+    fetch.assert_called_once_with("qcom")
+    assert [bundle.ref for bundle in bundles] == ["aaa"]
+
+
+class TestActiveBundleValidation(OpenpilotTestCase):
+  """Validation is per-slot: a failed fetch (empty bundle list) must not reset a slot,
+  and resetting one slot must not stomp the runner cache derived from the other."""
+
+  def setUp(self):
+    super().setUp()
+    helpers._LAST_VALIDATED_RAW.clear()
+
+  @staticmethod
+  def _raw_bundle(ref: str, runner: int | None = None) -> dict:
+    bundle = custom.ModelManagerSP.ModelBundle.new_message()
+    bundle.ref = ref
+    bundle.minimumSelectorVersion = 18
+    if runner is not None:
+      bundle.runner = runner
+    return bundle.to_dict()
+
+  def _params(self, qcom=None, usbgpu=None):
+    params = mock.MagicMock()
+
+    def get(key, *args, **kwargs):
+      return {"ModelManager_ActiveBundle": qcom, "ModelManager_ActiveBundleUSBGPU": usbgpu}.get(key)
+
+    params.get.side_effect = get
+    return params
+
+  def test_empty_catalog_does_not_reset_slot(self):
+    params = self._params(qcom=self._raw_bundle("small"))
+    with mock.patch("openpilot.sunnypilot.models.helpers.usbgpu_present", return_value=False):
+      validate_active_bundles(params, {"qcom": [], "usbgpu": []})
+    params.remove.assert_not_called()
+
+  def test_reset_recomputes_runner_from_surviving_slot(self):
+    tinygrad = int(custom.ModelManagerSP.Runner.tinygrad)
+    big_raw = self._raw_bundle("big", runner=tinygrad)
+    params = self._params(qcom=self._raw_bundle("gone"), usbgpu=big_raw)
+    catalog = {"qcom": [custom.ModelManagerSP.ModelBundle(**self._raw_bundle("other"))],
+               "usbgpu": [custom.ModelManagerSP.ModelBundle(**big_raw)]}
+    with mock.patch("openpilot.sunnypilot.models.helpers.usbgpu_present", return_value=True):
+      validate_active_bundles(params, catalog)
+    params.remove.assert_called_once_with("ModelManager_ActiveBundle")
+    runner_puts = [call for call in params.put.call_args_list if call.args[0] == "ModelRunnerTypeCache"]
+    assert [call.args[1] for call in runner_puts] == [tinygrad]
+
+
+class TestActiveBundleSelection(OpenpilotTestCase):
+  """The effective active bundle is the active source's slot: usbgpu when a GPU is
+  present, qcom otherwise. An empty active slot means the hardware default (stock
+  runner), never the other slot's pick - modeld_v2 requires a real bundle."""
+
+  @staticmethod
+  def _raw_bundle(ref: str) -> dict:
+    bundle = custom.ModelManagerSP.ModelBundle.new_message()
+    bundle.ref = ref
+    bundle.minimumSelectorVersion = 18
+    return bundle.to_dict()
+
+  def _params(self, qcom=None, usbgpu=None):
+    params = mock.MagicMock()
+
+    def get(key, *args, **kwargs):
+      if key == "ModelManager_ActiveBundle":
+        return qcom
+      if key == "ModelManager_ActiveBundleUSBGPU":
+        return usbgpu
+      return None
+
+    params.get.side_effect = get
+    return params
+
+  def test_selected_bundle_is_per_slot(self):
+    params = self._params(qcom=self._raw_bundle("small"), usbgpu=self._raw_bundle("big"))
+    assert get_selected_bundle(params, "qcom").ref == "small"
+    assert get_selected_bundle(params, "usbgpu").ref == "big"
+
+  def test_no_gpu_uses_qcom_slot(self):
+    params = self._params(qcom=self._raw_bundle("small"), usbgpu=self._raw_bundle("big"))
+    with mock.patch("openpilot.sunnypilot.models.helpers.usbgpu_present", return_value=False):
+      assert get_active_bundle(params).ref == "small"
+
+  def test_gpu_uses_usbgpu_slot(self):
+    params = self._params(qcom=self._raw_bundle("small"), usbgpu=self._raw_bundle("big"))
+    with mock.patch("openpilot.sunnypilot.models.helpers.usbgpu_present", return_value=True):
+      assert get_active_bundle(params).ref == "big"
+
+  def test_gpu_without_big_selection_is_hardware_default(self):
+    params = self._params(qcom=self._raw_bundle("small"), usbgpu=None)
+    with mock.patch("openpilot.sunnypilot.models.helpers.usbgpu_present", return_value=True):
+      assert get_active_bundle(params) is None
+
+
+class TestEffectiveSource(OpenpilotTestCase):
+  """One gate decides the active source. With no flags it is runtime truth (GPU
+  attached); display callers (mici) pass the ui_state flags, which additionally
+  require the big model to be loading, active, or the device offroad. The active
+  bundle is simply the selected bundle of that source."""
+
+  @staticmethod
+  def _raw_bundle(ref: str) -> dict:
+    bundle = custom.ModelManagerSP.ModelBundle.new_message()
+    bundle.ref = ref
+    bundle.minimumSelectorVersion = 18
+    return bundle.to_dict()
+
+  def test_runtime_no_gpu(self):
+    with mock.patch("openpilot.sunnypilot.models.helpers.usbgpu_present", return_value=False):
+      assert get_active_source() == "qcom"
+
+  def test_runtime_gpu_present(self):
+    with mock.patch("openpilot.sunnypilot.models.helpers.usbgpu_present", return_value=True):
+      assert get_active_source() == "usbgpu"
+
+  def test_display_offroad_gpu_present_shows_big(self):
+    assert get_active_source(usbgpu=True, usbgpu_active=False, usbgpu_loading=False, offroad=True) == "usbgpu"
+
+  def test_display_onroad_gpu_loading_shows_big(self):
+    assert get_active_source(usbgpu=True, usbgpu_active=False, usbgpu_loading=True, offroad=False) == "usbgpu"
+
+  def test_display_onroad_gpu_active_shows_big(self):
+    assert get_active_source(usbgpu=True, usbgpu_active=True, usbgpu_loading=False, offroad=False) == "usbgpu"
+
+  def test_display_onroad_gpu_idle_shows_small(self):
+    assert get_active_source(usbgpu=True, usbgpu_active=False, usbgpu_loading=False, offroad=False) == "qcom"
+
+  def test_display_active_none_is_idle(self):
+    assert get_active_source(usbgpu=True, usbgpu_active=None, usbgpu_loading=False, offroad=False) == "qcom"
+
+  def test_active_bundle_follows_source(self):
+    params = mock.MagicMock()
+    params.get.side_effect = lambda key: {"ModelManager_ActiveBundle": self._raw_bundle("small"),
+                                          "ModelManager_ActiveBundleUSBGPU": self._raw_bundle("big")}.get(key)
+    with mock.patch("openpilot.sunnypilot.models.helpers.usbgpu_present", return_value=False):
+      assert get_active_bundle(params).ref == "small"
+    assert get_selected_bundle(params, get_active_source(usbgpu=True, usbgpu_active=False,
+                                                         usbgpu_loading=False, offroad=True)).ref == "big"
+
+
@unittest.skipUnless(os.environ.get('RUN_INTEGRATION_TESTS'), 'requires external network')
 class TestLiveModelManifest(OpenpilotTestCase):
  """Every artifact and chunk URL in the published manifest must resolve."""
@@ -4,7 +4,6 @@ from openpilot.sunnypilot.models.tinygrad_ref import get_tinygrad_ref
 from openpilot.sunnypilot.models.fetcher import ModelFetcher
 from openpilot.common.test import OpenpilotTestCase

-
 def fetch_tinygrad_ref():
  response = requests.get(ModelFetcher.MODEL_URL, timeout=10)
  response.raise_for_status()
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:447099e93e303b29e7b3eac237bb0f27f8c5e12786991139aee2432532a75f58
+size 12310
@@ -83,9 +83,14 @@ class TestLocationdProc(OpenpilotTestCase):
      self.pm.send(msg.which(), msg)
      if msg.which() == "cameraOdometry":
        self.pm.wait_for_readers_to_update(msg.which(), timeout=1, dt=0.005)
-    time.sleep(1)  # wait for async params write
+    for _ in range(50):
+      val = self.params.get('LastGPSPositionLLK')
+      if val is not None:
+        break
+      time.sleep(0.1)

-    lastGPS = json.loads(self.params.get('LastGPSPositionLLK'))
+    self.assertIsNotNone(val, "LastGPSPositionLLK not written within 5s")
+    lastGPS = json.loads(val)
    self.assertAlmostEqual(lastGPS['latitude'], self.lat, delta=0.001)
    self.assertAlmostEqual(lastGPS['longitude'], self.lon, delta=0.001)
    self.assertAlmostEqual(lastGPS['altitude'], self.alt, delta=0.001)
@@ -252,4 +252,12 @@ EVENTS_SP: dict[int, dict[str, Alert | AlertCallbackType]] = {
      AlertStatus.userPrompt, AlertSize.small,
      Priority.LOW, VisualAlert.none, AudibleAlert.prompt, 0.1),
  },
+
+  EventNameSP.bigModelReady: {
+    ET.PERMANENT: Alert(
+      "Big Model Ready",
+      "",
+      AlertStatus.normal, AlertSize.small,
+      Priority.LOW, VisualAlert.none, AudibleAlert.prompt, 2.),
+  },
 }
@@ -28,7 +28,7 @@ from websocket import (ABNF, WebSocket, WebSocketException, WebSocketTimeoutExce
                       create_connection, WebSocketConnectionClosedException)

 import openpilot.cereal.messaging as messaging
-from openpilot.sunnypilot.models.default_model import DEFAULT_MODEL
+from openpilot.sunnypilot.models.model_name import DEFAULT_MODEL, DEFAULT_BIG_MODEL
 from openpilot.sunnypilot.selfdrive.car.sync_sunnylink_params import update_car_list_param
 from openpilot.sunnypilot.sunnylink.api import SunnylinkApi
 from openpilot.sunnypilot.sunnylink.utils import sunnylink_need_register, sunnylink_ready, get_param_as_byte, save_param_from_base64_encoded_string
@@ -182,6 +182,8 @@ def getParamsMetadata() -> str:
    schema["capabilities"] = generate_capabilities()
    schema["capability_labels"] = CAPABILITY_LABELS
    schema["default_model"] = DEFAULT_MODEL
+    schema["default_big_model"] = DEFAULT_BIG_MODEL
+    schema["usbgpu_active"] = params.get_bool("UsbGpuActive")
    raw = json.dumps(schema, separators=(",", ":")).encode("utf-8")
    return base64.b64encode(gzip.compress(raw)).decode("utf-8")
  except Exception:
@@ -2172,26 +2172,6 @@
      "title": "Hyundai / Kia / Genesis Settings",
      "description": "",
      "items": [
-        {
-          "key": "CustomButtonAction",
-          "widget": "multiple_button",
-          "title": "Steering Custom Button",
-          "description": "Choose the openpilot action for the steering wheel custom/star button. OEM functionality is unchanged.",
-          "options": [
-            {
-              "value": 0,
-              "label": "None"
-            },
-            {
-              "value": 1,
-              "label": "Bookmark"
-            },
-            {
-              "value": 3,
-              "label": "Cycle UI"
-            }
-          ]
-        },
        {
          "key": "HyundaiLongitudinalTuning",
          "widget": "multiple_button",
@@ -10,17 +10,6 @@ sections:
  title: Hyundai / Kia / Genesis Settings
  description: ''
  items:
-  - key: CustomButtonAction
-    widget: multiple_button
-    title: Steering Custom Button
-    description: Choose the openpilot action for the steering wheel custom/star button. OEM functionality is unchanged.
-    options:
-    - value: 0
-      label: None
-    - value: 1
-      label: Bookmark
-    - value: 3
-      label: Cycle UI
  - key: HyundaiLongitudinalTuning
    widget: multiple_button
    title: Custom Longitudinal Tuning
@@ -65,6 +65,7 @@ def sp_stats(end_event):
    'MadsSteeringMode',
    'MadsUnifiedEngagementMode',
    'ModelManager_ActiveBundle',
+    'ModelManager_ActiveBundleUSBGPU',
    'ModelManager_Favs',
    'EnableSunnylinkUploader',
    'SunnylinkEnabled',
@@ -84,6 +84,21 @@ def _migrate_tesla_mads_screen_button(_params):
    cloudlog.exception(f"Error migrating TeslaMadsScreenButton: {e}")


+def _migrate_model_bundle_slots(_params):
+  # Pre-split, a chestnut user's big-model selection lived in the single
+  # ActiveBundle. Seed both slots; validation drops whichever does not match
+  # its own manifest.
+  try:
+    if _params.get("ModelManager_ActiveBundleUSBGPU") is not None:
+      return
+    if (bundle := _params.get("ModelManager_ActiveBundle")) is None:
+      return
+    _params.put("ModelManager_ActiveBundleUSBGPU", bundle, block=True)
+    cloudlog.info("params_migration: seeded ModelManager_ActiveBundleUSBGPU from ModelManager_ActiveBundle")
+  except Exception as e:
+    cloudlog.exception(f"Error migrating model bundle slots: {e}")
+
+
 def run_migration(_params):
  # migrate OnroadScreenOffBrightness
  if _params.get("OnroadScreenOffBrightnessMigrated") != ONROAD_BRIGHTNESS_MIGRATION_VERSION:
@@ -120,3 +135,6 @@ def run_migration(_params):

  # seed TeslaMadsScreenButton for existing Tesla installs
  _migrate_tesla_mads_screen_button(_params)
+
+  # seed the usbgpu model slot from the pre-split single slot
+  _migrate_model_bundle_slots(_params)
@@ -0,0 +1,36 @@
+"""
+Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
+
+This file is part of sunnypilot and is licensed under the MIT License.
+See the LICENSE.md file in the root directory for more details.
+"""
+
+from openpilot.common.params import Params
+from openpilot.common.test import OpenpilotTestCase
+from openpilot.sunnypilot.system.params_migration import _migrate_model_bundle_slots
+
+
+class TestModelBundleSlotMigration(OpenpilotTestCase):
+  """Pre-split, a chestnut user's big-model selection lived in the single ActiveBundle.
+  The migration seeds both slots; per-source validation later drops whichever does not
+  match its own manifest."""
+
+  def test_seeds_usbgpu_slot_from_active_bundle(self):
+    params = Params()
+    bundle = {"ref": "big", "minimumSelectorVersion": 18}
+    params.put("ModelManager_ActiveBundle", bundle, block=True)
+    _migrate_model_bundle_slots(params)
+    assert params.get("ModelManager_ActiveBundleUSBGPU") == bundle
+    assert params.get("ModelManager_ActiveBundle") == bundle
+
+  def test_noop_when_usbgpu_slot_already_set(self):
+    params = Params()
+    params.put("ModelManager_ActiveBundle", {"ref": "small"}, block=True)
+    params.put("ModelManager_ActiveBundleUSBGPU", {"ref": "big"}, block=True)
+    _migrate_model_bundle_slots(params)
+    assert params.get("ModelManager_ActiveBundleUSBGPU") == {"ref": "big"}
+
+  def test_noop_when_no_selection(self):
+    params = Params()
+    _migrate_model_bundle_slots(params)
+    assert params.get("ModelManager_ActiveBundleUSBGPU") is None
@@ -828,20 +828,22 @@ def startStream(sdp: str, enabled: bool) -> dict:
  bridge_services_in = []

  # stale car params case taken care of by webrtcd being shut off on ignition
-  cp_bytes = Params().get("CarParamsPersistent")
+  cp_bytes = params.get("CarParamsPersistent")
  if cp_bytes is not None:
    with car.CarParams.from_bytes(cp_bytes) as CP:
      if CP.notCar:
        bridge_services_in.append("testJoystick")
-  else:
-    raise Exception("failed to get CarParamsPersistent")

  if params.get_bool("IsOffroad"):
    # manager owns camerad/stream_encoderd/webrtcd; flip the param and let it bring them up.
    # webrtcd clears IsLiveStreaming when the session ends
    params.put_bool("IsLiveStreaming", True)
    # wait for webrtcd end points to wake up
-    wait_for_webrtcd()
+    try:
+      wait_for_webrtcd()
+    except TimeoutError:
+      cloudlog.event("athena.startStream.webrtcd_offroad_start_timeout", error=True)
+      raise

  return post_stream_request(StreamRequestBody(sdp, ["wideRoad"], enabled, bridge_services_in, ["carState", "deviceState"]))

@@ -33,6 +33,7 @@ USBDEVFS_SETCONFIGURATION = 0x80045505
 USBDEVFS_CLAIMINTERFACE = 0x8004550F
 USBDEVFS_RESET = 0x5514
 USBDEVFS_CLEAR_HALT = 0x80045515
+MAX_REGISTER_READ_SIZE = 255

 _deadline = float("inf")

@@ -146,6 +147,7 @@ def claim_interface(path, setup=False):
 class Flash:
  def __init__(self):
    self.fd = -1
+    self.max_register_read_size = MAX_REGISTER_READ_SIZE

  def close(self):
    if self.fd >= 0:
@@ -160,6 +162,9 @@ class Flash:
      if in_rom_bootloader(vid_pid, product):
        raise RomFallback("chestnut fell back to the ROM bootloader")
      if path is not None:
+        speed = int(open(path + "/speed").read())
+        # USB2 firmware truncates larger reads to one full packet without a terminating ZLP.
+        self.max_register_read_size = 64 if speed < 5000 else MAX_REGISTER_READ_SIZE
        self.fd = claim_interface(path)
        return
      time.sleep(0.1)
@@ -231,8 +236,8 @@ class Flash:
    while len(out) < length:
      n = min(4096, length - len(out))
      self.transaction(0x03, addr + len(out), max(4096, n))
-      for off in range(0, n, 255):
-        out += self.reg_read(0x7000 + off, min(255, n - off))
+      for off in range(0, n, self.max_register_read_size):
+        out += self.reg_read(0x7000 + off, min(self.max_register_read_size, n - off))
    return bytes(out)

  def erase_sector(self, addr):
@@ -16,6 +16,7 @@ from openpilot.common.utils import strip_deprecated_keys
 from openpilot.common.filter_simple import FirstOrderFilter
 from openpilot.common.params import Params
 from openpilot.common.realtime import DT_HW
+from openpilot.selfdrive.modeld.helpers import MODELS_DIR, usbgpu_compiled
 from openpilot.selfdrive.selfdrived.alertmanager import set_offroad_alert
 from openpilot.common.hardware import HARDWARE, COMMA_HARDWARE
 from openpilot.common.basedir import BASEDIR
@@ -26,7 +27,7 @@ from openpilot.common.swaglog import cloudlog
 from openpilot.sunnypilot.system.statsd import statlog
 from openpilot.system.hardware.power_monitoring import PowerMonitoring
 from openpilot.system.hardware.fan_controller import FanController
-from openpilot.common.version import terms_version, training_version, get_build_metadata, terms_version_sp
+from openpilot.common.version import terms_version, training_version, get_build_metadata, terms_version_sp, CHESTNUT_BRANCHES


 ThermalStatus = log.DeviceState.ThermalStatus
@@ -238,6 +239,7 @@ def hardware_thread(end_event, hw_queue) -> None:

  fan_controller = FanController(int(1./DT_HW))
  chestnut = Chestnut()
+  big_model_available = (MODELS_DIR / 'big_driving_supercombo.onnx').is_file() or usbgpu_compiled()

  while not end_event.is_set():
    sm.update(PANDA_STATES_TIMEOUT)
@@ -299,6 +301,11 @@ def hardware_thread(end_event, hw_queue) -> None:

    set_usb_state(msg.deviceState, last_hw_state.usb_state)
    chestnut.update(started_ts is None, last_hw_state.usb_state)
+    current_channel = get_build_metadata().channel
+    chestnut_target = CHESTNUT_BRANCHES.get(current_channel)
+    chestnut_needs_switch = msg.deviceState.chestnutPresent and not big_model_available and chestnut_target is not None
+    set_offroad_alert_if_changed("Offroad_ChestnutBranch", chestnut_needs_switch,
+                                 extra_text=chestnut_target if chestnut_needs_switch else None)

    # this subset is only used for offroad
    temp_sources = [
@@ -14,7 +14,7 @@
 #include "sunnypilot/common/version.h"

 // ***** log metadata *****
-kj::Array<capnp::word> logger_build_init_data() {
+kj::Array<capnp::word> logger_build_init_data(bool route_log) {
  uint64_t wall_time = nanos_since_epoch();

  MessageBuilder msg;
@@ -72,7 +72,7 @@ kj::Array<capnp::word> logger_build_init_data() {
    "df -h",  // usage for all filesystems
  };

-  auto hw_logs = Hardware::get_init_logs();
+  auto hw_logs = Hardware::get_init_logs(route_log);

  auto commands = init.initCommands().initEntries(log_commands.size() + hw_logs.size());
  for (int i = 0; i < log_commands.size(); i++) {
@@ -166,7 +166,7 @@ static void log_sentinel(LoggerState *log, SentinelType type, int exit_signal =
 LoggerState::LoggerState(const std::string &log_root) {
  route_name = logger_get_identifier("RouteCount");
  route_path = log_root + "/" + route_name;
-  init_data = logger_build_init_data();
+  init_data = logger_build_init_data(true);
 }

 LoggerState::~LoggerState() {
@@ -32,6 +32,6 @@ protected:
  std::unique_ptr<ZstdFileWriter> rlog, qlog;
 };

-kj::Array<capnp::word> logger_build_init_data();
+kj::Array<capnp::word> logger_build_init_data(bool route_log = false);
 std::string logger_get_identifier(std::string key);
 std::string zstd_decompress(const std::string &in);
@@ -1,40 +0,0 @@
-#!/usr/bin/env bash
-
-# Define the service name
-SERVICE_NAME="actions.runner.sunnypilot.$(uname -n)"
-
-# Function to control the service
-control_service() {
-    local action=$1  # Store the function argument in a local variable
-    sudo systemctl $action ${SERVICE_NAME}
-}
-
-service_exists_and_is_loaded() {
-    sudo systemctl status ${SERVICE_NAME} &>/dev/null
-    if [[ $? -ne 4 ]]; then
-        return 0  # Service is known to systemd (i.e., loaded)
-    else
-        return 1  # Service is unknown to systemd (i.e., not loaded)
-    fi
-}
-
-# Check for required argument
-if [[ -z $1 ]] || { [[ $1 != "start" ]] && [[ $1 != "stop" ]]; }; then
-    echo "Usage: $0 {start|stop}"
-    exit 1
-fi
-
-# Store the script argument in a descriptive variable
-ACTION=$1
-
-# Trap EXIT signal (Ctrl+C) and stop the service
-trap 'control_service stop ; exit' SIGINT SIGKILL EXIT
-
-# Enter the main loop
-while true; do
-    # Check if the service is actually present on the system
-    if service_exists_and_is_loaded; then
-        control_service $ACTION  # Call the function with the specified action
-    fi
-    sleep 1  # Pause before the next iteration
-done
@@ -68,10 +68,6 @@ def only_offroad(started: bool, params: Params, CP: car.CarParams) -> bool:
 def livestream(started: bool, params: Params, CP: car.CarParams) -> bool:
  return params.get_bool("IsLiveStreaming")

-def use_github_runner(started, params, CP: car.CarParams) -> bool:
-  return not PC and params.get_bool("EnableGithubRunner") and (
-    not params.get_bool("NetworkMetered") and not params.get_bool("GithubRunnerSufficientVoltage"))
-
 def use_copyparty(started, params, CP: car.CarParams) -> bool:
  return bool(params.get_bool("EnableCopyparty"))

@@ -110,15 +106,12 @@ def or_(*fns):
 def and_(*fns):
  return lambda *args: operator.and_(*(fn(*args) for fn in fns))

-def not_(*fns):
-  return lambda *args: operator.not_(*(fn(*args) for fn in fns))
-
 procs = [
  DaemonProcess("manage_athenad", "openpilot.system.athena.manage_athenad", "AthenadPid"),

  NativeProcess("loggerd", "openpilot/system/loggerd", ["./loggerd"], logging),
  NativeProcess("encoderd", "openpilot/system/loggerd", ["./encoderd"], only_onroad),
-  NativeProcess("stream_encoderd", "openpilot/system/loggerd", ["./encoderd", "--stream"], or_(and_(livestream, not_(iscar)), notcar)),
+  NativeProcess("stream_encoderd", "openpilot/system/loggerd", ["./encoderd", "--stream"], or_(livestream, notcar)),
  PythonProcess("logmessaged", "openpilot.system.logmessaged", always_run),

  NativeProcess("camerad", "openpilot/system/camerad", ["./camerad"], or_(driverview, livestream), enabled=not WEBCAM),
@@ -163,7 +156,7 @@ procs = [

  # debug procs
  NativeProcess("bridge", "openpilot/cereal/messaging", ["./bridge"], notcar),
-  PythonProcess("webrtcd", "openpilot.system.webrtc.webrtcd", or_(and_(livestream, not_(iscar)), notcar)),
+  PythonProcess("webrtcd", "openpilot.system.webrtc.webrtcd", or_(livestream, notcar)),
  PythonProcess("joystick", "openpilot.tools.joystick.joystick_control", and_(joystick, iscar)),

  # sunnylink <3
@@ -189,10 +182,6 @@ procs += [
  NativeProcess("locationd_llk", "openpilot/sunnypilot/selfdrive/locationd", ["./locationd"], only_onroad),
 ]

-if os.path.exists("./github_runner.sh"):
-  procs += [NativeProcess("github_runner_start", "openpilot/system/manager",
-                          ["./github_runner.sh", "start"], and_(only_offroad, use_github_runner), sigkill=False)]
-
 if os.path.exists("../../sunnypilot/sunnylink/uploader.py"):
  procs += [PythonProcess("sunnylink_uploader", "openpilot.sunnypilot.sunnylink.uploader", use_sunnylink_uploader_shim)]

@@ -3,11 +3,12 @@ import sys
 import time
 import signal
 import struct
+import threading
 import requests
 import urllib.parse
 from datetime import datetime, UTC

-from openpilot.cereal import messaging
+from openpilot.cereal import log, messaging
 from openpilot.common.api import Api
 from openpilot.common.time_helpers import system_time_valid
 from openpilot.common.params import Params
@@ -46,7 +47,6 @@ def get_assistnow_messages() -> list[bytes]:
  params = Params()
  if token := params.get('AssistNowToken'):
    cloudlog.warning("Downloading AssistNow data directly from u-blox")
-    # TODO: implement adding the last known location
    r = requests.get("https://online-live2.services.u-blox.com/GetOnlineData.ashx", params=urllib.parse.urlencode({
      'token': token,
      'gnss': 'gps,glo',
@@ -240,14 +240,6 @@ def init_pigeon(pigeon: TTYPigeon) -> bool:
        ))
        pigeon.send_with_ack(msg, ack=UBLOX_ASSIST_ACK)

-      # A configured u-blox token takes precedence over comma's AGPS proxy.
-      try:
-        for msg in get_assistnow_messages():
-          pigeon.send_with_ack(msg, ack=UBLOX_ASSIST_ACK)
-        cloudlog.warning("AssistNow messages sent")
-      except Exception:
-        cloudlog.warning("failed to get AssistNow messages")
-
      cloudlog.warning("Pigeon GPS on!")
      break
    except TimeoutError:
@@ -287,12 +279,38 @@ def run_receiving(duration: int = 0):

  start_time = time.monotonic()
  last_almanac_save = time.monotonic()
+  assist_attempted = False
+  assist_messages = None
+
+  def download_assistnow() -> None:
+    nonlocal assist_messages
+    sm = messaging.SubMaster(['deviceState'])
+    while assist_messages is None:
+      sm.update(1000)
+      if system_time_valid() and sm['deviceState'].networkType != log.DeviceState.NetworkType.none:
+        try:
+          assist_messages = get_assistnow_messages()
+        except Exception:
+          cloudlog.warning("failed to get AssistNow messages")
+      time.sleep(10.)
+  threading.Thread(target=download_assistnow, daemon=True).start()
+
  while (duration == 0) or (time.monotonic() - start_time < duration):
+    if assist_messages is not None and not assist_attempted:
+      assist_attempted = True
+      try:
+        for msg in assist_messages:
+          pigeon.send_with_ack(msg, ack=UBLOX_ASSIST_ACK)
+        cloudlog.warning("AssistNow messages sent")
+      except Exception:
+        cloudlog.warning("failed to send AssistNow messages")
+
    dat = pigeon.receive()
    if len(dat) > 0:
      if dat[0] == 0x00:
        cloudlog.warning("received invalid data from ublox, re-initing!")
        init(pigeon)
+        assist_attempted = False
        continue

      # send out to socket
@@ -4,7 +4,29 @@ Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
 This file is part of sunnypilot and is licensed under the MIT License.
 See the LICENSE.md file in the root directory for more details.
 """
+from collections.abc import Callable
+
+import pyray as rl
+
+from openpilot.system.ui.lib.application import gui_app, FontWeight
+from openpilot.system.ui.sunnypilot.lib.styles import style
 from openpilot.system.ui.sunnypilot.widgets.list_view import ButtonActionSP
+from openpilot.system.ui.widgets.label import ScrollState, UnifiedLabel
+from openpilot.system.ui.widgets.list_view import BUTTON_WIDTH, BUTTON_HEIGHT, TEXT_PADDING, _resolve_value
+
+SCROLL_SPEED = 1.2  # stock is 0.8, boosted 50% to compensate for larger font (50 vs 32)
+SCROLL_REFERENCE_FPS = 60.
+
+
+class UnifiedLabelSP(UnifiedLabel):
+  # stock scroll formula (0.8 / 60 * fps) is inverted — pre-correct so speed is constant px/sec
+  def _render(self, _):
+    if self._needs_scroll and self._scroll_state == ScrollState.SCROLLING:
+      fps = gui_app.target_fps
+      wrong_step = 0.8 / SCROLL_REFERENCE_FPS * fps
+      correct_step = SCROLL_SPEED * SCROLL_REFERENCE_FPS / fps
+      self._scroll_offset -= (correct_step - wrong_step)
+    super()._render(_)


 class NoElideButtonAction(ButtonActionSP):
@@ -12,6 +34,36 @@ class NoElideButtonAction(ButtonActionSP):
    return super().get_width_hint() + 1


+class ScrollingButtonAction(ButtonActionSP):
+  def __init__(self, text: str | Callable[[], str], width: int = style.BUTTON_ACTION_WIDTH,
+               enabled: bool | Callable[[], bool] = True):
+    super().__init__(text=text, width=width, enabled=enabled)
+    self._value_label = UnifiedLabelSP("", font_size=style.ITEM_TEXT_FONT_SIZE, font_weight=FontWeight.NORMAL,
+                                       text_color=self._value_color, scroll=True,
+                                       alignment_vertical=rl.GuiTextAlignmentVertical.TEXT_ALIGN_MIDDLE)
+
+  def set_value(self, value: str | Callable[[], str], color: rl.Color = style.ITEM_TEXT_VALUE_COLOR):
+    if self.value != _resolve_value(value, ""):
+      self._value_label.reset_scroll()
+    super().set_value(value, color)
+    self._value_label.set_text(value)
+    self._value_label.set_text_color(color)
+
+  def _render(self, rect: rl.Rectangle) -> bool:
+    """Duplicate of ButtonActionSP._render, with the value drawn by a scrolling label"""
+    self._button.set_text(self.text)
+    self._button.set_enabled(_resolve_value(self.enabled))
+    button_rect = rl.Rectangle(rect.x + rect.width - BUTTON_WIDTH, rect.y + (rect.height - BUTTON_HEIGHT) / 2, BUTTON_WIDTH, BUTTON_HEIGHT)
+    self._button.render(button_rect)
+
+    if self.value:
+      self._value_label.render(rl.Rectangle(rect.x, rect.y, rect.width - BUTTON_WIDTH - TEXT_PADDING, rect.height))
+
+    pressed = self._pressed
+    self._pressed = False
+    return pressed
+
+
 class AlertFadeAnimator:
  def __init__(self, target_fps: int, duration_on: float = 0.75, rc: float = 0.05):
    from openpilot.common.filter_simple import FirstOrderFilter
@@ -0,0 +1,211 @@
+"""
+Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
+
+This file is part of sunnypilot and is licensed under the MIT License.
+See the LICENSE.md file in the root directory for more details.
+"""
+import math
+
+import numpy as np
+import pyray as rl
+
+from openpilot.common.filter_simple import FirstOrderFilter
+from openpilot.system.ui.lib.application import gui_app, FontWeight
+from openpilot.system.ui.lib.shader_polygon import draw_polygon, Gradient
+from openpilot.system.ui.lib.text_measure import measure_text_cached
+from openpilot.system.ui.sunnypilot.lib.styles import style
+from openpilot.system.ui.sunnypilot.widgets.list_view import ListItemSP
+from openpilot.system.ui.widgets.label import UnifiedLabel
+from openpilot.system.ui.sunnypilot.lib.utils import UnifiedLabelSP
+from openpilot.system.ui.widgets.list_view import ItemAction
+
+FONT_SIZE = style.ITEM_TEXT_FONT_SIZE
+ICON_SIZE = 56
+ICON_PADDING = 12
+
+BAR_WIDTH = 1100
+BAR_HEIGHT = 20
+SEGMENT_GAP = 24
+SEGMENT_NAME_MAX_WIDTH = 380
+BAR_GAP = 16
+BAR_RADIUS = BAR_HEIGHT / 2
+CAPSULE_POINTS = 24
+
+RAIL_COLOR = rl.Color(60, 60, 60, 255)
+FILL_COLOR = rl.Color(30, 121, 232, 255)
+# rl.WHITE is a tuple; the shimmer path reads .a off the color
+TEXT_COLOR = rl.Color(255, 255, 255, 255)
+
+SWEEP_SPEED = 550.0  # px/s
+SWEEP_BAND = 240.0   # highlight half-width, px
+SWEEP_DIM = 0.65
+
+
+class DownloadStatusAction(ItemAction):
+  """Model download row: a name + percent over a progress rail while downloading, a name + icon otherwise."""
+
+  def __init__(self):
+    super().__init__(width=BAR_WIDTH)
+    self.name = ""
+    self.status_text = ""
+    self.segments: list[tuple[str, rl.Color, str | None, rl.Color | None]] | None = None
+    self._segment_labels: list[UnifiedLabelSP] = []
+    self.downloading = False
+    self.text_color = rl.GRAY
+    self.icon: str | None = None
+    self.icon_color: rl.Color | None = None
+    self._font = gui_app.font(FontWeight.NORMAL)
+    # raw progress arrives in steps, one per 128KB chunk the manager publishes
+    self._progress = FirstOrderFilter(0.0, 0.5, 1 / gui_app.target_fps)
+    # integrated per frame; (t * speed) % span jumps whenever the fill width changes
+    self._sweep = 0.0
+
+    self._name_label = UnifiedLabel("", font_size=FONT_SIZE, font_weight=FontWeight.NORMAL, text_color=TEXT_COLOR,
+                                    alignment=rl.GuiTextAlignment.TEXT_ALIGN_LEFT,
+                                    alignment_vertical=rl.GuiTextAlignmentVertical.TEXT_ALIGN_MIDDLE)
+    self._percent_label = UnifiedLabel("", font_size=FONT_SIZE, font_weight=FontWeight.NORMAL, text_color=TEXT_COLOR,
+                                       alignment=rl.GuiTextAlignment.TEXT_ALIGN_RIGHT,
+                                       alignment_vertical=rl.GuiTextAlignmentVertical.TEXT_ALIGN_MIDDLE)
+
+  def update(self, name, downloading=False, progress=0.0, status_text="", text_color=rl.GRAY, icon=None, icon_color=None, segments=None):
+    self.segments = segments
+    if downloading and not self.downloading:
+      self._name_label.reset_shimmer()
+      self._progress.x = progress
+      self._sweep = 0.0
+    self.name = name
+    self.downloading = downloading
+    self.status_text = status_text
+    self.text_color = text_color
+    self.icon = icon
+    self.icon_color = icon_color
+    self._name_label._shimmer = downloading
+    if downloading:
+      self._progress.update(progress)
+      self._sweep += SWEEP_SPEED / gui_app.target_fps
+
+  @property
+  def _idle_text(self) -> str:
+    return f"{self.name} - {self.status_text}" if self.status_text else self.name
+
+  def get_width_hint(self) -> float:
+    if self.downloading:
+      return BAR_WIDTH
+    if self.segments:
+      return sum(total for _, _, total in self._measured_segments())
+    width = measure_text_cached(self._font, self._idle_text, FONT_SIZE).x
+    if self.icon:
+      width += ICON_SIZE + ICON_PADDING
+    return width
+
+  def _measured_segments(self):
+    """[(segment, text width, total width incl. icon and gap)]"""
+    out = []
+    for i, seg in enumerate(self.segments or []):
+      text_width = min(measure_text_cached(self._font, seg[0], FONT_SIZE).x, SEGMENT_NAME_MAX_WIDTH)
+      total = text_width + (ICON_PADDING + ICON_SIZE if seg[2] else 0) + (SEGMENT_GAP if i else 0)
+      out.append((seg, text_width, total))
+    return out
+
+  def _render(self, rect: rl.Rectangle):
+    if self.downloading:
+      self._render_downloading(rect)
+    else:
+      self._render_idle(rect)
+
+  def _sweep_gradient(self, width: float) -> Gradient:
+    # clearance at both ends keeps the wrap offscreen
+    center = (self._sweep % (width + 2 * SWEEP_BAND)) - SWEEP_BAND
+
+    def band(x: float) -> float:
+      return max(0.0, 1.0 - abs(x - center) / SWEEP_BAND)
+
+    # sampling the corners is exact for a piecewise linear band
+    xs = sorted({0.0, width} | {min(max(center + o, 0.0), width) for o in (-SWEEP_BAND, 0.0, SWEEP_BAND)}, reverse=True)
+    # the gradient axis runs right-to-left in screen space
+    stops = [1.0 - x / width for x in xs]
+    # alpha here is the lift over the SWEEP_DIM base, not the final opacity
+    colors = [rl.Color(FILL_COLOR.r, FILL_COLOR.g, FILL_COLOR.b, int(255 * band(x))) for x in xs]
+    return Gradient(start=(0.0, 0.0), end=(1.0, 0.0), colors=colors, stops=stops)
+
+  @staticmethod
+  def _capsule(rect: rl.Rectangle) -> np.ndarray:
+    """Rounded-end ribbon so the gradient covers the caps."""
+    r = rect.height / 2
+    cy = rect.y + r
+    top, bottom = [], []
+    for i in range(CAPSULE_POINTS):
+      x = rect.x + rect.width * i / (CAPSULE_POINTS - 1)
+      d = min(x - rect.x, rect.x + rect.width - x, r)
+      h = math.sqrt(max(r * r - (r - d) ** 2, 0.0))
+      top.append((x, cy - h))
+      bottom.append((x, cy + h))
+    return np.array(top + bottom[::-1], dtype=np.float32)
+
+  def _draw_fill(self, rail: rl.Rectangle, fill_width: float):
+    if fill_width <= 0:
+      return
+    fill = rl.Rectangle(rail.x, rail.y, fill_width, rail.height)
+    rl.draw_rectangle_rounded(fill, 1.0, 10, rl.Color(FILL_COLOR.r, FILL_COLOR.g, FILL_COLOR.b, int(255 * SWEEP_DIM)))
+    draw_polygon(fill, self._capsule(fill), gradient=self._sweep_gradient(fill_width))
+
+  def _render_downloading(self, rect: rl.Rectangle):
+    percent = f"{int(self._progress.x)}%"
+    if self.status_text:
+      percent = f"{self.status_text} {percent}"
+    text_height = measure_text_cached(self._font, percent, FONT_SIZE).y
+    top = rect.y + (rect.height - (text_height + BAR_GAP + BAR_HEIGHT)) / 2
+
+    text_rect = rl.Rectangle(rect.x, top, rect.width, text_height)
+    self._name_label.set_text(self.name)
+    self._name_label.render(text_rect)
+    self._percent_label.set_text(percent)
+    self._percent_label.render(text_rect)
+
+    rail = rl.Rectangle(rect.x, top + text_height + BAR_GAP, rect.width, BAR_HEIGHT)
+    rl.draw_rectangle_rounded(rail, 1.0, 10, RAIL_COLOR)
+    self._draw_fill(rail, max(0.0, min(rect.width, rect.width * (self._progress.x / 100.0))))
+
+  def _render_idle(self, rect: rl.Rectangle):
+    if self.segments:
+      self._render_segments(rect)
+      return
+    text = self._idle_text
+    text_size = measure_text_cached(self._font, text, FONT_SIZE)
+    right = rect.x + rect.width
+
+    if self.icon:
+      texture = gui_app.texture(self.icon, ICON_SIZE, ICON_SIZE, keep_aspect_ratio=True)
+      rl.draw_texture_v(texture, rl.Vector2(right - texture.width, rect.y + (rect.height - texture.height) / 2),
+                        self.icon_color or self.text_color)
+      right -= texture.width + ICON_PADDING
+
+    rl.draw_text_ex(self._font, text, rl.Vector2(right - text_size.x, rect.y + (rect.height - text_size.y) / 2),
+                    FONT_SIZE, 0, self.text_color)
+
+  def _render_segments(self, rect: rl.Rectangle):
+    measured = self._measured_segments()
+    while len(self._segment_labels) < len(measured):
+      self._segment_labels.append(UnifiedLabelSP("", font_size=FONT_SIZE, max_width=SEGMENT_NAME_MAX_WIDTH,
+                                                 scroll=True, wrap_text=False))
+    x = rect.x + rect.width - sum(total for _, _, total in measured)
+    for i, ((text, color, icon, icon_color), text_width, _) in enumerate(measured):
+      if i:
+        x += SEGMENT_GAP
+      label = self._segment_labels[i]
+      if label.text != text:
+        label.set_text(text)
+      label.set_text_color(color)
+      text_height = measure_text_cached(self._font, text, FONT_SIZE).y
+      label.set_position(x, rect.y + (rect.height - text_height) / 2)
+      label.render()
+      x += text_width
+      if icon:
+        texture = gui_app.texture(icon, ICON_SIZE, ICON_SIZE, keep_aspect_ratio=True)
+        rl.draw_texture_v(texture, rl.Vector2(x + ICON_PADDING, rect.y + (rect.height - texture.height) / 2),
+                          icon_color or color)
+        x += ICON_PADDING + ICON_SIZE
+
+
+def download_status_item(title):
+  return ListItemSP(title=title, action_item=DownloadStatusAction(), title_color=style.ITEM_TEXT_COLOR)
@@ -207,13 +207,10 @@ def handle_agnos_update() -> None:
  set_consistent_flag(False)

  cloudlog.info(f"Beginning background installation for AGNOS {updated_version}")
-  set_offroad_alert("Offroad_NeosUpdate", True)

  manifest_path = os.path.join(OVERLAY_MERGED, "openpilot/system/hardware/comma/agnos.json")
  target_slot_number = get_target_slot_number()
  flash_agnos_update(manifest_path, target_slot_number, cloudlog)
-  set_offroad_alert("Offroad_NeosUpdate", False)
-


 class Updater:
@@ -23,9 +23,9 @@ def post_stream_request(body: StreamRequestBody) -> dict:
    ret["time"] = (t_end - t_start) * 1000
    return ret
  except requests.ConnectTimeout as e:
-    raise Exception("webrtc took too long to respond.") from e
+    raise Exception("device took too long to respond.") from e
  except requests.ConnectionError as e:
-    raise Exception("webrtc server on device is not running.") from e
+    raise Exception("turn car ignition off to use livestreaming.") from e


 def wait_for_webrtcd(max_retries: float = 10) -> None:
@@ -37,4 +37,4 @@ def wait_for_webrtcd(max_retries: float = 10) -> None:
    except requests.ConnectionError:
      attempts += 1
      time.sleep(0.5)
-  raise TimeoutError("webrtcd did not initialize in time.")
+  raise TimeoutError("livestreaming service did not initialize in time.")
@@ -7,7 +7,7 @@ from openpilot.common.test import OpenpilotTestCase
 from openpilot.cereal import messaging, log
 from teleoprtc.tracks import VIDEO_CLOCK_RATE

-from openpilot.system.webrtc.webrtcd import CerealOutgoingMessageProxy, CerealIncomingMessageProxy
+from openpilot.system.webrtc.webrtcd import CerealOutgoingMessageProxy, CerealIncomingMessageProxy, ServerState, handle_get_stream
 from openpilot.system.webrtc.device.video import LiveStreamVideoStreamTrack


@@ -80,3 +80,8 @@ class TestStreamSession(OpenpilotTestCase):
        start_pts = packet.pts
      assert abs(i + packet.pts - (start_pts + (((time.monotonic_ns() - start_ns) * VIDEO_CLOCK_RATE) // 1_000_000_000))) < 450 #5ms
      assert bytes(packet) == b""
+
+  def test_stream_rejects_non_json_content_type(self):
+    response = self.loop.run_until_complete(handle_get_stream(ServerState(), b"{}", "text/plain"))
+
+    assert response == (415, b'{"error": "unsupported media type"}', "application/json; charset=utf-8")
@@ -21,10 +21,16 @@ from typing import Any
 from openpilot.system.webrtc.helpers import StreamRequestBody
 from openpilot.system.webrtc.schema import generate_field
 from openpilot.common.params import Params
+from openpilot.common.swaglog import cloudlog
 from openpilot.cereal import messaging, log

 SESSION_TIMEOUT_SECONDS = 300

+
+# ice candidate parser for logging
+def _ice_candidates(sdp: str) -> list[str]:
+  return [line.removeprefix("a=") for line in sdp.splitlines() if line.startswith("a=candidate:")]
+
 # socket trick: route lookup for 8.8.8.8 (nothing is sent or actually connected to)
 # return the source interfaces IP which is the default interface of the device
 def _default_route_ip() -> str | None:
@@ -253,7 +259,7 @@ class StreamSession:
    self._cleanup_lock = asyncio.Lock()
    self._cleanup_done = False
    self.logger = logging.getLogger("webrtcd")
-    self.logger.info(
+    cloudlog.warning(
      "New stream session (%s), video cameras %s, video enabled %s, incoming services %s, outgoing services %s",
      self.identifier, [t.id for t in self.video_tracks], body.enabled, body.bridge_services_in, body.bridge_services_out,
    )
@@ -329,9 +335,12 @@ class StreamSession:
  async def run(self):
    try:
      self.params.put("LivestreamRequestKeyframe", True)
+
+      # avoid datachannel race by adding messange_handler immediately
+      self.stream.set_message_handler(self.message_handler)
+
      await asyncio.wait_for(self.stream.wait_for_connection(), timeout=15)
      if self.stream.has_messaging_channel():
-        self.stream.set_message_handler(self.message_handler)
        if self.incoming_bridge is not None:
          await self.shared_pub_master.add_services_if_needed(self.incoming_bridge_services)
        if self.outgoing_bridge is not None:
@@ -341,14 +350,18 @@ class StreamSession:
      if self.bitrate_controller is not None:
        self.bitrate_controller.start()

-      self.logger.info("Stream session (%s) connected", self.identifier)
+      with cloudlog.ctx(session_id=self.identifier):
+        cloudlog.warning("webrtcd.session.connected")
      if self.is_body:
        await self.run_body_session()
      else:
        await self.run_normal_session()
-      self.logger.info("Stream session (%s) ended", self.identifier)
+      with cloudlog.ctx(session_id=self.identifier):
+        cloudlog.warning("webrtcd.session.ended")
    except Exception:
      self.logger.exception("Stream session failure")
+      with cloudlog.ctx(session_id=self.identifier):
+        cloudlog.exception("webrtcd.session.exception")
    finally:
      await self.post_run_cleanup()

@@ -395,7 +408,10 @@ def _text_response(text: str, status: int = 200) -> tuple[int, bytes, str]:
  return (status, text.encode(), "text/plain; charset=utf-8")


-async def handle_get_stream(state: ServerState, raw_body: bytes) -> tuple[int, bytes, str]:
+async def handle_get_stream(state: ServerState, raw_body: bytes, content_type: str) -> tuple[int, bytes, str]:
+  if content_type != "application/json":
+    return _json_response({"error": "unsupported media type"}, status=415)
+
  stream_dict = state.streams
  body = StreamRequestBody(**json.loads(raw_body))

@@ -419,15 +435,25 @@ async def handle_get_stream(state: ServerState, raw_body: bytes) -> tuple[int, b
    stream_dict[session.identifier] = session
    try:
      answer = await asyncio.wait_for(session.get_answer(), timeout=30)
+      cloudlog.event(
+        "webrtcd.session.ice_candidates",
+        session_id=session.identifier,
+        offer_candidates=_ice_candidates(body.sdp),
+        answer_candidates=_ice_candidates(answer.sdp),
+      )
    except TimeoutError:
      await session.stop()
      stream_dict.pop(session.identifier, None)
      logging.getLogger("webrtcd").exception("Timed out creating stream answer")
+      with cloudlog.ctx(session_id=session.identifier):
+        cloudlog.warning("webrtcd.session.answer_timeout")
      raise
    except Exception:
      await session.stop()
      stream_dict.pop(session.identifier, None)
      logging.getLogger("webrtcd").exception("Failed to create stream answer")
+      with cloudlog.ctx(session_id=session.identifier):
+        cloudlog.exception("webrtcd.session.answer_exception")
      raise
    session.start()

@@ -508,7 +534,7 @@ class WebrtcdHandler(BaseHTTPRequestHandler):
        services = parse_qs(parsed.query).get("services", [""])[0]
        result = self._run(handle_get_schema(self.server.state, services))
      elif parsed.path == "/stream":
-        result = self._run(handle_get_stream(self.server.state, self._read_body()))
+        result = self._run(handle_get_stream(self.server.state, self._read_body(), self.headers.get_content_type()))
      else:  # /notify
        try:
          payload = json.loads(self._read_body())
@@ -611,7 +637,7 @@ def webrtcd_thread(host: str, port: int):

 def main():
  parser = argparse.ArgumentParser(description="WebRTC daemon")
-  parser.add_argument("--host", type=str, default="0.0.0.0", help="Host to listen on")
+  parser.add_argument("--host", type=str, default="127.0.0.1", help="Host to listen on")
  parser.add_argument("--port", type=int, default=5001, help="Port to listen on")
  args = parser.parse_args()

@@ -21,7 +21,7 @@ dependencies = [
  "tqdm",         # cars (fw_versions.py) on start + many one-off uses

  # core
-  "scons",
+  "scons==4.10.1",  # 4.11 removed the qt3 tool still used to build Cabana
  "pycapnp==2.1.0",  # 2.2 introduces a memory leak due to cyclic references
  "numpy >=2.0",

@@ -1,260 +0,0 @@
-#!/usr/bin/env bash
-set -e
-
-# Default values
-DEFAULT_REPO_URL="https://github.com/sunnypilot"
-START_AT_BOOT=false
-RESTORE_MODE=false
-RUNNER_VERSION="2.325.0"
-
-# Parse command line arguments
-while [[ $# -gt 0 ]]; do
-    case $1 in
-        --start-at-boot)
-            START_AT_BOOT=true
-            shift
-            ;;
-        --token)
-            GITHUB_TOKEN="$2"
-            shift 2
-            ;;
-        --repo)
-            REPO_URL="$2"
-            shift 2
-            ;;
-        --restore)
-            RESTORE_MODE=true
-            shift
-            ;;
-        *)
-            if [ -z "$GITHUB_TOKEN" ]; then
-                GITHUB_TOKEN="$1"
-            elif [ -z "$REPO_URL" ]; then
-                REPO_URL="$1"
-            fi
-            shift
-            ;;
-    esac
-done
-
-# Determine BASE_DIR based on mount point
-if mountpoint -q /data/media; then
-    BASE_DIR="/data/media/0/github"
-else
-    BASE_DIR="/data/github"
-fi
-
-# Constants
-RUNNER_USER="github-runner"
-USER_GROUPS="comma,gpu,gpio,sudo"
-RUNNER_DIR="${BASE_DIR}/runner"
-BUILDS_DIR="${BASE_DIR}/builds"
-LOGS_DIR="${BASE_DIR}/logs"
-CACHE_DIR="${BASE_DIR}/cache"
-OPENPILOT_DIR="${BASE_DIR}/openpilot"
-
-# Basic utility functions (no dependencies)
-remount_rw() {
-    sudo mount -o remount,rw /
-}
-
-remount_ro() {
-    sync || true  # Try to sync but continue even if it fails
-    sudo mount -o remount,ro /  # Always try to remount as read-only
-}
-
-# Always ensure we try to remount as read-only on exit
-trap remount_ro EXIT
-
-setup_runner_user() {
-    sudo useradd --comment 'GitHub Runner' --create-home --home-dir ${BASE_DIR} ${RUNNER_USER} --shell /bin/bash -G ${USER_GROUPS} || sudo usermod -aG ${USER_GROUPS} ${RUNNER_USER}
-}
-
-create_sudoers_entry() {
-    sudo grep -qxF "${RUNNER_USER} ALL=(ALL) NOPASSWD: ALL" /etc/sudoers || echo "${RUNNER_USER} ALL=(ALL) NOPASSWD: ALL" | sudo tee -a /etc/sudoers
-}
-
-set_directory_permissions() {
-    sudo chown -R ${RUNNER_USER}:comma "$BASE_DIR"
-    sudo chmod -R g+rwx "$BASE_DIR"
-    sudo find "$BASE_DIR" -type d -exec chmod g+s {} +
-}
-
-setup_directories() {
-    echo "Creating necessary directories..."
-    sudo mkdir -p "$RUNNER_DIR" "$BUILDS_DIR" "$LOGS_DIR" "$CACHE_DIR" "$OPENPILOT_DIR"
-    mkdir -p "/data/openpilot"
-    sudo chown -R comma:comma "/data/openpilot"
-    sync
-}
-
-wipe_bash_logout() {
-  export BASE_DIR
-  sudo -u ${RUNNER_USER} bash -c "touch ${BASE_DIR}/.bash_logout"
-  sudo -u ${RUNNER_USER} bash -c "truncate -s 0 '${BASE_DIR}/.bash_logout'"
-}
-
-# System configuration functions (depends on basic utility functions)
-setup_system_configs() {
-    echo "Setting up system configurations..."
-    remount_rw
-    setup_runner_user
-    create_sudoers_entry
-    remount_ro
-    set_directory_permissions
-    wipe_bash_logout
-}
-
-# Runner setup functions
-install_runner() {
-    echo "Downloading and setting up runner..."
-    cd "$RUNNER_DIR"
-    curl -o actions-runner-linux-arm64-${RUNNER_VERSION}.tar.gz -L https://github.com/actions/runner/releases/download/v${RUNNER_VERSION}/actions-runner-linux-arm64-${RUNNER_VERSION}.tar.gz
-    sudo -u ${RUNNER_USER} tar -xzf ./actions-runner-linux-arm64-${RUNNER_VERSION}.tar.gz
-    sudo rm ./actions-runner-linux-arm64-${RUNNER_VERSION}.tar.gz
-    sudo chmod +x ./config.sh
-}
-
-configure_runner() {
-    remount_rw
-    echo "Configuring runner..."
-    cd "$RUNNER_DIR"
-    sudo -u ${RUNNER_USER} ./config.sh --url "$REPO_URL" --token "$GITHUB_TOKEN" --name $(hostname) --runnergroup "tici-tizi" --labels "tici" --work "$BUILDS_DIR" --unattended
-    remount_ro
-}
-
-create_service_template() {
-    echo "Creating service template..."
-    cat <<EOL > "$RUNNER_DIR/bin/actions.runner.service.template"
-[Unit]
-Description={{Description}}
-After=network-online.target nss-lookup.target time-sync.target
-Wants=network-online.target nss-lookup.target time-sync.target
-StartLimitInterval=5
-StartLimitBurst=10
-
-[Service]
-Type=simple
-User=root
-ExecStart=/usr/bin/unshare -m -- /bin/bash -c 'mount --bind ${OPENPILOT_DIR} /data/openpilot && setpriv --reuid={{User}} --regid={{User}} --init-groups env HOME=${BASE_DIR} USER={{User}} LOGNAME={{User}} MAIL=/var/mail/{{User}} {{RunnerRoot}}/runsvc.sh'
-WorkingDirectory={{RunnerRoot}}
-KillMode=process
-KillSignal=SIGTERM
-TimeoutStopSec=5min
-Restart=always
-RestartSec=120
-
-[Install]
-WantedBy=multi-user.target
-EOL
-}
-
-install_service() {
-    local service_name
-    if [ -f "${RUNNER_DIR}/.service" ]; then
-        service_name=$(cat "${RUNNER_DIR}/.service")
-    else
-        service_name="actions.runner.sunnypilot.$(uname -n)"
-    fi
-  
-    create_service_template
-    remount_rw
-    local service_path="/etc/systemd/system/${service_name}"
-    echo "Installing systemd service..."
-    if [ -f "${service_path}" ]; then
-        echo "Service ${service_path} found in systemd, we will delete it"
-        sudo rm -f "${service_path}"
-    fi
-    
-    cd "$RUNNER_DIR"
-    sudo ./svc.sh install $RUNNER_USER
-
-    if [ "$START_AT_BOOT" = false ]; then
-        sudo systemctl disable "${service_name}"
-    fi
-    remount_ro
-}
-
-check_restore_prerequisites() {
-    local can_restore=false
-    local service_name=""
-
-    # Check if base runner directory exists
-    if [ ! -d "${RUNNER_DIR}" ]; then
-        echo "ERROR: Runner directory ${RUNNER_DIR} does not exist"
-        echo "This directory is required for restore operations"
-        exit 1
-    fi
-
-    # First check if we have the required files for restoration
-    if [ -f "${RUNNER_DIR}/.credentials" ] && [ -f "${RUNNER_DIR}/.service" ]; then
-        can_restore=true
-        service_name=$(cat "${RUNNER_DIR}/.service")
-        echo "Found required runner configuration files"
-    else
-        echo "Missing required runner configuration files"
-        echo "Required: .credentials and .service files in ${RUNNER_DIR}"
-        exit 1
-    fi
-
-    if ! id "${RUNNER_USER}" &>/dev/null; then
-        echo "User ${RUNNER_USER} does not exist"
-    fi
-
-    # Only proceed if we can restore AND need to restore
-    if [ "$can_restore" = true ]; then
-        echo "Restoration is possible"
-        return 0
-    else
-        echo "No restoration possible"
-        exit 0
-    fi
-}
-
-perform_restore() {
-    echo "Starting runner restoration..."
-    setup_directories
-    setup_system_configs
-    install_service
-    echo "Runner restoration completed successfully"
-}
-
-perform_install() {
-    echo "Starting fresh installation..."
-    setup_directories
-    setup_system_configs
-    install_runner
-    set_directory_permissions
-    configure_runner
-    install_service
-    echo "Installation completed successfully"
-}
-
-main() {
-    if [ "$RESTORE_MODE" = true ]; then
-        echo "Running in restore mode - will only restore system configurations..."
-        check_restore_prerequisites
-        perform_restore
-    else
-        # Check required arguments for normal installation
-        if [ -z "$GITHUB_TOKEN" ]; then
-            echo "Usage: $0 [--start-at-boot] [--token <github_token>] [--repo <repository_url>] [--restore]"
-            echo "Required argument (except for --restore): github_token"
-            echo "Optional arguments:"
-            echo "  --start-at-boot    Enable auto-start at boot (default: false)"
-            echo "  --repo            Repository URL (default: ${DEFAULT_REPO_URL})"
-            echo "  --restore         Restore existing runner configuration"
-            exit 1
-        fi
-
-        # Set repository URL if not provided
-        REPO_URL="${REPO_URL:-$DEFAULT_REPO_URL}"
-        perform_install
-    fi
-
-    echo "Starting runner service..."
-    cd "$RUNNER_DIR"
-    sudo ./svc.sh start
-}
-
-main
@@ -48,24 +48,33 @@ def create_short_name(full_name: str) -> str:
  return result[:8]


-def _read_pkl_bytes(pkl_path: Path) -> bytes:
+def create_pkl_name(full_name: str) -> str:
+  pkl = re.sub(r'[^a-zA-Z0-9]+', '_', full_name).strip('_').lower()
+  return pkl
+
+
+def _hash_pkl(pkl_path: Path) -> str:
  manifest = Path(f"{pkl_path}.chunkmanifest")
  if manifest.exists():
    num_chunks = int(manifest.read_text().strip())
-    parts = []
-    for i in range(num_chunks):
-      chunk = Path(f"{pkl_path}.chunk{i + 1:02d}of{num_chunks:02d}")
-      parts.append(chunk.read_bytes())
-    return b''.join(parts)
-  return pkl_path.read_bytes()
+    paths = [Path(f"{pkl_path}.chunk{i + 1:02d}of{num_chunks:02d}") for i in range(num_chunks)]
+  else:
+    paths = [pkl_path]
+
+  digest = hashlib.sha256()
+  for path in paths:
+    with path.open('rb') as f:
+      while block := f.read(1024 * 1024):
+        digest.update(block)
+  return digest.hexdigest()


 def _find_driving_pkl(output_path: Path) -> Path | None:
-  for pattern in ('driving_tinygrad.pkl', 'driving_*_tinygrad.pkl'):
+  for pattern in ('*driving_tinygrad.pkl', '*driving_*_tinygrad.pkl'):
    matches = sorted(output_path.glob(pattern))
    if matches:
      return matches[0]
-  for pattern in ('driving_tinygrad.pkl.chunkmanifest', 'driving_*_tinygrad.pkl.chunkmanifest'):
+  for pattern in ('*driving_tinygrad.pkl.chunkmanifest', '*driving_*_tinygrad.pkl.chunkmanifest'):
    matches = sorted(output_path.glob(pattern))
    if matches:
      return Path(str(matches[0]).removesuffix('.chunkmanifest'))
@@ -81,8 +90,20 @@ def _rename_pkl_with_chunks(old_pkl: Path, new_pkl: Path) -> Path:
  return old_pkl.rename(new_pkl)


+def _hash_onnx_files(model_dir: Path) -> str | None:
+  onnx_files = sorted(model_dir.glob("*.onnx"))
+  if not onnx_files:
+    return None
+  digest = hashlib.sha256()
+  for f in onnx_files:
+    with f.open('rb') as fh:
+      while block := fh.read(1024 * 1024):
+        digest.update(block)
+  return digest.hexdigest()
+
+
 def generate_chunked_model(driving_pkl: Path) -> dict:
-  tinygrad_hash = hashlib.sha256(_read_pkl_bytes(driving_pkl)).hexdigest()
+  tinygrad_hash = _hash_pkl(driving_pkl)

  chunks_config = []
  manifest_file = Path(f"{driving_pkl}.chunkmanifest")
@@ -114,7 +135,8 @@ def generate_chunked_model(driving_pkl: Path) -> dict:
  }


-def create_metadata_json(models: list, output_dir: Path, custom_name=None, short_name=None, is_20hz=False, upstream_branch="unknown") -> None:
+def create_metadata_json(models: list, output_dir: Path, custom_name=None, short_name=None, is_20hz=False, upstream_branch="unknown",
+                         onnx_sha256=None, is_big=False) -> None:
  bundle_json = {
    "short_name": short_name,
    "display_name": custom_name or upstream_branch,
@@ -127,9 +149,13 @@ def create_metadata_json(models: list, output_dir: Path, custom_name=None, short
    "generation": "-1",
    "build_time": datetime.now(UTC).strftime("%Y-%m-%dT%H:%M:%SZ"),
    "overrides": {},
+    "is_big": is_big,
    "models": models,
  }

+  if onnx_sha256:
+    bundle_json["onnx_sha256"] = onnx_sha256
+
  # Write metadata to output_dir
  metadata_json = {
    "bundles": [bundle_json]
@@ -154,18 +180,23 @@ if __name__ == "__main__":
  _output_dir = Path(args.output_dir)
  _output_dir.mkdir(exist_ok=True, parents=True)
  _short_name = create_short_name(args.custom_name) if args.custom_name else None
+  _pkl = create_pkl_name(args.custom_name) if args.custom_name else None

  _driving_pkl = _find_driving_pkl(_output_dir)
  if not _driving_pkl:
    print(f"No driving_tinygrad.pkl found in {_output_dir}", file=sys.stderr)
    sys.exit(1)

-  if _short_name:
-    new_pkl = _output_dir / f"driving_{_short_name.lower()}_tinygrad.pkl"
+  is_big = _driving_pkl.name.startswith('big_')
+
+  if _pkl:
+    new_pkl = _output_dir / f"driving_{_pkl}_tinygrad.pkl"
    if not new_pkl.exists():
      _driving_pkl = _rename_pkl_with_chunks(_driving_pkl, new_pkl)
    else:
      _driving_pkl = new_pkl

  _model_metadata = generate_chunked_model(_driving_pkl)
-  create_metadata_json([_model_metadata], _output_dir, args.custom_name, _short_name, args.is_20hz, args.upstream_branch)
+  _onnx_sha256 = _hash_onnx_files(Path(args.model_dir))
+  create_metadata_json([_model_metadata], _output_dir, args.custom_name, _short_name, args.is_20hz, args.upstream_branch,
+                       onnx_sha256=_onnx_sha256, is_big=is_big)
@@ -47,11 +47,17 @@ git rm -rf $OUTPUT_DIR/.git || true # Doing cleanup, but it might fail if the .g
 git remote remove origin || true # ensure cleanup
 git remote add origin $GIT_ORIGIN
 #git push origin -d $DEV_BRANCH || true # Ensuring we delete the remote branch if it exists as we are wiping it out
-git fetch origin $DEV_BRANCH || (git checkout -b $DEV_BRANCH && git commit --allow-empty -m "sunnypilot v$VERSION release" && git push -u origin $DEV_BRANCH)
+git fetch --depth 1 origin $DEV_BRANCH || (git checkout -b $DEV_BRANCH && git commit --allow-empty -m "sunnypilot v$VERSION release" && git push -u origin $DEV_BRANCH)

 echo "[-] committing version $VERSION T=$SECONDS"
 git add -f .

+# gitlinks break the release tree on device
+if git ls-files -s | awk '$1 == "160000" { found = 1; print } END { exit !found }'; then
+    echo "Error: submodules found in release tree."
+    exit 1
+fi
+
 # include source commit hash and build date in commit
 GIT_HASH=$(git --git-dir=$SOURCE_DIR/.git rev-parse HEAD)
 DATETIME=$(date '+%Y-%m-%dT%H:%M:%S')
@@ -1,66 +0,0 @@
-#!/usr/bin/env bash
-# Determine BASE_DIR based on mount point
-if mountpoint -q /data/media; then
-    GITHUB_BASE_DIR="/data/media/0/github"
-else
-    GITHUB_BASE_DIR="/data/github"
-fi
-
-# Define directories and user
-BIN_DIR="$GITHUB_BASE_DIR/bin"
-BUILDS_DIR="$GITHUB_BASE_DIR/builds"
-OPENPILOT_DIR="$GITHUB_BASE_DIR/openpilot"
-LOGS_DIR="$GITHUB_BASE_DIR/logs"
-CACHE_DIR="$GITHUB_BASE_DIR/cache"
-RUNNER_USERNAME="github-runner"
-# Define the systemd service name
-SERVICE_NAME="github-runner"
-USER_GROUPS="comma,gpu,gpio,sudo"
-
-# Function to stop and disable the systemd service
-stop_and_uninstall_service() {
-    cd $GITHUB_BASE_DIR/runner
-    sudo ./svc.sh stop
-    sudo ./svc.sh uninstall
-}
-
-# Function to remove the systemd service file
-remove_runner() {
-    cd $GITHUB_BASE_DIR/runner
-    sudo rm .runner
-    sudo su -c './config.sh remove' github-runner
-}
-
-# Function to delete the Github Runner directories
-delete_directories() {
-    sudo rm -rf "$BIN_DIR/github-runner"
-    sudo rm -rf "$GITHUB_BASE_DIR" "$BIN_DIR" "$BUILDS_DIR" "$LOGS_DIR" "$CACHE_DIR" "$OPENPILOT_DIR"
-}
-
-# Function to remove the Github Runner user
-delete_user() {
-    for group in ${USER_GROUPS//,/ }
-    do
-       sudo gpasswd -d ${RUNNER_USERNAME} ${group}
-    done
-    sudo userdel -r ${RUNNER_USERNAME}
-}
-
-# Function to remove sudoers entry
-remove_sudoers_entry() {
-    sudo sed -i.bak "/${RUNNER_USERNAME} ALL=(ALL) NOPASSWD: ALL/d" /etc/sudoers
-}
-
-# Make filesystem writable
-sudo mount -o remount rw /
-
-# Ensure filesystem is remounted as read-only on script exit
-trap "sudo mount -o remount ro /" EXIT
-
-# Call functions
-stop_and_uninstall_service
-remove_runner
-delete_directories
-delete_user
-remove_sudoers_entry
-# End of uninstall script
@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+"""
+Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
+
+This file is part of sunnypilot and is licensed under the MIT License.
+See the LICENSE.md file in the root directory for more details.
+"""
+
+import argparse
+import hashlib
+import json
+import tempfile
+
+from huggingface_hub import HfApi, hf_hub_download
+
+
+def hash_file(path: str) -> str:
+  digest = hashlib.sha256()
+  with open(path, 'rb') as f:
+    while block := f.read(1024 * 1024):
+      digest.update(block)
+  return digest.hexdigest()
+
+
+def main():
+  parser = argparse.ArgumentParser()
+  parser.add_argument("--hf-repo", required=True)
+  parser.add_argument("--hf-defaults-path", required=True)
+  parser.add_argument("--artifact-name", required=True)
+  parser.add_argument("--model-dir", required=True)
+  parser.add_argument("--onnx-path", required=True)
+  parser.add_argument("--onnx-ref", required=True)
+  parser.add_argument("--model-name", required=True)
+  parser.add_argument("--tinygrad-ref", required=True)
+  parser.add_argument("--run-number", required=True)
+  args = parser.parse_args()
+
+  api = HfApi()
+  onnx_sha256 = hash_file(args.onnx_path)
+  short_ref = args.onnx_ref[:8]
+  folder_name = f"model-{args.model_name}-{short_ref}-{args.run_number}"
+
+  print(f"ONNX hash: {onnx_sha256}")
+  print(f"ONNX ref: {args.onnx_ref} (short: {short_ref})")
+  print(f"Folder: {folder_name}")
+
+  metadata_path = f"{args.model_dir}/metadata.json"
+  with open(metadata_path) as f:
+    metadata = json.load(f)
+
+  bundle = metadata['bundles'][0]
+  bundle['display_name'] = args.model_name
+  bundle['onnx_sha256'] = onnx_sha256
+  bundle['onnx_ref'] = args.onnx_ref
+
+  artifact = bundle['models'][0]['artifact']
+  hf_base = f"https://huggingface.co/datasets/{args.hf_repo}/resolve/main/{args.hf_defaults_path}/{folder_name}"
+  artifact['download_uri']['url'] = f"{hf_base}/{artifact['file_name']}"
+  for chunk in artifact.get('chunks', []):
+    chunk['url'] = f"{hf_base}/{chunk['file_name']}"
+
+  print(f"Uploading model to {args.hf_defaults_path}/{folder_name}/")
+  api.upload_folder(
+    folder_path=args.model_dir,
+    path_in_repo=f"{args.hf_defaults_path}/{folder_name}",
+    repo_id=args.hf_repo,
+    repo_type="dataset",
+  )
+
+  json_filename = f"{args.hf_defaults_path}/default_models.json"
+  try:
+    local_path = hf_hub_download(repo_id=args.hf_repo, repo_type='dataset', filename=json_filename)
+    with open(local_path) as f:
+      defaults_json = json.load(f)
+  except Exception:
+    defaults_json = {"tinygrad_ref": args.tinygrad_ref, "bundles": []}
+
+  defaults_json['tinygrad_ref'] = args.tinygrad_ref
+
+  existing_idx = next((i for i, b in enumerate(defaults_json['bundles'])
+                       if b.get('onnx_sha256') == onnx_sha256), None)
+  if existing_idx is not None:
+    defaults_json['bundles'][existing_idx] = bundle
+  else:
+    defaults_json['bundles'].append(bundle)
+
+  print(json.dumps(defaults_json, indent=2))
+
+  with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
+    json.dump(defaults_json, f, indent=2)
+    tmp_path = f.name
+
+  api.upload_file(
+    path_or_fileobj=tmp_path,
+    path_in_repo=json_filename,
+    repo_id=args.hf_repo,
+    repo_type="dataset",
+  )
+
+  print(f"Updated {json_filename}")
+
+
+if __name__ == "__main__":
+  main()
@@ -2,15 +2,14 @@
 set -e
 set -x

-# git diff --name-status origin/release3-staging | grep "^A" | less
-
 DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" >/dev/null && pwd)"
-
 cd $DIR

 BUILD_DIR=/data/openpilot
 SOURCE_DIR="$(git rev-parse --show-toplevel)"

+export PYTHONPATH="$BUILD_DIR:$BUILD_DIR/msgq_repo:$BUILD_DIR/opendbc_repo:$BUILD_DIR/rednose_repo:$BUILD_DIR/teleoprtc_repo:$BUILD_DIR/tinygrad_repo"
+
 if [ -z "$RELEASE_BRANCH" ]; then
  echo "RELEASE_BRANCH is not set"
  exit 1
@@ -23,33 +22,36 @@ BUILD_BRANCH=release-mici-staging
 source $DIR/identity.sh

 echo "[-] Setting up repo T=$SECONDS"
-rm -rf $BUILD_DIR
-mkdir -p $BUILD_DIR
+if ! git -C "$SOURCE_DIR" worktree remove --force "$BUILD_DIR" 2>/dev/null; then
+  rm -rf $BUILD_DIR
+fi
+git -C "$SOURCE_DIR" worktree prune
+git -C "$SOURCE_DIR" worktree add --detach --no-checkout "$BUILD_DIR"
 cd $BUILD_DIR
-git init
-git remote add origin git@github.com:commaai/openpilot.git
-git checkout --orphan $BUILD_BRANCH
+git update-ref -d "refs/heads/$BUILD_BRANCH"
+git symbolic-ref HEAD "refs/heads/$BUILD_BRANCH"
+git read-tree --empty

 # do the files copy
 echo "[-] copying files T=$SECONDS"
 cd $SOURCE_DIR
-cp -pR --parents $(./tools/release/release_files.py) $BUILD_DIR/
+./tools/release/release_files.py | xargs -0 cp -pR --parents -t "$BUILD_DIR" --

 # in the directory
 cd $BUILD_DIR

-rm -f panda/board/obj/panda.bin.signed
-rm -f panda/board/obj/panda_h7.bin.signed
+# use the full CPU available for speeding up the build.
+# openpilot resets the CPU frequencies when test_onroad.py runs below.
+for policy in /sys/devices/system/cpu/cpufreq/policy*; do
+  [ -d "$policy" ] || continue
+  hardware_max="$(cat "$policy/cpuinfo_max_freq")"
+  echo "$hardware_max" | sudo tee "$policy/scaling_max_freq" >/dev/null
+done

-VERSION=$(cat openpilot/sunnypilot/common/version.h | awk -F[\"-]  '{print $2}')
-echo "[-] committing version $VERSION T=$SECONDS"
-git add -f .
-git commit -a -m "openpilot v$VERSION release"
-
-# Build and test before launch_chffrplus.sh creates the on-device package
-# symlinks. SConstruct uses the same package roots for build subprocesses.
-export PYTHONPATH="$BUILD_DIR:$BUILD_DIR/msgq_repo:$BUILD_DIR/opendbc_repo:$BUILD_DIR/rednose_repo:$BUILD_DIR/teleoprtc_repo:$BUILD_DIR/tinygrad_repo"
 scons
+if [ -n "$INCLUDE_BIG_MODEL" ]; then
+  test -f openpilot/selfdrive/modeld/models/big_driving_tinygrad.pkl.chunkmanifest
+fi

 if [ -z "$PANDA_DEBUG_BUILD" ]; then
  # release panda fw
@@ -72,7 +74,6 @@ find . -name '*.a' -delete
 find . -name '*.o' -delete
 find . -name '*.os' -delete
 find . -name '*.pyc' -delete
-find . -name 'moc_*' -delete
 find . -name '__pycache__' -delete
 rm -rf .sconsign.dblite Jenkinsfile tools/release/
 rm -f openpilot/selfdrive/modeld/models/*.onnx*
@@ -88,9 +89,11 @@ git checkout openpilot/third_party/
 # Mark as prebuilt release
 touch prebuilt

+VERSION=$(cat openpilot/sunnypilot/common/version.h | awk -F[\"-]  '{print $2}')
 # Add built files to git
-git add -f .
-git commit --amend -m "openpilot v$VERSION"
+# writing larger objects is faster than compressing them on-device
+git -c core.compression=0 add -f .
+git -c core.compression=0 -c gc.auto=0 commit -m "openpilot v$VERSION"

 # Run tests
 cd $BUILD_DIR
@@ -102,6 +105,7 @@ REFS=()
 for branch in ${RELEASE_BRANCH//,/ }; do
  REFS+=("$BUILD_BRANCH:$branch")
 done
-git push -f origin "${REFS[@]}"
+# uploading the larger pack is faster than spending CPU to optimize it
+git -c pack.window=0 -c pack.depth=0 -c pack.compression=0 push -f origin "${REFS[@]}"

 echo "[-] done T=$SECONDS"
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
royjr	04a8ad189e	Merge branch 'master' into egpu-alert	2026-08-27 11:01:29 -04:00
Jason Wen	9f43d2477d	[MICI] ui: move and restyle the sunnylink pill in settings (#1972 )	2026-08-27 03:52:57 -04:00
Nayan	2d6cc4c065	models: Model Selector upgrades (#1953 ) * uh, i did not commit anything all this time * slideee to the left, cha cha * lint lint * ui: unify model source predicate and per-source bundle lookup in model_info * [TIZI/TICI] ui: disable the other-model row onroad like the active row * [TIZI/TICI] ui: drop docstring that restates the function name * [TIZI/TICI] ui: keep Favorites as the first model folder in the picker * ui: record why model names read the params slots and not modelManagerSP * ui: show the default model's name on the picker Default entries * models: bind a download to its ref so cancel and reselect work everywhere * models: resume partial chunked downloads and verify silently * models: publish a verifying status so cached checks read as verification, not a stuck download * [TIZI/TICI] ui: move download status onto each model's own row * [TIZI/TICI] ui: show the row status description while it has text * [TIZI/TICI] ui: restore the Model Status bar row * models: a cancel interrupts verification immediately and keeps on-disk chunks * models: a selection made mid-download queues instead of cancelling the transfer * [TIZI/TICI] ui: Model Status shows both slots idle and the queued pick while busy * [TIZI/TICI] ui: label the Model Status slots small and big and scroll long names * models: start a queued download in the same tick and label empty slots (Default) * ui: scroll Model Status names at the corrected speed * [TIZI/TICI] ui: Model Status shows the big model failing over to small * [TIZI/TICI] ui: stable model rows and a runner-matched failover note on Model Status * [TIZI/TICI] ui: model rows show full names and the failover note reopens with the page * ui: name the actually driving model runner-matched and bring mici to state parity * fix ugly --------- Co-authored-by: Jason Wen <haibin.wen3@gmail.com> Co-authored-by: James Vecellio-Grant <159560811+Discountchubbs@users.noreply.github.com>	2026-08-27 02:03:53 -04:00
Nayan	da28afca91	models: dual-slot backend (qcom/usbgpu) with ref-based downloads (#1966 ) * models: dual-slot backend (qcom/usbgpu) with ref-based downloads * models: restore get_active_source and the usbgpu-to-qcom fallback * models: fix per-slot validation and cap mismatched-source refetches * ui/models: select models by ref and seed the usbgpu slot on migration * models: drop defensive attribute guards on capnp bundles * models: remove vestigial fetcher state and dead fallbacks * models: resolve the active bundle from the active source slot only * models: pass the usbgpu kwarg through the modeld test stubs * models: resolve the displayed model from the active slot in ui_state * models: correct the validation memo type hint * models: drop docstrings that restate the function name --------- Co-authored-by: Jason Wen <haibin.wen3@gmail.com>	2026-08-26 02:34:02 -04:00
Jason Wen	15f201caed	ui: use full big model failure detection for sidebar and home eGPU icons (#1969 )	2026-08-25 21:07:44 -04:00
Jason Wen	1d4558c067	[TIZI/TICI] sidebar: show eGPU icon when chestnut is present (#1968 ) * [tizi/tici] sidebar: show eGPU icon when chestnut is present * matchy match * fix	2026-08-25 20:47:52 -04:00
Jason Wen	78a766eb61	ui: fix scrolling label speed at non-60fps refresh rates (#1967 ) * ui: fix scrolling label speed at non-60fps refresh rates * send it * nope * more	2026-08-25 20:38:02 -04:00
Jason Wen	b742b96c44	[MICI] ui: four-state eGPU icon for non-default big models (#1945 ) * ui: four-state eGPU icon for non-default big models * oops * try this out * align	2026-08-25 12:04:39 -04:00
Jason Wen	25c25047b8	models: persist model selection per catalog across chestnut state changes (#1960 )	2026-08-25 01:12:12 -04:00
Jason Wen	cefe5737b9	models: fix current model not updating on chestnut status (#1959 ) * models: preserve user model selection across reboots and power cycles * no * again * idk * over	2026-08-25 00:41:31 -04:00
Jason Wen	760c19d3f9	ui/models: handle missing files during cache size calculation (#1958 )	2026-08-24 23:31:52 -04:00
James Vecellio-Grant	45814e3313	modeld_v2: spatial features (#1934 ) * modeld_v2: spatial features * Update fetcher.py * dont reshape non 4 dim arrays * realize for non compiled * Update compile_modeld.py * god dammit it was realize() * it was fucking frozen tinygrad. just need to recompile * bump * ci: add is_big flag to metadata.json to support backward compat * Update model_generator.py * Update sunnypilot-build-model.yaml * Update helpers.py * Revert "Update helpers.py" This reverts commit `3a955ca11a`. * Reapply "Update helpers.py" This reverts commit `ca9c6e1933`. * models: use less strict chestnut detection state --------- Co-authored-by: Jason Wen <haibin.wen3@gmail.com>	2026-08-24 22:52:29 -04:00
Jason Wen	2ba91d2be5	ci: add tinygrad ref check to prepare_chestnut and even faster prebuilt stages (#1957 ) * ci: faster prebuilt stages * tg check chestnut * zoomer!	2026-08-24 22:42:45 -04:00
Jason Wen	19f83b274f	ci: identical environment for publish_chestnut prebuilt	2026-08-24 22:06:20 -04:00
Jason Wen	d14d0b1dd0	ci: parallelize models chunk downloads and split branch publishing (#1955 ) * ci: parallelize model chunk downloads and better publish * ci: download all model chunks in parallel with xargs -P8 * split split * ew * must require	2026-08-24 21:48:53 -04:00
Jason Wen	6cc5f3aad8	ci: fix DM model build, separate HF defaults paths, nuke build races (#1956 ) * ci: fix DM model build, separate HF defaults paths, nuke build races * more split! * name * ci: download driving and DM model chunks into chestnut prebuilt output	2026-08-24 20:02:48 -04:00
Jason Wen	8e16c9babb	ci: offload small model compilation (#1952 ) * ci: compile default big model with stock modeld * Revert "Revert big RL model (#38627)" This reverts commit `516ec1e682`. * ci: compile default small model with stock modeld compiler * ci: offload small model compilation * Reapply "Revert big RL model (#38627)" This reverts commit `d06cfabb62`. * Reapply "Revert big RL model (#38627)" This reverts commit `d06cfabb62`.	2026-08-24 16:24:19 -04:00
Jason Wen	2bcfed5c71	ci: compile default models with stock modeld (#1954 ) * ci: compile default big model with stock modeld * Revert "Revert big RL model (#38627)" This reverts commit `516ec1e682`. * ci: compile default small model with stock modeld compiler * Reapply "Revert big RL model (#38627)" This reverts commit `d06cfabb62`.	2026-08-24 15:37:46 -04:00
Jason Wen	66cf334067	ci: unify default model build into single workflow (#1951 ) * ci: unify default model build into single workflow * ci: consolidate upload jobs and add tinygrad ref validation	2026-08-24 12:35:37 -04:00
Jason Wen	94ed0608e6	models: use less strict chestnut detection state (#1948 )	2026-08-24 01:40:31 -04:00
royjr	e3cd22b765	egpu: alert when big model ready	2026-08-24 00:22:41 -04:00
Jason Wen	0fbca979df	models: show big model list when Chestnut present (#1943 )	2026-08-23 20:19:57 -04:00
Jason Wen	dcddb2a0bd	models: revert icon override from this branch scope	2026-08-23 19:53:46 -04:00
Jason Wen	699eaf7957	include them!	2026-08-23 19:16:15 -04:00
Jason Wen	c246e6318a	Merge branch 'master' into models-good-detect	2026-08-23 16:56:44 -04:00
Jason Wen	718db8c62e	Sync: `commaai/openpilot:master` → `sunnypilot/sunnypilot:master` (#1944 )	2026-08-23 16:56:00 -04:00
Jason Wen	c2214d4c32	Merge commit '084747c75d2cbd23af65ab7a9e770bbd7b98bac9' into sync-20260823 # Conflicts: # openpilot/common/params_keys.h	2026-08-23 15:36:54 -04:00
Jason Wen	0de7fbf33d	new	2026-08-23 15:06:53 -04:00
Jason Wen	211f990f6b	models: fix sunnylink default model display and false big model re-downloading (#1941 ) * big needs small * no download * actually * send it	2026-08-23 04:04:46 -04:00
Jason Wen	97468e4fa4	[TIZI/TICI] ui: remove calibration reset dialog on model change (#1942 )	2026-08-23 03:48:52 -04:00
Jason Wen	6c6fba9a14	ci: fix flaky LLK test (#1940 )	2026-08-23 02:57:02 -04:00
Jason Wen	34621cf816	ci: refactor big model chunk handling (#1939 )	2026-08-23 02:48:10 -04:00
Jason Wen	086530b7c6	[TIZI/TICI] ui: fix path width during gas and steering override (#1938 )	2026-08-22 21:47:38 -04:00
Jason Wen	4f46433e2b	alerts: add branch metadata to chestnut offroad warning (#1936 ) * alerts: add branch metadata to chestnut offroad warning * all branches	2026-08-22 10:20:06 -04:00
Jason Wen	5a8567e3e7	ci: chestnut prebuilt branches (#1935 ) * ci: chestnut prebuilt branches * fix * nope * big * try again * diff * malformed * auth * more	2026-08-22 03:41:48 -04:00
Jason Wen	07558166c8	ci: only check default model on dispatch	2026-08-22 00:32:35 -04:00
Jason Wen	ca9338812e	ci: prep for chestnut prebuilts	2026-08-22 00:16:10 -04:00
granolaFPV	4667241fe7	[TIZI/TICI] ui: dynamic path width color (#1926 ) * Fix UI path color and thickness based on lateral steering state (Issue #1441) * Fix UI path color and thickness based on lateral control engagement (Issue #1441) * Fix UI path width and color based on MADS lateral engagement (Issue #1441) * Fix UI path width and color based on MADS lateral engagement (Issue #1441) * move to ModelRendererSP * match torque bar * same behavior across the board * simplify --------- Co-authored-by: Brennan Browne <brennanbrowne@google.com> Co-authored-by: Jason Wen <haibin.wen3@gmail.com>	2026-08-21 20:51:43 -04:00
Shane Smiskol	084747c75d	Fix button label widths (#38680 ) * Revert "ui: fix text and icon overlap on button (#38628)" This reverts commit `d9c4120f89`. * simple * can do this * fix eliding * Revert "fix eliding" This reverts commit b271a350182ad87f9942d7363383ee8ec72d0e36. * clean up * clean up	2026-08-21 15:41:12 -07:00
Marceline Milligan	a49c260927	ui: show default big model name when eGPU present/active (#1930 ) * Name the big default model in the device UI Build on the default big-model metadata from #1929 and resolve the displayed model from cached capability and modeld runtime state. Keep model selection behavior unchanged. Assisted-by: GitHub Copilot Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> * Remove get_default_model_label * simplify --------- Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Co-authored-by: nayan <nayan8teen@gmail.com>	2026-08-21 13:26:52 -04:00
Jason Wen	5ad2bfdb75	ci: deprecate GitHub runners (#1933 )	2026-08-21 00:35:38 -04:00
Jason Wen	b742557d62	sunnylink: add model resolver (#1931 ) * models: add get_default_model resolver for sunnylink * models: move get_default_model to default_model.py	2026-08-20 21:56:57 -04:00
Nayan	5ecd05aedf	models: add big model to default model resolution (#1929 ) * device * sunnylink * lint * lfs? * Revert "lfs?" This reverts commit `bcdaec6b4c`. * update path * Scope the default big model down to the sunnylink schema * Drop the mock-only default model test * Move the default model resolver out to separate PR --------- Co-authored-by: Jason Wen <haibin.wen3@gmail.com>	2026-08-20 21:31:32 -04:00
Jason Wen	5ae100aa1d	models fetcher: bump big model to v21	2026-08-20 19:19:59 -04:00
Jason Wen	be76a88b80	ci override LFS fetch exclude for real ONNX file retrieval (#1928 ) ci: override lfs.fetchexclude so the model fetch pulls real ONNX files instead of pointers	2026-08-20 19:12:59 -04:00
James Vecellio-Grant	049d225d5a	ci: Dedicated Model Runner (#1922 ) * ci: Dedicated Model Runner * recurse * not needed * fix wrapper * whoops * bypass * modeld_v2: restore chestnut link check before big model build * modeld_v2: stage onnx to disk instead of shared memory * ci: clear unchunked onnx temps before model build * ci: stream the pkl hash instead of loading it into memory --------- Co-authored-by: Jason Wen <haibin.wen3@gmail.com>	2026-08-20 16:18:17 -04:00
github-actions[bot]	c783f2225a	[bot] Update Python packages (#1925 ) Update Python packages Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>	2026-08-20 14:44:15 -04:00
Robin Dittrich	53e13a7bc0	LagdToggle: fix inverted get_lat_delay branches (#1906 ) * helpers.py get_lat_delay fix * fix trailing whitespace * lint --------- Co-authored-by: Nayan <nayan8teen@gmail.com>	2026-08-19 21:36:37 -04:00
stef	555f48c5d2	params: remove livestream param on ignition (#38679 ) * remove livestream param on ignition * simplify process config	2026-08-19 14:21:59 -07:00
stef	dcf9d25bf3	webrtcd: more descriptive errors (#38677 ) more descriptive errors	2026-08-19 14:02:03 -07:00
stef	a8d1a280c6	webrtcd/athenad: we don't have to fail on no car params (#38678 ) we don't have to fail on no car params	2026-08-19 13:49:19 -07:00
stef	5b36799eec	webrtc: fix message handler race (#38675 ) open message handler early	2026-08-18 21:56:33 -07:00
Kumar	ba29a38507	Sync: `commaai/openpilot:master` → `sunnypilot/sunnypilot:master` (#1921 )	2026-08-18 21:16:47 -07:00
stef	20fdc3d824	webrtcd: cloud logging (#38674 ) * logging * remove test * get rid of redudant try except * fix logger context	2026-08-18 21:13:57 -07:00
Jason Wen	ed35a82129	Merge commit '8edce0da4492307df211c710af6c4ece1c4a218e' into sync-20260818	2026-08-18 22:10:51 -04:00
Shane Smiskol	7bd6cad821	Re-open agnos updater UI if crash (#38672 ) loop if crash	2026-08-18 19:06:48 -07:00
Shane Smiskol	8edce0da44	Clean up big model detection w/ helpers (#38671 ) use helpers	2026-08-18 18:40:54 -07:00
stef	3c90b66b65	webrtcd: bind to localhost (#38664 ) check content type and bind to localhost	2026-08-18 18:40:11 -07:00
Adeeb Shihadeh	08c83149b0	Pin SCons to 4.10.1 (#38669 )	2026-08-18 18:37:47 -07:00
Shane Smiskol	03711a13b0	Revert "chestnut: don't compile if big model is LFS pointer" (#38670 ) Revert "chestnut: don't compile if big model is LFS pointer (#38655)" This reverts commit `b8e14d85fb`.	2026-08-18 18:31:07 -07:00
Shane Smiskol	9f1709a7e1	Revert "lfs: exclude big driving model in master clones (#38626 )" This reverts commit `b7657f6553`.	2026-08-18 18:29:33 -07:00
Jason Wen	2b576c5fce	ci: tmp disable ui_report	2026-08-18 19:46:56 -04:00
Jason Wen	20ba774eaa	[TIZI/TICI] ui: fix missing model download status and rework status row (#1920 ) * [TIZI/TICI] ui: fix missing model download status and rework the status row * fix lint	2026-08-18 19:45:40 -04:00
James Vecellio-Grant	59833c500a	models: bump json version (#1919 )	2026-08-18 15:23:47 -07:00
Harald Schäfer	3d09a47a47	cruise planner: fix decel jerk from cruise (#38653 ) * cruise planner: fix decel jerk from cruise * dead variable	2026-08-18 14:15:20 -07:00
Jimmy	2f4744d39b	modeld_v2: fix features_buffer alignment for supercombo models (#1918 ) Co-authored-by: Quantizr (Jimmy) <jimmyfang@ucla.edu>	2026-08-18 13:47:52 -07:00
Jason Wen	6dd3457f4f	ci: refactor prebuilt workflow (#1916 ) * ci: fix prebuilt file copy for null-separated release_files.py output * ci: drop prebuilt symlinks the launch script recreates and gate the release on no submodules * ci: use the device-local scons cache and prune dead prebuilt config * ci: keep the scons cache in the runner workspace instead of the device's	2026-08-18 02:36:48 -04:00
Shane Smiskol	b7657f6553	lfs: exclude big driving model in master clones (#38626 ) * exclude big * lfs * Revert "lfs" This reverts commit b646d5fb50d2a5be1e6e73275f2ee302687e670f.	2026-08-17 21:54:29 -07:00
Shane Smiskol	b8e14d85fb	chestnut: don't compile if big model is LFS pointer (#38655 ) * use compiled helper for hardwared alert, source doesn't matter. scons skips compile if it's empty/lfs pointer * log it * rmnl * compile failed * out of scope * rmnl	2026-08-17 21:47:14 -07:00
Jason Wen	0b1ed0d047	Sync: `commaai/openpilot:master` → `sunnypilot/sunnypilot:master` (#1913 )	2026-08-17 01:43:11 -04:00
Jason Wen	9fb45b315a	Merge commit '053d9c446800df38aca42b69bb99197aefbea77b' into sync-20260816 # Conflicts: # README.md # docs/CARS.md # opendbc_repo # tinygrad_repo # tools/release/build_release.sh # tools/release/build_stripped.sh	2026-08-17 00:38:50 -04:00
James Vecellio-Grant	94a32493e3	modeld_v2: chestnut support (#1894 ) * modeld_v2: Support eGpu * bump tg * egpu * no pkls please * god no onnx either * fix test * done in build model now * lint * rip * egpu ready build all split * manual seed , reuse memory buffers across runs * dont download big when we dont have big lol * whoops * no i and x * cd * who put those there. ?? * reduce flakiness by using artifact-name from build-model to regex, speed up pub b y checking the name before trying to clone and publish again * try hf as a trusted publisher :) * mf its a dataaset. i knew that * fucking validation wants raw to fetch and full to push. grr * smh * dude i am missing so much * pkl name * move build all to hf * tests: migrate sunnypilot tests to unittest and remove pytest * red diff mf * im scared , this may be a bad idea lol * fetch latest commit. * transition to requests * models: use requests instead of aiohttp * tici * fix * gpu fixes from upstream * lint * bump * needed to say * old * how?? * epgu flag reduce * this made me cry * support monolith still * precache warp in legacy * Move jsons to param for sunnylink --------- Co-authored-by: Jason Wen <haibin.wen3@gmail.com>	2026-08-16 21:40:16 -04:00
commaci-public	053d9c4468	[bot] Update Python packages (#38650 ) * Update Python packages * revert that for now * ignore dashcam only --------- Co-authored-by: Vehicle Researcher <user@comma.ai> Co-authored-by: Adeeb Shihadeh <adeebshihadeh@gmail.com>	2026-08-16 18:38:12 -07:00
Adeeb Shihadeh	85d364d4de	loggerd: fix ~0.5s startup logging delay (#38649 )	2026-08-16 18:24:01 -07:00
Adeeb Shihadeh	dfbe0ee7c1	jenkins: set big cache dir (#38648 )	2026-08-16 18:23:37 -07:00
Adeeb Shihadeh	03e6c81821	test_onroad: more precise frame ID check (#38647 )	2026-08-16 16:10:35 -07:00
Adeeb Shihadeh	047be14df9	release: speedup builds (#38644 )	2026-08-16 15:25:19 -07:00
stef	351701689f	bump teleop (#38645 )	2026-08-16 14:22:04 -07:00
Adeeb Shihadeh	ec86732af8	ui: fix false positive openpilot unavailable on startup (#38643 )	2026-08-16 13:11:50 -07:00
Adeeb Shihadeh	0f40ca1d88	pigeond: continuously try to get AGPS (#38642 )	2026-08-16 12:50:16 -07:00
Adeeb Shihadeh	97542f838f	check the pkl too	2026-08-15 16:17:21 -07:00
stef	dcbd66ad81	ui: big model failed alert (#38629 ) * big model failed + supply voltage check * remove ltssm and supply voltage stuff for seperate PR	2026-08-15 16:05:02 -07:00
Adeeb Shihadeh	391132465d	release: chestnut build scripts (#38638 ) * release: chestnut build scripts * simplify * only max * no new script * release: exclude local virtualenv	2026-08-15 16:01:42 -07:00
Adeeb Shihadeh	a996f8ef90	chestnut gets its own table	2026-08-15 15:59:20 -07:00
Adeeb Shihadeh	6ad3532113	Document chestnut branches	2026-08-15 15:54:19 -07:00
Adeeb Shihadeh	48b7f171a7	release: speed up pushes by 9x (#38640 )	2026-08-15 15:33:43 -07:00
Adeeb Shihadeh	5e3d17c72c	chestnut: fix flashing on old FW (#38639 )	2026-08-15 15:31:19 -07:00
Adeeb Shihadeh	fb555fdefd	big model doesn't need big build times (#38637 ) * big model doesn't need big build times * revert htat	2026-08-15 14:28:45 -07:00
Adeeb Shihadeh	28560d6cf1	show an offroad alert to switch to a chestnut branch (#38636 ) * show an offroad alert to switch to a chestnut branch * add to keys	2026-08-15 13:18:02 -07:00
Adeeb Shihadeh	748c725e3e	soundd: more robust test (#38635 )	2026-08-15 12:39:26 -07:00
Adeeb Shihadeh	3447ec1789	selfdrived: excessive actuation check is not for notCars (#38634 )	2026-08-15 12:28:38 -07:00
Adeeb Shihadeh	76b69af59a	remove offroad OS update alert (#38633 )	2026-08-15 12:08:38 -07:00
Adeeb Shihadeh	d9c4120f89	ui: fix text and icon overlap on button (#38628 )	2026-08-15 12:03:34 -07:00
stef	df4566ef2f	ui: small software ui fixes (#38630 ) add icon and scroller for branch name	2026-08-14 21:01:22 -07:00
Toby Penner	516ec1e682	Revert big RL model (#38627 )	2026-08-14 13:45:22 -07:00
Adeeb Shihadeh	c988e78893	jenkins fixups (#38532 )	2026-08-13 22:46:13 -07:00
Shane Smiskol	bdc8e4b02c	deprecate long kp (#38614 ) * deprecate long kp * bump	2026-08-13 22:25:35 -07:00