live ui

Merge branch 'master' into ccnc-port
2026-08-26 11:43:43 +08:00 · 2026-08-23 11:38:14 -04:00 · 2026-08-23 11:05:40 -04:00 · 2026-08-22 13:19:05 -04:00 · 2026-08-21 17:12:13 -04:00 · 2026-08-21 17:09:31 -04:00
34 changed files with 1896 additions and 1171 deletions
@@ -0,0 +1,83 @@
+name: Build default big model
+
+on:
+  workflow_dispatch:
+
+env:
+  HF_REPO: sunnypilot/sunnypilot_models_v1
+  HF_DEFAULTS_PATH: models/defaults/big
+
+jobs:
+  resolve_name:
+    runs-on: ubuntu-24.04
+    outputs:
+      model_name: ${{ steps.name.outputs.model_name }}
+      onnx_ref: ${{ steps.name.outputs.onnx_ref }}
+    steps:
+      - uses: actions/checkout@v4
+      - id: name
+        run: |
+          NAME=$(PYTHONPATH=${{ github.workspace }} python3 -c "from openpilot.sunnypilot.models.model_name import DEFAULT_BIG_MODEL; print(DEFAULT_BIG_MODEL)")
+          ONNX_REF=$(git log -1 --format='%H' -- openpilot/selfdrive/modeld/models/big_driving_supercombo.onnx)
+          echo "model_name=${NAME}" >> $GITHUB_OUTPUT
+          echo "onnx_ref=$ONNX_REF" >> $GITHUB_OUTPUT
+
+  build_model:
+    needs: resolve_name
+    uses: ./.github/workflows/sunnypilot-build-model.yaml
+    with:
+      upstream_branch: ${{ needs.resolve_name.outputs.onnx_ref }}
+      custom_name: ${{ needs.resolve_name.outputs.model_name }}
+      target_hardware: usbgpu
+    secrets: inherit
+
+  upload_defaults:
+    needs: [ resolve_name, build_model ]
+    runs-on: ubuntu-24.04
+    permissions:
+      id-token: write
+      contents: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - run: git lfs pull -I "openpilot/selfdrive/modeld/models/big_driving_supercombo.onnx"
+
+      - name: Install huggingface_hub
+        run: pip install --upgrade "huggingface_hub>=0.22.0"
+
+      - name: Download artifact name
+        uses: actions/download-artifact@v4
+        with:
+          name: artifact-name-${{ needs.resolve_name.outputs.model_name }}
+          path: artifact_name
+
+      - name: Read artifact name
+        id: artifact
+        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.artifact.outputs.artifact_name }}
+          path: output
+
+      - name: Upload to HF and update default_models.json
+        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 "${{ env.HF_DEFAULTS_PATH }}" \
+            --artifact-name "$ARTIFACT_NAME" \
+            --model-dir output \
+            --onnx-path "openpilot/selfdrive/modeld/models/big_driving_supercombo.onnx" \
+            --onnx-ref "${{ needs.resolve_name.outputs.onnx_ref }}" \
+            --model-name "${{ needs.resolve_name.outputs.model_name }}" \
+            --tinygrad-ref "$(python3 openpilot/sunnypilot/models/tinygrad_ref.py)" \
+            --run-number "${{ github.run_number }}"
@@ -1,501 +0,0 @@
-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
-
@@ -1,66 +0,0 @@
-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"
@@ -188,7 +188,7 @@ jobs:
          if [ "${{ inputs.target_hardware }}" == "usbgpu" ]; then
            echo "USBGPU build"
            export USBGPU=1
-            TG_FLAGS="DEBUG=1 DEV=USB+AMD:LLVM WARP_DEV=QCOM FLOAT16=1 JIT_BATCH_SIZE=0 GMMU=0 TC_OPT=2"
+            TG_FLAGS="DEBUG=2 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"
@@ -39,8 +39,6 @@ jobs:
      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: |
@@ -98,8 +96,6 @@ 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:
@@ -123,7 +119,6 @@ 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 }}
@@ -170,7 +165,7 @@ jobs:
          scons -j1 cache_dir="$SCONS_CACHE" --minimal \
            openpilot/selfdrive/locationd openpilot/sunnypilot/selfdrive/locationd
          echo "Building rest of sunnypilot"
-          SKIP_TINYGRAD_COMPILE=1 /usr/bin/time -v scons -j$(nproc) cache_dir="$SCONS_CACHE" --minimal
+          /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}
@@ -219,174 +214,59 @@ jobs:
    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
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ github.head_ref || github.ref_name }}
+
+      - run: git lfs pull -I "openpilot/selfdrive/modeld/models/big_driving_supercombo.onnx"
+
+      - name: Check HF defaults and build if needed
        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"
+          ACTUAL_ONNX_HASH=$(sha256sum "openpilot/selfdrive/modeld/models/big_driving_supercombo.onnx" | cut -d' ' -f1)
+          echo "Repo ONNX hash: $ACTUAL_ONNX_HASH"
+          echo "onnx_sha256=$ACTUAL_ONNX_HASH" >> $GITHUB_OUTPUT

          JSON_URL="https://huggingface.co/datasets/${HF_REPO}/resolve/main/${HF_DEFAULTS_PATH}/default_models.json"

-          check_defaults() {
+          check_hash() {
            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)
+            BUNDLE=$(echo "$DEFAULTS" | jq --arg hash "$ACTUAL_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
+          if check_hash; then
+            echo "HF defaults match repo ONNX"
+          else
+            echo "No matching model on HF — triggering build"
+            gh workflow run build-default-big-model.yaml --ref "${{ github.head_ref || github.ref_name }}"

-          echo "No matching model on HF — dispatching build"
-          gh workflow run build-default-models.yaml --ref "$REF" -f target=big
+            echo "Waiting for build to start..."
+            sleep 120

-          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
+            RUN_ID=$(gh run list --workflow=build-default-big-model.yaml --branch="${{ github.head_ref || github.ref_name }}" --limit=1 --json databaseId --jq '.[0].databaseId')
+            if [ -z "$RUN_ID" ] || [ "$RUN_ID" = "null" ]; then
+              echo "::error::Failed to find build-default-big-model run"
+              exit 1
            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 }}
+            echo "Waiting for run $RUN_ID..."
+            gh run watch "$RUN_ID"

-      - 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
+            CONCLUSION=$(gh run view "$RUN_ID" --json conclusion --jq '.conclusion')
+            if [ "$CONCLUSION" != "success" ]; then
+              echo "::error::build-default-big-model failed: $CONCLUSION"
+              exit 1
            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
+            if ! check_hash; then
+              echo "::error::HF defaults still don't match after build"
+              exit 1
            fi
-            echo "Poll $i/60: not yet available"
-          done
-
-          echo "::error::DM model not available on HF after 30 minutes"
-          exit 1
+          fi
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

@@ -398,24 +278,23 @@ jobs:

  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() &&
      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 ]
+    needs: [ build, prepare_strategy, prepare_chestnut ]
    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
@@ -427,16 +306,43 @@ 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: Prepare chestnut output
+        if: ${{ needs.prepare_chestnut.result == 'success' }}
+        run: |
+          mkdir -p "${{ github.workspace }}/chestnut_output"
+          tar xzf prebuilt.tar.gz -C "${{ github.workspace }}/chestnut_output"
+
+      - name: Download big model chunks from HF
+        if: ${{ needs.prepare_chestnut.result == 'success' }}
+        env:
+          HF_REPO: sunnypilot/sunnypilot_models_v1
+          HF_DEFAULTS_PATH: models/defaults/big
+        run: |
+          ONNX_HASH="${{ needs.prepare_chestnut.outputs.onnx_sha256 }}"
+          JSON_URL="https://huggingface.co/datasets/${HF_REPO}/resolve/main/${HF_DEFAULTS_PATH}/default_models.json"
+          DEFAULTS=$(curl -fsSL "$JSON_URL")
+          BUNDLE=$(echo "$DEFAULTS" | jq --arg hash "$ONNX_HASH" '.bundles[] | select(.onnx_sha256 == $hash)')
+
+          mkdir -p big_model_chunks
+          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')
+
+          CANONICAL="big_driving_tinygrad.pkl"
+          echo "$ARTIFACT" | jq -r '.chunks[].file_name' | while read CHUNK_NAME; do
+            CHUNK_IDX=$(echo "$CHUNK_NAME" | grep -oP 'chunk\K[0-9]+of[0-9]+')
+            CANONICAL_CHUNK="${CANONICAL}.chunk${CHUNK_IDX}"
+            ENCODED_URL=$(python3 -c "import urllib.parse; print(urllib.parse.quote('${BASE_URL}/${CHUNK_NAME}', safe=':/'))")
+            echo "Downloading $CHUNK_NAME -> $CANONICAL_CHUNK"
+            curl -fsSL -o "big_model_chunks/${CANONICAL_CHUNK}" "$ENCODED_URL"
+          done
+
+          echo "$NUM_CHUNKS" > "big_model_chunks/${CANONICAL}.chunkmanifest"
+
+      - name: Inject big model into chestnut
+        if: ${{ needs.prepare_chestnut.result == 'success' }}
+        run: |
+          cp big_model_chunks/* "${{ github.workspace }}/chestnut_output/openpilot/selfdrive/modeld/models/"

      - name: Configure Git
        run: |
@@ -458,6 +364,22 @@ jobs:
            "https://x-access-token:${{github.token}}@github.com/sunnypilot/sunnypilot.git" \
            "${{ needs.prepare_strategy.outputs.extra_version_identifier }}"

+      - name: Publish chestnut branch
+        if: ${{ needs.prepare_chestnut.result == 'success' }}
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          CHESTNUT_BRANCH="${{ needs.prepare_strategy.outputs.new_branch }}-chestnut"
+          CHESTNUT_DIR="${{ github.workspace }}/chestnut_output"
+
+          ${{ env.CI_DIR }}/publish.sh \
+            "${{ github.workspace }}" \
+            "$CHESTNUT_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 }}"
+
      - 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: |
@@ -465,77 +387,12 @@ jobs:
            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'
@@ -543,8 +400,6 @@ 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
@@ -24,9 +24,7 @@ function agnos_init {
    if $AGNOS_PY --verify $MANIFEST; then
      sudo reboot
    fi
-    while true; do
-      $DIR/openpilot/common/hardware/comma/updater $AGNOS_PY $MANIFEST
-    done
+    $DIR/openpilot/common/hardware/comma/updater $AGNOS_PY $MANIFEST
  fi
 }

@@ -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 | CLEAR_ON_IGNITION_ON, BOOL}},
+    {"IsLiveStreaming", {CLEAR_ON_MANAGER_START, BOOL}},
    {"IsMetric", {PERSISTENT | BACKUP, BOOL}},
    {"IsOffroad", {CLEAR_ON_MANAGER_START, BOOL}},
    {"IsRhdDetected", {PERSISTENT, BOOL}},
@@ -196,8 +196,6 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
    // Model Manager params
    {"ModelManager_ActiveBundle", {PERSISTENT, JSON}},
    {"ModelManager_ActiveJson", {CLEAR_ON_MANAGER_START, STRING}},
-    {"ModelManager_PrevBundle", {PERSISTENT, JSON}},
-    {"ModelManager_PrevBundle_USBGPU", {PERSISTENT, JSON}},
    {"ModelManager_ClearCache", {CLEAR_ON_MANAGER_START, BOOL}},
    {"ModelManager_DownloadIndex", {CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION, INT}},
    {"ModelManager_Favs", {PERSISTENT | BACKUP, STRING}},
@@ -73,45 +73,44 @@ compile_modeld_script = [
 model_w, model_h = MEDMODEL_INPUT_SIZE
 frame_skip = ModelConstants.MODEL_RUN_FREQ // ModelConstants.MODEL_CONTEXT_FREQ

-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)
+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
@@ -143,5 +142,4 @@ def tg_compile(flags, model_name):
     Action(do_chunk, "  [CHUNK] $TARGET")],
  )

-if not os.getenv('SKIP_TINYGRAD_COMPILE'):
-  tg_compile(tg_flags, 'dmonitoring_model')
+tg_compile(tg_flags, 'dmonitoring_model')
@@ -168,16 +168,9 @@ 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
-    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)
+    rl.draw_texture_ex(button_img, rl.Vector2(HOME_BTN.x, HOME_BTN.y), 0.0, 1.0, tint)

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

    # ***** Center-aligned bottom section icons *****
    self._experimental_icon.set_visible(ui_state.experimental_mode)
-    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._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))

@@ -149,15 +149,11 @@ 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 _title_width_hint(self) -> int:
-    # A value moves the title to the top, where it shares space with the icon
+  def _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
@@ -232,14 +228,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._title_width_hint(),
+    label_rect = rl.Rectangle(label_x, btn_y + self.LABEL_VERTICAL_PADDING, self._width_hint(),
                              self._rect.height - self.LABEL_VERTICAL_PADDING * 2)
    self._label.render(label_rect)

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

    # ICON -------------------------------------------------------------------
@@ -316,6 +312,9 @@ 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)
@@ -364,6 +363,9 @@ 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

@@ -115,12 +115,8 @@ class ModelsLayout(Widget):
  def calculate_cache_size():
    cache_size = 0.0
    if os.path.exists(CUSTOM_MODEL_PATH):
-      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)
+      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

  def _clear_cache(self):
    def _callback(response):
@@ -4,14 +4,11 @@ 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


@@ -21,9 +18,6 @@ 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:
@@ -59,10 +53,6 @@ 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"):
@@ -88,29 +78,6 @@ 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,14 +4,8 @@ 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


@@ -19,35 +13,3 @@ 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,7 +7,6 @@ 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


@@ -22,8 +21,6 @@ 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:
@@ -43,7 +43,6 @@ 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
@@ -152,7 +151,6 @@ class UIStateSP:

    self._enforce_constraints()
    self.active_bundle = self.params.get("ModelManager_ActiveBundle")
-    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)
@@ -112,15 +112,6 @@ 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)
@@ -7,7 +7,6 @@ See the LICENSE.md file in the root directory for more details.
 """

 import argparse
-import math
 import os
 import tempfile
 import time
@@ -67,15 +66,14 @@ 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

@@ -119,9 +117,8 @@ def generate_queues_and_npy(input_shapes: dict, frame_skip: int, device: str = D
  }

  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),
+    queues['feat_q'] = Tensor(np.zeros((feat_q_len, 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() if key in ('tfm', 'big_tfm')})
@@ -186,14 +183,14 @@ def make_run_policy(vision_runner, policy_runners: list, features_slice: slice,
    warped_dev = warped.to(Device.DEFAULT)
    Tensor.realize(packed_npy_inputs_dev, warped_dev)

-    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)
+    img = shift_and_sample(img_q, warped_dev[0:1], sample_skip_fn).realize()
+    big_img = shift_and_sample(big_img_q, warped_dev[1:2], sample_skip_fn).realize()

    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)
+    desire_buf = shift_and_sample(desire_q, desire_dev.reshape(1, 1, -1), sample_desire_fn).realize()

    inputs = {desire_key: desire_buf}
    for key, tensor_val in unpacked_dict.items():
@@ -202,7 +199,7 @@ def make_run_policy(vision_runner, policy_runners: list, features_slice: slice,

    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).reshape(input_shapes['features_buffer'])
+      inputs['features_buffer'] = shift_and_sample(feat_q, prev_feat_dev.reshape(1, 1, -1), sample_skip_fn).realize()

    if vision_runner:
      vision_out_cast = next(iter(vision_runner({road_key: img, wide_key: big_img}).values())).cast('float32').realize()
@@ -214,7 +211,7 @@ def make_run_policy(vision_runner, policy_runners: list, features_slice: slice,

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

    policy_out = next(iter(policy_runners[0](inputs).values())).cast('float32').realize()
    if 'features_buffer' not in inputs and features_slice is not None:
@@ -195,85 +195,3 @@ class TestReadFileChunkedToDisk(OpenpilotTestCase):

      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)
-
-
@@ -9,7 +9,7 @@ from openpilot.sunnypilot.models.model_name import DEFAULT_MODEL, DEFAULT_BIG_MO


 def get_default_model() -> str:
-  show_big_model = (ui_state.usbgpu
+  show_big_model = (ui_state.usbgpu and ui_state.usbgpu_compiled
                    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
@@ -13,6 +13,8 @@ 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.selfdrive.modeld.helpers import usbgpu_present
+
 from openpilot.cereal import custom


@@ -138,8 +140,8 @@ 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_v21.json"
-  MODEL_URL_USBGPU = "https://raw.githubusercontent.com/sunnypilot/sunnypilot-models/refs/heads/gh-pages/docs/driving_models_usbgpu_v22.json"
+  MODEL_URL = "https://raw.githubusercontent.com/sunnypilot/sunnypilot-models/refs/heads/gh-pages/docs/driving_models_v20.json"
+  MODEL_URL_USBGPU = "https://raw.githubusercontent.com/sunnypilot/sunnypilot-models/refs/heads/gh-pages/docs/driving_models_usbgpu_v21.json"

  def __init__(self, params: Params):
    self.params = params
@@ -147,10 +149,11 @@ class ModelFetcher:
    self._is_usbgpu: bool | None = None
    self.model_cache = ModelCache(params)
    self.model_url = self.MODEL_URL
+    self._update_model_source()

-  def _update_model_source(self, chestnut_present: bool) -> None:
-    """Updates what json to use based on chestnut hardware presence via deviceState"""
-    is_usbgpu = chestnut_present
+  def _update_model_source(self) -> None:
+    """Updates what json to use based on usbgpu availability"""
+    is_usbgpu = usbgpu_present()
    if is_usbgpu != self._is_usbgpu:
      self._is_usbgpu = is_usbgpu
      self.model_cache = ModelCache(self.params, suffix="_USBGPU" if is_usbgpu else "")
@@ -188,9 +191,9 @@ class ModelFetcher:

    return None

-  def get_available_bundles(self, chestnut_present: bool = False) -> list[custom.ModelManagerSP.ModelBundle]:
+  def get_available_bundles(self) -> list[custom.ModelManagerSP.ModelBundle]:
    """Gets the list of available models, with smart cache handling"""
-    self._update_model_source(chestnut_present)
+    self._update_model_source()
    cached_data, is_expired = self.model_cache.get()

    if cached_data and not is_expired:
@@ -207,12 +210,10 @@ class ModelFetcher:
    cloudlog.warning("Failed to fetch fresh data. Using expired cache as fallback")
    return self.model_parser.parse_models(cached_data)

-
 if __name__ == "__main__":
-  from openpilot.selfdrive.modeld.helpers import usbgpu_present
  params = Params()
  model_fetcher = ModelFetcher(params)
-  bundles = model_fetcher.get_available_bundles(chestnut_present=usbgpu_present())
+  bundles = model_fetcher.get_available_bundles()
  for bundle in bundles:
    for model in bundle.models:
      model_overrides = {override.key: override.value for override in bundle.overrides}
@@ -18,11 +18,12 @@ from openpilot.sunnypilot.models.constants import Meta, MetaSimPose, MetaTombRai
 from openpilot.common.hardware.hw import Paths

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

 CUSTOM_MODEL_PATH = Paths.model_root()
 METADATA_PATH = Path(__file__).parent / '../models/supercombo_metadata.pkl'
 ModelManager = custom.ModelManagerSP
+_LAST_VALIDATED_RAW = None


 def _compute_hash(file_path: str) -> str | None:
@@ -85,11 +86,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 active_bundle.ref and bundle.ref:
+      if getattr(active_bundle, 'ref', None) and getattr(bundle, 'ref', None):
        if active_bundle.ref == bundle.ref:
          matching_bundle = bundle
          break
-      elif active_bundle.internalName == bundle.internalName:
+      elif getattr(active_bundle, 'internalName', None) == getattr(bundle, 'internalName', None):
        matching_bundle = bundle
        break

@@ -97,42 +98,36 @@ def _bundle_needs_reset(active_bundle: custom.ModelManagerSP.ModelBundle, availa
      return True
    if active_bundle.minimumSelectorVersion != matching_bundle.minimumSelectorVersion:
      return True
-    if active_bundle.runner.raw != matching_bundle.runner.raw:
-      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 set(_bundle_artifacts(active_bundle)) != set(_bundle_artifacts(matching_bundle)):
      return True

-  # missing files trigger re-download, not selection reset
-  return False
+  return not _bundle_is_valid_locally(active_bundle)


-def _prev_bundle_key(is_usbgpu: bool) -> str:
-  return "ModelManager_PrevBundle_USBGPU" if is_usbgpu else "ModelManager_PrevBundle"
+def validate_active_bundle(params: Params, available_bundles: list[custom.ModelManagerSP.ModelBundle] | None = None) -> None:
+  global _LAST_VALIDATED_RAW

-
-def validate_active_bundle(params: Params, available_bundles: list[custom.ModelManagerSP.ModelBundle] | None = None,
-                           is_usbgpu: bool = False) -> None:
  raw_bundle = params.get("ModelManager_ActiveBundle")
  if not raw_bundle:
-    prev = params.get(_prev_bundle_key(is_usbgpu))
-    if prev and (prev_bundle := get_active_bundle(params, raw_bundle_dict=prev)) is not None:
-      if not _bundle_needs_reset(prev_bundle, available_bundles):
-        params.put("ModelManager_ActiveBundle", prev, block=True)
+    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.put(_prev_bundle_key(not is_usbgpu), raw_bundle, block=True)
-
-    prev = params.get(_prev_bundle_key(is_usbgpu))
-    if prev and (prev_bundle := get_active_bundle(params, raw_bundle_dict=prev)) is not None:
-      if not _bundle_needs_reset(prev_bundle, available_bundles):
-        params.put("ModelManager_ActiveBundle", prev, block=True)
-        return
-
    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":
@@ -30,7 +30,6 @@ class ModelManagerSP:
    self.params = Params()
    self.model_fetcher = ModelFetcher(self.params)
    self.pm = messaging.PubMaster(["modelManagerSP"])
-    self.sm = messaging.SubMaster(["deviceState"])
    self.available_models: list[custom.ModelManagerSP.ModelBundle] = []
    self.selected_bundle: custom.ModelManagerSP.ModelBundle = None
    self.active_bundle: custom.ModelManagerSP.ModelBundle = get_active_bundle(self.params)
@@ -257,21 +256,14 @@ class ModelManagerSP:
    """Main entry point for downloading a model bundle"""
    asyncio.run(self._download_bundle(model_bundle, destination_path))

-  BOOT_SETTLE_TICKS = 10  # seconds at 1 Hz before validating active bundle
-
  def main_thread(self) -> None:
    """Main thread for model management"""
    rk = Ratekeeper(1, print_delay_threshold=None)
-    boot_ticks = 0

    while True:
      try:
-        self.sm.update(0)
-        chestnut_present = self.sm['deviceState'].chestnutPresent
-        self.available_models = self.model_fetcher.get_available_bundles(chestnut_present)
-        if boot_ticks >= self.BOOT_SETTLE_TICKS:
-          validate_active_bundle(self.params, self.available_models, is_usbgpu=chestnut_present)
-        boot_ticks = min(boot_ticks + 1, self.BOOT_SETTLE_TICKS)
+        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)

        if (index_to_download := self.params.get("ModelManager_DownloadIndex")) is not None:
@@ -28,6 +28,7 @@ from websocket import (ABNF, WebSocket, WebSocketException, WebSocketTimeoutExce
                       create_connection, WebSocketConnectionClosedException)

 import openpilot.cereal.messaging as messaging
+from openpilot.selfdrive.modeld.helpers import usbgpu_present, usbgpu_compiled
 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
@@ -181,9 +182,10 @@ def getParamsMetadata() -> str:
    schema = generate_schema()
    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")
+    # mirrors get_default_model() — ui_state unavailable in sunnylinkd process
+    show_big = (usbgpu_present() and usbgpu_compiled()
+                and (params.get_bool("UsbGpuActive") or params.get_bool("UsbGpuLoading") or params.get_bool("IsOffroad")))
+    schema["default_model"] = DEFAULT_BIG_MODEL if show_big else DEFAULT_MODEL
    raw = json.dumps(schema, separators=(",", ":")).encode("utf-8")
    return base64.b64encode(gzip.compress(raw)).decode("utf-8")
  except Exception:
@@ -828,22 +828,20 @@ 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
-    try:
-      wait_for_webrtcd()
-    except TimeoutError:
-      cloudlog.event("athena.startStream.webrtcd_offroad_start_timeout", error=True)
-      raise
+    wait_for_webrtcd()

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

@@ -106,12 +106,15 @@ 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_(livestream, notcar)),
+  NativeProcess("stream_encoderd", "openpilot/system/loggerd", ["./encoderd", "--stream"], or_(and_(livestream, not_(iscar)), notcar)),
  PythonProcess("logmessaged", "openpilot.system.logmessaged", always_run),

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

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

  # sunnylink <3
@@ -8,26 +8,12 @@ from collections.abc import Callable

 import pyray as rl

-from openpilot.system.ui.lib.application import gui_app, FontWeight
+from openpilot.system.ui.lib.application import 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.label import 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):
  def get_width_hint(self):
@@ -35,12 +21,14 @@ class NoElideButtonAction(ButtonActionSP):


 class ScrollingButtonAction(ButtonActionSP):
+  """ButtonActionSP whose value scrolls instead of eliding when it doesn't fit."""
+
  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)
+    self._value_label = UnifiedLabel("", 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, ""):
@@ -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("device took too long to respond.") from e
+    raise Exception("webrtc took too long to respond.") from e
  except requests.ConnectionError as e:
-    raise Exception("turn car ignition off to use livestreaming.") from e
+    raise Exception("webrtc server on device is not running.") 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("livestreaming service did not initialize in time.")
+  raise TimeoutError("webrtcd did not initialize in time.")
@@ -21,16 +21,10 @@ 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:
@@ -259,7 +253,7 @@ class StreamSession:
    self._cleanup_lock = asyncio.Lock()
    self._cleanup_done = False
    self.logger = logging.getLogger("webrtcd")
-    cloudlog.warning(
+    self.logger.info(
      "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,
    )
@@ -335,12 +329,9 @@ 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:
@@ -350,18 +341,14 @@ class StreamSession:
      if self.bitrate_controller is not None:
        self.bitrate_controller.start()

-      with cloudlog.ctx(session_id=self.identifier):
-        cloudlog.warning("webrtcd.session.connected")
+      self.logger.info("Stream session (%s) connected", self.identifier)
      if self.is_body:
        await self.run_body_session()
      else:
        await self.run_normal_session()
-      with cloudlog.ctx(session_id=self.identifier):
-        cloudlog.warning("webrtcd.session.ended")
+      self.logger.info("Stream session (%s) ended", self.identifier)
    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()

@@ -435,25 +422,15 @@ async def handle_get_stream(state: ServerState, raw_body: bytes, content_type: s
    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()

@@ -0,0 +1,198 @@
+# Live UI
+
+View a comma device's live sunnypilot UI over Wi-Fi. Replay, ADB, and USB are
+not used.
+
+| Mode | Output | Device bridge |
+| --- | --- | --- |
+| Mimic (default) | Local UI rendered from live device data | Required |
+| Exact (`--exact`) | Actual pixels shown on the device | Not required |
+
+Mimic mode does not directly require SSH, but the device bridge must be started
+somehow; the examples use SSH. Exact mode, touch control, and `--stop-exact`
+require key-based SSH access.
+
+Choose **mimic** when developing or inspecting the local UI with live device
+data. Choose **exact** when you need to see or control what is physically shown
+on the device.
+
+## Before the first run
+
+1. Replace `192.168.43.1` in the examples if your device uses a different IP.
+2. Connect the computer and device to networks that can reach each other.
+3. Run local commands from the sunnypilot repository root.
+4. For exact mode, verify non-interactive SSH access:
+
+   ```bash
+   ssh -o BatchMode=yes comma@192.168.43.1 true
+   ```
+
+The script automatically switches to the repository's `.venv` when present.
+
+## Mimic UI
+
+Mimic mode receives live cereal messages and encoded road-camera frames, then
+renders a new UI instance on the computer. It resembles the device UI but is
+not a pixel-for-pixel screen mirror.
+
+Build the messaging bridge once on the computer:
+
+```bash
+scons -u cereal/messaging/bridge
+```
+
+Use two terminals. In the first, start the bridge on the device and leave it
+running:
+
+```bash
+ssh comma@192.168.43.1
+./cereal/messaging/bridge
+```
+
+In the second terminal, start the local UI:
+
+```bash
+BIG=0 ./openpilot/tools/live/ui.py 192.168.43.1
+```
+
+`BIG` is inherited from your environment and is not forced by the tool.
+
+## Exact device screen
+
+Exact mode streams the actual device display. It does not need either
+messaging bridge:
+
+```bash
+./openpilot/tools/live/ui.py --exact 192.168.43.1
+```
+
+The tool runs a temporary capture helper through SSH using AGNOS's existing
+DRM broker. It does not install software or modify openpilot source on the
+device. Exact mode requires a compatible AGNOS DRM writeback connector and
+captures the post-processed display output when that mode is available.
+
+Exact mode is experimental. Some Qualcomm/AGNOS combinations can time out
+during DRM writeback, freezing both the mirrored window and physical device UI.
+This can happen without `--control`; mouse, keyboard, and shortcut forwarding
+are not required to trigger the capture failure.
+The tool stops its verified helper when capture stalls, but the kernel display
+state may require a full device reboot before exact mode can be tried again.
+Restarting openpilot alone does not reset the display driver.
+
+Set the capture rate from 1 to 60 FPS; the default is 15:
+
+```bash
+./openpilot/tools/live/ui.py --exact --exact-fps 30 192.168.43.1
+./openpilot/tools/live/ui.py --exact --exact-fps 60 192.168.43.1
+```
+
+Start with 15 or 30 FPS. Higher rates use more device CPU and Wi-Fi bandwidth.
+
+Use `SCALE` to resize the local window:
+
+```bash
+SCALE=2 ./openpilot/tools/live/ui.py --exact 192.168.43.1
+```
+
+Only one exact session can run at a time.
+
+## Touch control
+
+Touch control is available only with exact mode:
+
+```bash
+./openpilot/tools/live/ui.py --exact --control 192.168.43.1
+```
+
+Left-clicks and drags are forwarded to the physical touchscreen over SSH.
+These inputs affect the real device, including settings and confirmation
+buttons.
+
+When the device's on-screen keyboard is visible, type with the computer
+keyboard. Letters, numbers, symbols, Space, Backspace, and Return are converted
+to taps on the device keyboard.
+
+Exact control also provides simulator-style shortcuts:
+
+| Shortcut | Action |
+| --- | --- |
+| `↓` | Go back with a swipe-down gesture |
+| `←` | Swipe right |
+| `→` | Swipe left |
+| `Command`+`K` (macOS) or `Ctrl`+`K` (Linux/Windows) | Force keyboard forwarding on, or return to automatic detection |
+
+Hold an arrow key to repeat its gesture until the key is released.
+
+Escape has no action and does not close the program; use `Ctrl-C` or the window
+close button to exit. `Command`+`K`/`Ctrl`+`K` enables manual keyboard forwarding
+regardless of exact-screen resolution; touch locations scale to the captured
+screen. Automatic keyboard detection targets the 536x240 mici UI. Turn forced
+forwarding back off after typing so ordinary keys cannot produce unintended
+taps on incompatible keyboard layouts.
+
+## Connection status
+
+Status appears in the window title and terminal:
+
+- `connected`: mimic telemetry and camera frames, or exact screen frames, are
+  arriving.
+- `keyboard`: exact-mode keyboard forwarding is currently active. This appears
+  only while the device keyboard is detected or forwarding is forced on.
+- `no camera`: mimic telemetry is arriving, but road-camera frames are not.
+- `disconnected`: expected mimic-mode live data has stopped.
+
+At the default capture rate, exact mode reports a stopped screen stream in
+about one second. Lower `--exact-fps` values allow more time between frames.
+If Qualcomm DRM writeback stalls, exact mode immediately stops its verified
+device helper and exits to avoid leaving the physical display frozen.
+
+## Stop and clean up
+
+Press `Ctrl-C` or close the window. If an exact helper remains orphaned, run:
+
+```bash
+./openpilot/tools/live/ui.py --stop-exact 192.168.43.1
+```
+
+`--kill-exact` is an alias. Stop exact mode before restarting or rebuilding
+openpilot to avoid blocking the physical UI during a display transition.
+
+## Options
+
+```text
+--exact                 Show the actual device screen
+--control               Forward mouse and keyboard input; requires --exact
+--exact-fps FPS         Exact capture rate, 1-60 (default: 15)
+--stop-exact            Stop orphaned exact helpers
+--kill-exact            Alias for --stop-exact
+--ip ADDRESS            Alternative to the positional address
+```
+
+See the complete command help:
+
+```bash
+./openpilot/tools/live/ui.py --help
+```
+
+## Troubleshooting
+
+- **`cereal/messaging/bridge` is not built:** Run:
+
+  ```bash
+  scons -u cereal/messaging/bridge
+  ```
+
+- **Mimic is disconnected:** Confirm the device bridge is still running and
+  the IP is reachable.
+- **Mimic reports no camera:** Confirm the device is publishing
+  `roadEncodeData`. Camera display may also wait briefly for the next keyframe.
+- **Exact says another session is running:** Close the other exact window. If
+  none is open, run `--stop-exact`.
+- **Exact cannot connect:** Recheck key-based SSH and the device IP using the
+  command in "Before the first run."
+- **Exact stalls or the physical UI freezes:** Stop the exact window and run
+  `--stop-exact`. If the device UI remains unstable or exact immediately stalls
+  again, fully reboot the device; restarting openpilot is not sufficient. If
+  the problem returns after reboot, use mimic mode because continuous DRM
+  writeback is not reliable on that device/AGNOS combination. Removing
+  `--control` does not address this capture-layer failure.
@@ -136,7 +136,7 @@ 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",
-                         onnx_sha256=None, is_big=False) -> None:
+                         onnx_sha256=None) -> None:
  bundle_json = {
    "short_name": short_name,
    "display_name": custom_name or upstream_branch,
@@ -149,7 +149,6 @@ 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,
  }

@@ -187,8 +186,6 @@ if __name__ == "__main__":
    print(f"No driving_tinygrad.pkl found in {_output_dir}", file=sys.stderr)
    sys.exit(1)

-  is_big = _driving_pkl.name.startswith('big_')
-
  if _pkl:
    new_pkl = _output_dir / f"driving_{_pkl}_tinygrad.pkl"
    if not new_pkl.exists():
@@ -199,4 +196,4 @@ if __name__ == "__main__":
  _model_metadata = generate_chunked_model(_driving_pkl)
  _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)
+                       onnx_sha256=_onnx_sha256)
@@ -47,7 +47,7 @@ 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 --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)
+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)

 echo "[-] committing version $VERSION T=$SECONDS"
 git add -f .
Author	SHA1	Message	Date
royjr	cda9d8f45f	live ui	2026-08-23 11:38:14 -04:00
royjr	53b1070b09	Merge branch 'master' into ccnc-port	2026-08-23 11:05:40 -04:00
royjr	68bf6d8162	Merge branch 'master' into ccnc-port	2026-08-22 13:19:05 -04:00
royjr	8b472291d0	Merge branch 'master' into ccnc-port	2026-08-21 17:12:13 -04:00
royjr	797c8d4293	Update opendbc_repo	2026-08-21 17:09:31 -04:00
royjr	7568528507	Merge branch 'master' into ccnc-port	2026-08-19 12:53:59 -04:00
royjr	6665c3acf6	Merge branch 'master' into ccnc-port	2026-08-17 10:14:33 -04:00
royjr	3b13eb4d0d	Update opendbc_repo	2026-08-17 10:14:19 -04:00
royjr	f7eb4c2561	Update opendbc_repo	2026-08-15 01:39:27 -04:00
royjr	be9255358c	Update opendbc_repo	2026-08-15 01:35:33 -04:00
royjr	f48ccb5d7a	Merge branch 'master' into ccnc-port	2026-08-14 20:42:45 -04:00
royjr	99559d6749	Update opendbc_repo	2026-08-14 20:42:36 -04:00
royjr	4b6f0ffb46	Merge branch 'master' into ccnc-port	2026-08-11 11:56:46 -04:00
royjr	55415382ce	Update opendbc_repo	2026-08-11 11:56:38 -04:00
royjr	9f30901eb6	Merge branch 'master' into ccnc-port	2026-08-10 16:33:50 -04:00
royjr	d2045d24fb	Update opendbc_repo	2026-08-10 16:33:37 -04:00
royjr	6488a11e4d	Merge branch 'master' into ccnc-port	2026-08-02 14:27:34 -04:00
royjr	7b22b65313	Merge branch 'master' into ccnc-port	2026-07-27 15:29:04 -04:00
royjr	b59a50101e	Update opendbc_repo	2026-07-27 15:28:51 -04:00
royjr	3e30962bd3	Merge branch 'master' into ccnc-port	2026-07-25 03:04:23 -04:00
royjr	3274043063	Update opendbc_repo	2026-07-25 03:04:12 -04:00
royjr	c624550d2e	Merge branch 'master' into ccnc-port	2026-07-20 15:52:41 -04:00
royjr	6759038671	Merge branch 'master' into ccnc-port	2026-07-20 09:18:18 -04:00
royjr	aa636e75c8	Merge branch 'master' into ccnc-port	2026-07-16 00:23:49 -04:00
royjr	5ff3c3bd8d	Update opendbc_repo	2026-07-16 00:23:43 -04:00
royjr	1e11b52290	Update opendbc_repo	2026-07-14 00:40:02 -04:00
royjr	76e0204025	Update opendbc_repo	2026-07-14 00:37:13 -04:00
royjr	cc88f2cbd6	Update opendbc_repo	2026-07-10 22:00:25 -04:00
royjr	ee0ac199a4	Update opendbc_repo	2026-07-03 08:08:29 -04:00
royjr	d5ed828eaa	Update opendbc_repo	2026-07-01 19:30:06 -04:00
royjr	9fca585f2a	Merge branch 'master' into ccnc-port	2026-06-30 22:14:33 -04:00
royjr	bb1259303e	Update opendbc_repo	2026-06-30 22:14:23 -04:00
royjr	e135051ca8	Merge branch 'master' into ccnc-port	2026-06-13 22:38:22 -04:00
royjr	12bef55d8a	Update opendbc_repo	2026-06-13 22:12:00 -04:00
royjr	2f7a45e6c8	Merge branch 'master' into ccnc-port	2026-06-08 22:01:57 -04:00
royjr	936ebfc12b	Update opendbc_repo	2026-06-08 22:01:44 -04:00
royjr	aa0c9dc0eb	Merge branch 'master' into ccnc-port	2026-06-04 09:52:35 -04:00
royjr	7476a866e7	Update opendbc_repo	2026-06-04 09:52:06 -04:00
royjr	610d857e33	Merge branch 'master' into ccnc-port	2026-05-28 08:30:40 -04:00
royjr	d2f47407d0	Update opendbc_repo	2026-05-12 21:03:18 -04:00
royjr	db75ec76ea	Merge branch 'master' into ccnc-port	2026-05-12 20:44:57 -04:00
royjr	24066465d7	Update opendbc_repo	2026-05-12 20:44:48 -04:00
royjr	a7abbd6e25	Update opendbc_repo	2026-04-20 18:22:12 -04:00
royjr	878982447c	Merge branch 'master' into ccnc-port	2026-04-19 12:06:46 -04:00
royjr	576527a36b	Merge branch 'master' into ccnc-port	2026-04-17 05:42:35 -04:00
royjr	ef8c35da24	Update opendbc_repo	2026-04-17 05:41:21 -04:00
royjr	85688b1040	Merge branch 'master' into ccnc-port	2026-04-16 19:48:39 -04:00
royjr	0fb2199130	Update opendbc_repo	2026-04-16 19:47:57 -04:00
royjr	d48d756c1d	Update opendbc_repo	2026-04-08 00:56:54 -04:00
royjr	2ed298a0c9	Merge branch 'master' into ccnc-port	2026-04-08 00:51:13 -04:00
royjr	d68f038949	Update opendbc_repo	2026-04-08 00:51:11 -04:00
royjr	7231571e57	Merge branch 'master' into ccnc-port	2026-04-03 23:34:00 -04:00
royjr	b37f1419d3	Update opendbc_repo	2026-04-03 23:33:19 -04:00
royjr	cd85a66790	Merge branch 'master' into ccnc-port	2026-03-26 00:53:07 -04:00
royjr	305ea87daf	Update opendbc_repo	2026-03-26 00:52:44 -04:00
royjr	4bbfc793e0	Merge branch 'master' into ccnc-port	2026-03-15 15:44:59 -04:00
royjr	d5d983676e	Update opendbc_repo	2026-03-13 16:41:05 -04:00
royjr	de8a96a398	Merge branch 'master' into ccnc-port	2026-03-13 16:41:00 -04:00
royjr	0cbf45f699	Merge branch 'master' into ccnc-port	2026-03-11 23:28:59 -04:00
royjr	0d68a3a2ab	Merge branch 'master' into ccnc-port	2026-03-09 19:58:32 -04:00
royjr	9e85a85059	Update opendbc_repo	2026-03-09 19:58:18 -04:00
royjr	0373c327c0	Update opendbc_repo	2026-03-02 10:10:38 -05:00
royjr	efe9e5c200	Update opendbc_repo	2026-03-02 02:15:05 -05:00
royjr	8a249a45dc	Update opendbc_repo	2026-03-02 02:06:16 -05:00
royjr	bdbefe67f6	Update opendbc_repo	2026-03-02 01:40:31 -05:00
royjr	675bb166ad	Merge branch 'master' into ccnc-port	2026-03-01 17:18:11 -05:00
royjr	1b717a7e88	Merge branch 'master' into ccnc-port	2026-03-01 13:23:30 -05:00
royjr	86f55a8ba9	Update opendbc_repo	2026-03-01 13:23:24 -05:00
royjr	629392d2f7	Update opendbc_repo	2026-02-27 16:31:59 -05:00
royjr	bc414bdc8b	Update opendbc_repo	2026-02-26 23:53:26 -05:00
royjr	7ca5649f2c	Merge branch 'master' into ccnc-port	2026-02-26 23:52:46 -05:00
royjr	641ee8fa87	Update opendbc_repo	2026-02-26 23:52:27 -05:00
royjr	56c276158c	Merge branch 'master' into ccnc-port	2026-02-24 14:12:12 -05:00
royjr	c65308a8bd	Update opendbc_repo	2026-02-24 14:12:01 -05:00
royjr	994e526460	Merge branch 'master' into ccnc-port	2026-02-18 12:06:05 -05:00
royjr	1defae36b7	Update opendbc_repo	2026-02-18 12:05:53 -05:00
royjr	8f029fd0ef	Merge branch 'master' into ccnc-port	2026-02-13 23:01:41 -05:00
royjr	ddb46284dc	Update opendbc_repo	2026-02-13 23:01:16 -05:00
royjr	9effc754d9	Merge branch 'master' into ccnc-port	2026-02-06 01:16:06 -05:00
royjr	e49ffc2a2d	Update opendbc_repo	2026-02-06 01:15:59 -05:00
royjr	2cacd0b3e5	Merge branch 'master' into ccnc-port	2026-01-24 12:50:18 -05:00
royjr	c4b8859dff	Update opendbc_repo	2026-01-24 12:50:11 -05:00
royjr	8fb0953205	Merge branch 'master' into ccnc-port	2026-01-11 22:17:38 -05:00
royjr	63d1c8835f	Merge branch 'master' into ccnc-port	2026-01-10 13:03:48 -05:00
royjr	17a185606d	Merge branch 'master' into ccnc-port	2026-01-09 16:40:32 -05:00
royjr	da10131392	Merge branch 'master' into ccnc-port	2025-12-28 17:18:51 -05:00
royjr	7107c2ba14	Merge branch 'master' into ccnc-port	2025-12-23 12:13:48 -05:00
royjr	95b6e877ac	Update opendbc_repo	2025-12-23 12:13:29 -05:00
royjr	eb02c6570e	Update opendbc_repo	2025-12-21 15:43:04 -05:00
royjr	1be8ae31c4	Merge branch 'master' into ccnc-port	2025-12-19 01:04:42 -05:00
royjr	04dcd38856	Update opendbc_repo	2025-12-19 01:04:30 -05:00
royjr	22ccf0d72f	Merge branch 'master' into ccnc-port	2025-12-15 17:02:50 -05:00
royjr	3c969bb627	Merge branch 'master' into ccnc-port	2025-12-13 23:22:22 -05:00
royjr	20f8011feb	Update opendbc_repo	2025-12-13 23:22:11 -05:00
royjr	9cf17e74a1	Merge branch 'master' into ccnc-port	2025-12-12 23:19:56 -05:00
royjr	2c4efdf557	Merge branch 'master' into ccnc-port	2025-12-07 13:29:48 -05:00
royjr	4cd3d3c16c	Merge branch 'master' into ccnc-port	2025-12-02 12:56:21 -05:00
royjr	637f3ae9c8	Merge branch 'master' into ccnc-port	2025-12-01 14:41:03 -05:00
royjr	464ee80f71	Merge branch 'master' into ccnc-port	2025-11-26 00:27:53 -05:00
royjr	2743a04613	Merge branch 'master' into ccnc-port	2025-11-24 18:44:13 -05:00
royjr	7f9978d001	Merge branch 'master' into ccnc-port	2025-11-22 00:21:15 -05:00
royjr	4b83961c67	Merge branch 'master' into ccnc-port	2025-11-21 16:23:22 -05:00
royjr	c00eaf428a	Update opendbc_repo	2025-11-21 16:23:01 -05:00
royjr	0a9993e8d4	Merge branch 'master' into ccnc-port	2025-11-19 16:49:59 -05:00
royjr	0af214a985	Update opendbc_repo	2025-11-19 16:49:51 -05:00
royjr	af43385e3a	Merge branch 'master' into ccnc-port	2025-11-11 10:19:51 -05:00
royjr	0ab2b8c590	Update opendbc_repo	2025-11-07 19:59:50 -05:00
royjr	67ab18a0de	Merge branch 'master' into ccnc-port	2025-11-07 19:23:51 -05:00
royjr	e87dc15b30	Update opendbc_repo	2025-11-07 19:23:37 -05:00
royjr	192d08516c	Merge branch 'master' into ccnc-port	2025-11-02 19:23:00 -05:00
royjr	3cf001c59c	Update opendbc_repo	2025-11-02 19:22:49 -05:00
royjr	f2ccd021da	Merge branch 'master' into ccnc-port	2025-11-02 14:07:54 -05:00
royjr	c9fc900f64	Update opendbc_repo	2025-11-02 14:07:44 -05:00
royjr	3c37c5ce5d	Update opendbc_repo	2025-10-30 11:28:49 -04:00
royjr	7c45889e4e	Merge branch 'master' into ccnc-port	2025-10-30 11:27:50 -04:00
royjr	2aabb7aee8	Merge branch 'master' into ccnc-port	2025-10-24 14:16:09 -04:00
royjr	3859e9962f	Update opendbc_repo	2025-10-24 14:15:51 -04:00
royjr	810efbab72	Merge branch 'master' into ccnc-port	2025-10-18 07:33:11 -04:00
royjr	ec27bec326	Update opendbc_repo	2025-10-18 07:32:33 -04:00
royjr	250d553157	Merge branch 'master' into ccnc-port	2025-10-14 21:57:32 -04:00
royjr	cea54a0ca8	Update opendbc_repo	2025-10-14 21:57:26 -04:00
royjr	8e72d783bd	Update opendbc_repo	2025-10-13 22:41:21 -04:00
royjr	1b0dc103dc	Merge branch 'master' into ccnc-port	2025-10-11 23:51:46 -04:00
royjr	6c364d292b	Update opendbc_repo	2025-10-11 23:51:31 -04:00
royjr	bcdec2ce84	Merge branch 'master' into ccnc-port	2025-10-10 17:29:05 -04:00
royjr	3deaeb3759	Merge branch 'master' into ccnc-port	2025-10-10 15:02:32 -04:00
royjr	c669f0984a	Update opendbc_repo	2025-10-10 15:02:17 -04:00
royjr	46dd946740	Merge branch 'master' into ccnc-port	2025-10-07 01:36:06 -04:00
royjr	9da4b3653e	Update opendbc_repo	2025-10-07 01:35:58 -04:00
royjr	4e21ae7c50	Update opendbc_repo	2025-10-05 06:21:56 -04:00
royjr	bb91e92237	Update opendbc_repo	2025-10-05 06:01:15 -04:00
royjr	14b4c4f85b	Update opendbc_repo	2025-10-02 09:20:32 -04:00
royjr	0660b542c3	Merge branch 'master' into ccnc-port	2025-10-01 16:01:32 -04:00
royjr	2b893b90c9	Update opendbc_repo	2025-10-01 16:01:26 -04:00
royjr	f5139178ed	Merge branch 'master' into ccnc-port	2025-09-30 14:39:57 -04:00
royjr	fb43b755f2	Update opendbc_repo	2025-09-30 14:39:50 -04:00
royjr	07f5b967d8	Merge branch 'master' into ccnc-port	2025-09-24 21:30:29 -04:00
royjr	ea19c7d3bb	Update opendbc_repo	2025-09-24 21:30:17 -04:00
royjr	e461842cbb	Merge branch 'master' into ccnc-port	2025-09-23 05:55:02 -04:00
royjr	a73c9659d5	Update opendbc_repo	2025-09-23 05:54:50 -04:00
royjr	cb796fbc76	Merge branch 'master' into ccnc-port	2025-09-18 20:10:43 -04:00
royjr	6bf75fc557	Update opendbc_repo	2025-09-18 20:10:37 -04:00
royjr	9a1fc28819	Merge branch 'master' into ccnc-port	2025-09-18 13:54:36 -04:00
royjr	0741d05e92	Update opendbc_repo	2025-09-18 13:54:23 -04:00
royjr	1ad008107d	Merge branch 'master' into ccnc-port	2025-09-15 01:40:27 -04:00
royjr	feebd9df93	Reapply "UI: Developer UI (#1233 )" This reverts commit `15e5d2efb9`.	2025-09-15 01:40:21 -04:00
royjr	c2e5ced3e5	Update opendbc_repo	2025-09-15 01:39:51 -04:00
royjr	15e5d2efb9	Revert "UI: Developer UI (#1233 )" This reverts commit `1bb4ca2547`.	2025-09-12 02:10:29 -04:00
royjr	a3929d0b54	Merge branch 'master' into ccnc-port	2025-09-12 01:40:29 -04:00
royjr	794f8f9991	Update opendbc_repo	2025-09-08 09:27:31 -04:00
royjr	68fa5e3f21	Merge branch 'master' into ccnc-port	2025-09-07 13:13:37 -04:00
royjr	86c6cc1f48	Merge branch 'master' into ccnc-port	2025-09-03 22:22:12 -04:00
royjr	eb7ffbf093	Update opendbc_repo	2025-09-03 10:14:58 -04:00
royjr	3919095752	Update opendbc_repo	2025-09-03 10:05:35 -04:00
royjr	74d63be1c3	Merge branch 'master' into ccnc-port	2025-09-03 09:50:55 -04:00
royjr	8894486a1a	Update opendbc_repo	2025-09-03 09:50:49 -04:00
royjr	810599315d	Merge branch 'master' into ccnc-port	2025-08-31 16:53:30 -04:00
royjr	6f3ab810c8	Update opendbc_repo	2025-08-31 16:53:24 -04:00
royjr	230f78b8d3	Merge branch 'master' into ccnc-port	2025-08-26 12:14:46 -04:00
royjr	f1affec088	Update opendbc_repo	2025-08-26 12:14:22 -04:00
royjr	97d8ef242c	Merge branch 'master' into ccnc-port	2025-08-24 15:12:57 -04:00
royjr	a63fff9b45	Update opendbc_repo	2025-08-24 15:12:46 -04:00
royjr	cb3893daaa	Merge branch 'master' into ccnc-port	2025-08-23 10:33:24 -04:00
royjr	29f60df74b	Merge branch 'master' into ccnc-port	2025-08-22 11:18:27 -04:00
royjr	c6c072e1f4	Update opendbc_repo	2025-08-22 11:18:18 -04:00
royjr	d101cbb83e	Update opendbc_repo	2025-08-13 16:00:04 -04:00
royjr	1536d59633	Update opendbc_repo	2025-08-13 15:28:37 -04:00
royjr	dc99b865ae	Merge branch 'master' into ccnc-port	2025-08-13 12:31:14 -04:00
royjr	e59bc027ff	Merge branch 'master' into ccnc-port	2025-08-13 11:58:05 -04:00
royjr	cf7e5efaca	Update opendbc_repo	2025-08-13 11:57:57 -04:00
royjr	4b44f2eb31	Merge branch 'master' into ccnc-port	2025-08-10 09:18:24 -04:00
royjr	107d2ab400	Update opendbc_repo	2025-08-10 09:18:15 -04:00
royjr	5432d9062c	Merge branch 'master' into ccnc-port	2025-08-04 11:52:29 -04:00
royjr	f533f6c843	Merge branch 'master' into ccnc-port	2025-08-02 06:53:54 -04:00
royjr	58e9ac763c	Update opendbc_repo	2025-08-02 06:53:43 -04:00
royjr	cb50d54169	Merge branch 'master-new' into ccnc-port	2025-07-24 20:23:46 -04:00
royjr	bd5de4ed0a	Merge branch 'master-new' into ccnc-port	2025-07-20 23:49:36 -04:00
royjr	0d4073fadb	Merge branch 'master-new' into ccnc-port	2025-07-19 23:18:26 -04:00
royjr	ebc70dcb52	Merge branch 'master-new' into ccnc-port	2025-07-19 14:37:17 -04:00
royjr	4d0426999e	Update opendbc_repo	2025-07-19 14:36:59 -04:00
royjr	286da42573	Merge branch 'master-new' into ccnc-port	2025-07-16 23:48:23 -04:00
royjr	8a836710a9	Update opendbc_repo	2025-07-16 23:48:06 -04:00
royjr	5d515bcf33	Merge branch 'master-new' into ccnc-port	2025-07-07 05:35:55 -04:00
royjr	1c7f6d5133	Update opendbc_repo	2025-07-03 21:24:01 -04:00
royjr	05d57c7aeb	Update opendbc_repo	2025-07-01 18:30:32 -04:00
royjr	e4b0eaf352	Update opendbc_repo	2025-06-28 19:30:28 -04:00
royjr	a710276472	Merge branch 'master-new' into ccnc-port	2025-06-28 19:22:59 -04:00
royjr	af086db671	Merge branch 'master-new' into ccnc-port	2025-06-28 12:13:26 -04:00
royjr	0d9eb0e25e	Update opendbc_repo submodule to latest commit Advanced the opendbc_repo submodule to commit d309f7ec96e37267c94d12fc4bfe2672ad505b06. This pulls in the latest changes from the opendbc repository.	2025-06-26 14:03:56 -04:00
royjr	0616caed6d	Merge branch 'master-new' into ccnc-port	2025-06-25 19:33:53 -04:00
royjr	095337b3c1	Update opendbc_repo	2025-06-25 19:33:38 -04:00
royjr	1edec2d22c	Update opendbc_repo	2025-06-14 16:14:02 -04:00
royjr	affabb9ee0	Update opendbc_repo	2025-06-14 15:55:07 -04:00
royjr	dc27e8711c	Update opendbc_repo	2025-06-14 14:54:32 -04:00
royjr	cf7329a264	Merge branch 'master-new' into ccnc-port	2025-06-11 21:36:06 -04:00
royjr	5ee5ecd820	Merge branch 'master-new' into ccnc-port	2025-06-08 23:25:13 -04:00
royjr	b064f730dd	Update opendbc_repo	2025-06-08 17:54:43 -04:00